tinymce

  • Version 7.4.1
  • Published
  • 8.58 MB
  • No dependencies
  • GPL-2.0-or-later license

Install

npm i tinymce
yarn add tinymce
pnpm add tinymce

Overview

Web based JavaScript HTML WYSIWYG editor control.

Index

Variables

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable tinymce

const tinymce: TinyMCE;

    Classes

    class AstNode

    class AstNode {}

      constructor

      constructor(name: string, type: number);

        property attributes

        attributes?: { name: string; value: string }[] & { map: Record<string, string> };

          property firstChild

          firstChild?: AstNode;

            property lastChild

            lastChild?: AstNode;

              property name

              name: string;

                property next

                next?: AstNode;

                  property parent

                  parent?: AstNode;

                    property prev

                    prev?: AstNode;

                      property raw

                      raw?: boolean;

                        property type

                        type: number;

                          property value

                          value?: string;

                            method append

                            append: (node: AstNode) => AstNode;

                              method attr

                              attr: {
                              (name: string, value: string | null | undefined): AstNode | undefined;
                              (name: Record<string, string>): AstNode;
                              (name: string): string;
                              };

                                method children

                                children: () => AstNode[];

                                  method clone

                                  clone: () => AstNode;

                                    method create

                                    static create: (name: string, attrs?: Record<string, string>) => AstNode;

                                      method empty

                                      empty: () => AstNode;

                                        method getAll

                                        getAll: (name: string) => AstNode[];

                                          method insert

                                          insert: (node: AstNode, refNode: AstNode, before?: boolean) => AstNode;

                                            method isEmpty

                                            isEmpty: (
                                            elements: SchemaMap,
                                            whitespace?: SchemaMap,
                                            predicate?: (node: AstNode) => boolean
                                            ) => boolean;

                                              method remove

                                              remove: () => AstNode;

                                                method replace

                                                replace: (node: AstNode) => AstNode;

                                                  method unwrap

                                                  unwrap: () => void;

                                                    method walk

                                                    walk: (prev?: boolean) => AstNode | null | undefined;

                                                      method wrap

                                                      wrap: (wrapper: AstNode) => AstNode;

                                                        class DomTreeWalker

                                                        class DomTreeWalker {}

                                                          constructor

                                                          constructor(startNode: Node, rootNode: Node);

                                                            method current

                                                            current: () => Node | null | undefined;

                                                              method next

                                                              next: (shallow?: boolean) => Node | null | undefined;

                                                                method prev

                                                                prev: (shallow?: boolean) => Node | null | undefined;

                                                                  method prev2

                                                                  prev2: (shallow?: boolean) => Node | null | undefined;

                                                                    class Editor

                                                                    class Editor implements EditorObservable {}

                                                                      constructor

                                                                      constructor(id: string, options: RawEditorOptions, editorManager: EditorManager);

                                                                        property annotator

                                                                        annotator: Annotator;

                                                                          property baseUri

                                                                          baseUri: URI;

                                                                            property baseURI

                                                                            baseURI: URI;

                                                                              property bindPendingEventDelegates

                                                                              bindPendingEventDelegates: (this: Editor) => void;

                                                                                property bodyElement

                                                                                bodyElement: HTMLElement;

                                                                                  property bookmark

                                                                                  bookmark: any;

                                                                                    property composing

                                                                                    composing: boolean;

                                                                                      property container

                                                                                      container: HTMLElement;

                                                                                        property contentAreaContainer

                                                                                        contentAreaContainer: HTMLElement;

                                                                                          property contentCSS

                                                                                          contentCSS: string[];

                                                                                            property contentDocument

                                                                                            contentDocument: Document;

                                                                                              property contentStyles

                                                                                              contentStyles: string[];

                                                                                                property contentWindow

                                                                                                contentWindow: Window;

                                                                                                  property delegates

                                                                                                  delegates: Record<string, EventUtilsCallback<any>>;

                                                                                                    property destroyed

                                                                                                    destroyed: boolean;

                                                                                                      property dispatch

                                                                                                      dispatch: <K extends string, U extends MappedEvent<EditorEventMap, K>>(
                                                                                                      name: K,
                                                                                                      args?: U,
                                                                                                      bubble?: boolean
                                                                                                      ) => EditorEvent<U>;

                                                                                                        property documentBaseURI

                                                                                                        documentBaseURI: URI;

                                                                                                          property documentBaseUrl

                                                                                                          documentBaseUrl: string;

                                                                                                            property dom

                                                                                                            dom: DOMUtils;

                                                                                                              property editorCommands

                                                                                                              editorCommands: EditorCommands;

                                                                                                                property editorContainer

                                                                                                                editorContainer: HTMLElement;

                                                                                                                  property editorManager

                                                                                                                  editorManager: EditorManager;

                                                                                                                    property editorUpload

                                                                                                                    editorUpload: EditorUpload;

                                                                                                                      property eventRoot

                                                                                                                      eventRoot: Element;

                                                                                                                        property fire

                                                                                                                        fire: <K extends string, U extends MappedEvent<EditorEventMap, K>>(
                                                                                                                        name: K,
                                                                                                                        args?: U,
                                                                                                                        bubble?: boolean
                                                                                                                        ) => EditorEvent<U>;

                                                                                                                          property formatter

                                                                                                                          formatter: Formatter;

                                                                                                                            property formElement

                                                                                                                            formElement: HTMLElement;

                                                                                                                              property formEventDelegate

                                                                                                                              formEventDelegate: (e: Event) => void;

                                                                                                                                property hasEventListeners

                                                                                                                                hasEventListeners: (name: string) => boolean;

                                                                                                                                  property hasHiddenInput

                                                                                                                                  hasHiddenInput: boolean;

                                                                                                                                    property hasVisual

                                                                                                                                    hasVisual: boolean;

                                                                                                                                      property hidden

                                                                                                                                      hidden: boolean;

                                                                                                                                        property id

                                                                                                                                        id: string;

                                                                                                                                          property iframeElement

                                                                                                                                          iframeElement: HTMLIFrameElement;

                                                                                                                                            property iframeHTML

                                                                                                                                            iframeHTML: string;

                                                                                                                                              property initialized

                                                                                                                                              initialized: boolean;

                                                                                                                                                property inline

                                                                                                                                                inline: boolean;

                                                                                                                                                  property isNotDirty

                                                                                                                                                  isNotDirty: boolean;

                                                                                                                                                    property loadedCSS

                                                                                                                                                    loadedCSS: Record<string, any>;

                                                                                                                                                      property mode

                                                                                                                                                      mode: EditorMode;

                                                                                                                                                        property model

                                                                                                                                                        model: Model;

                                                                                                                                                          property notificationManager

                                                                                                                                                          notificationManager: NotificationManager;

                                                                                                                                                            property off

                                                                                                                                                            off: <K extends string>(
                                                                                                                                                            name?: K,
                                                                                                                                                            callback?: (event: EditorEvent<MappedEvent<EditorEventMap, K>>) => void
                                                                                                                                                            ) => EventDispatcher<EditorEventMap>;

                                                                                                                                                              property on

                                                                                                                                                              on: <K extends string>(
                                                                                                                                                              name: K,
                                                                                                                                                              callback: (event: EditorEvent<MappedEvent<EditorEventMap, K>>) => void,
                                                                                                                                                              prepend?: boolean
                                                                                                                                                              ) => EventDispatcher<EditorEventMap>;

                                                                                                                                                                property once

                                                                                                                                                                once: <K extends string>(
                                                                                                                                                                name: K,
                                                                                                                                                                callback: (event: EditorEvent<MappedEvent<EditorEventMap, K>>) => void
                                                                                                                                                                ) => EventDispatcher<EditorEventMap>;

                                                                                                                                                                  property options

                                                                                                                                                                  options: Options;

                                                                                                                                                                    property orgDisplay

                                                                                                                                                                    orgDisplay: string;

                                                                                                                                                                      property orgVisibility

                                                                                                                                                                      orgVisibility: string;

                                                                                                                                                                        property parser

                                                                                                                                                                        parser: DomParser;

                                                                                                                                                                          property plugins

                                                                                                                                                                          plugins: Record<string, Plugin>;

                                                                                                                                                                            property quirks

                                                                                                                                                                            quirks: Quirks;

                                                                                                                                                                              property readonly

                                                                                                                                                                              readonly: boolean;

                                                                                                                                                                                property removed

                                                                                                                                                                                removed: boolean;

                                                                                                                                                                                  property schema

                                                                                                                                                                                  schema: Schema;

                                                                                                                                                                                    property selection

                                                                                                                                                                                    selection: EditorSelection;

                                                                                                                                                                                      property serializer

                                                                                                                                                                                      serializer: DomSerializer;

                                                                                                                                                                                        property shortcuts

                                                                                                                                                                                        shortcuts: Shortcuts;

                                                                                                                                                                                          property startContent

                                                                                                                                                                                          startContent: string;

                                                                                                                                                                                            property suffix

                                                                                                                                                                                            suffix: string;

                                                                                                                                                                                              property targetElm

                                                                                                                                                                                              targetElm: HTMLElement;

                                                                                                                                                                                                property theme

                                                                                                                                                                                                theme: Theme;

                                                                                                                                                                                                  property toggleNativeEvent

                                                                                                                                                                                                  toggleNativeEvent: (this: Editor, name: string, state: boolean) => void;

                                                                                                                                                                                                    property ui

                                                                                                                                                                                                    ui: EditorUi;

                                                                                                                                                                                                      property unbindAllNativeEvents

                                                                                                                                                                                                      unbindAllNativeEvents: (this: Editor) => void;

                                                                                                                                                                                                        property undoManager

                                                                                                                                                                                                        undoManager: UndoManager;

                                                                                                                                                                                                          property windowManager

                                                                                                                                                                                                          windowManager: WindowManager;

                                                                                                                                                                                                            method addCommand

                                                                                                                                                                                                            addCommand: {
                                                                                                                                                                                                            <S>(name: string, callback: EditorCommandCallback<S>, scope: S): void;
                                                                                                                                                                                                            (name: string, callback: EditorCommandCallback<Editor>): void;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              method addQueryStateHandler

                                                                                                                                                                                                              addQueryStateHandler: {
                                                                                                                                                                                                              <S>(name: string, callback: (this: S) => boolean, scope?: S): void;
                                                                                                                                                                                                              (name: string, callback: (this: Editor) => boolean): void;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method addQueryValueHandler

                                                                                                                                                                                                                addQueryValueHandler: {
                                                                                                                                                                                                                <S>(name: string, callback: (this: S) => string, scope: S): void;
                                                                                                                                                                                                                (name: string, callback: (this: Editor) => string): void;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method addShortcut

                                                                                                                                                                                                                  addShortcut: (
                                                                                                                                                                                                                  pattern: string,
                                                                                                                                                                                                                  desc: string,
                                                                                                                                                                                                                  cmdFunc: string | [string, boolean, any] | (() => void),
                                                                                                                                                                                                                  scope?: any
                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                    method addVisual

                                                                                                                                                                                                                    addVisual: (elm?: HTMLElement) => void;

                                                                                                                                                                                                                      method convertURL

                                                                                                                                                                                                                      convertURL: (url: string, name: string, elm?: string | Element) => string;

                                                                                                                                                                                                                        method destroy

                                                                                                                                                                                                                        destroy: (automatic?: boolean) => void;

                                                                                                                                                                                                                          method execCommand

                                                                                                                                                                                                                          execCommand: (
                                                                                                                                                                                                                          cmd: string,
                                                                                                                                                                                                                          ui?: boolean,
                                                                                                                                                                                                                          value?: any,
                                                                                                                                                                                                                          args?: ExecCommandArgs
                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                            method focus

                                                                                                                                                                                                                            focus: (skipFocus?: boolean) => void;

                                                                                                                                                                                                                              method getBody

                                                                                                                                                                                                                              getBody: () => HTMLElement;

                                                                                                                                                                                                                                method getContainer

                                                                                                                                                                                                                                getContainer: () => HTMLElement;

                                                                                                                                                                                                                                  method getContent

                                                                                                                                                                                                                                  getContent: {
                                                                                                                                                                                                                                  (args: { format: 'tree' } & Partial<GetContentArgs>): AstNode;
                                                                                                                                                                                                                                  (args?: Partial<GetContentArgs>): string;
                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                    method getContentAreaContainer

                                                                                                                                                                                                                                    getContentAreaContainer: () => HTMLElement;

                                                                                                                                                                                                                                      method getDoc

                                                                                                                                                                                                                                      getDoc: () => Document;

                                                                                                                                                                                                                                        method getElement

                                                                                                                                                                                                                                        getElement: () => HTMLElement;

                                                                                                                                                                                                                                          method getParam

                                                                                                                                                                                                                                          getParam: {
                                                                                                                                                                                                                                          <K extends keyof BuiltInOptionTypeMap>(
                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                          defaultVal: BuiltInOptionTypeMap[K],
                                                                                                                                                                                                                                          type: K
                                                                                                                                                                                                                                          ): BuiltInOptionTypeMap[K];
                                                                                                                                                                                                                                          <K extends keyof NormalizedEditorOptions>(
                                                                                                                                                                                                                                          name: K,
                                                                                                                                                                                                                                          defaultVal?: NormalizedEditorOptions[K],
                                                                                                                                                                                                                                          type?: keyof BuiltInOptionTypeMap
                                                                                                                                                                                                                                          ): NormalizedEditorOptions[K];
                                                                                                                                                                                                                                          <T>(name: string, defaultVal: T, type?: keyof BuiltInOptionTypeMap): T;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method getWin

                                                                                                                                                                                                                                            getWin: () => Window;

                                                                                                                                                                                                                                              method hasEditableRoot

                                                                                                                                                                                                                                              hasEditableRoot: () => boolean;

                                                                                                                                                                                                                                                method hasFocus

                                                                                                                                                                                                                                                hasFocus: () => boolean;

                                                                                                                                                                                                                                                  method hasPlugin

                                                                                                                                                                                                                                                  hasPlugin: (name: string, loaded?: boolean) => boolean;

                                                                                                                                                                                                                                                    method hide

                                                                                                                                                                                                                                                    hide: () => void;

                                                                                                                                                                                                                                                      method insertContent

                                                                                                                                                                                                                                                      insertContent: (content: string, args?: any) => void;

                                                                                                                                                                                                                                                        method isDirty

                                                                                                                                                                                                                                                        isDirty: () => boolean;

                                                                                                                                                                                                                                                          method isHidden

                                                                                                                                                                                                                                                          isHidden: () => boolean;

                                                                                                                                                                                                                                                            method load

                                                                                                                                                                                                                                                            load: (args?: Partial<SetContentArgs>) => string;

                                                                                                                                                                                                                                                              method nodeChanged

                                                                                                                                                                                                                                                              nodeChanged: (args?: any) => void;

                                                                                                                                                                                                                                                                method queryCommandState

                                                                                                                                                                                                                                                                queryCommandState: (cmd: string) => boolean;

                                                                                                                                                                                                                                                                  method queryCommandSupported

                                                                                                                                                                                                                                                                  queryCommandSupported: (cmd: string) => boolean;

                                                                                                                                                                                                                                                                    method queryCommandValue

                                                                                                                                                                                                                                                                    queryCommandValue: (cmd: string) => string;

                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                      remove: () => void;

                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                        render: () => void;

                                                                                                                                                                                                                                                                          method resetContent

                                                                                                                                                                                                                                                                          resetContent: (initialContent?: string) => void;

                                                                                                                                                                                                                                                                            method save

                                                                                                                                                                                                                                                                            save: (args?: Partial<GetContentArgs>) => string;

                                                                                                                                                                                                                                                                              method setContent

                                                                                                                                                                                                                                                                              setContent: {
                                                                                                                                                                                                                                                                              (content: string, args?: Partial<SetContentArgs>): string;
                                                                                                                                                                                                                                                                              (content: AstNode, args?: Partial<SetContentArgs>): AstNode;
                                                                                                                                                                                                                                                                              (content: Content, args?: Partial<SetContentArgs>): Content;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                method setDirty

                                                                                                                                                                                                                                                                                setDirty: (state: boolean) => void;

                                                                                                                                                                                                                                                                                  method setEditableRoot

                                                                                                                                                                                                                                                                                  setEditableRoot: (state: boolean) => void;

                                                                                                                                                                                                                                                                                    method setProgressState

                                                                                                                                                                                                                                                                                    setProgressState: (state: boolean, time?: number) => void;

                                                                                                                                                                                                                                                                                      method show

                                                                                                                                                                                                                                                                                      show: () => void;

                                                                                                                                                                                                                                                                                        method translate

                                                                                                                                                                                                                                                                                        translate: (text: Untranslated) => TranslatedString;

                                                                                                                                                                                                                                                                                          method uploadImages

                                                                                                                                                                                                                                                                                          uploadImages: () => Promise<UploadResult$1[]>;

                                                                                                                                                                                                                                                                                            class EditorCommands

                                                                                                                                                                                                                                                                                            class EditorCommands {}

                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                              constructor(editor: Editor);

                                                                                                                                                                                                                                                                                                method addCommand

                                                                                                                                                                                                                                                                                                addCommand: {
                                                                                                                                                                                                                                                                                                <S>(command: string, callback: EditorCommandCallback<S>, scope: S): void;
                                                                                                                                                                                                                                                                                                (command: string, callback: EditorCommandCallback<Editor>): void;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  method addCommands

                                                                                                                                                                                                                                                                                                  addCommands: {
                                                                                                                                                                                                                                                                                                  <K extends keyof Commands>(commandList: Commands[K], type: K): void;
                                                                                                                                                                                                                                                                                                  (commandList: Record<string, EditorCommandsCallback>): void;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    method addQueryStateHandler

                                                                                                                                                                                                                                                                                                    addQueryStateHandler: {
                                                                                                                                                                                                                                                                                                    <S>(command: string, callback: (this: S) => boolean, scope: S): void;
                                                                                                                                                                                                                                                                                                    (command: string, callback: (this: Editor) => boolean): void;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      method addQueryValueHandler

                                                                                                                                                                                                                                                                                                      addQueryValueHandler: {
                                                                                                                                                                                                                                                                                                      <S>(command: string, callback: (this: S) => string, scope: S): void;
                                                                                                                                                                                                                                                                                                      (command: string, callback: (this: Editor) => string): void;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        method execCommand

                                                                                                                                                                                                                                                                                                        execCommand: (
                                                                                                                                                                                                                                                                                                        command: string,
                                                                                                                                                                                                                                                                                                        ui?: boolean,
                                                                                                                                                                                                                                                                                                        value?: any,
                                                                                                                                                                                                                                                                                                        args?: ExecCommandArgs
                                                                                                                                                                                                                                                                                                        ) => boolean;

                                                                                                                                                                                                                                                                                                          method queryCommandState

                                                                                                                                                                                                                                                                                                          queryCommandState: (command: string) => boolean;

                                                                                                                                                                                                                                                                                                            method queryCommandSupported

                                                                                                                                                                                                                                                                                                            queryCommandSupported: (command: string) => boolean;

                                                                                                                                                                                                                                                                                                              method queryCommandValue

                                                                                                                                                                                                                                                                                                              queryCommandValue: (command: string) => string;

                                                                                                                                                                                                                                                                                                                class EventDispatcher

                                                                                                                                                                                                                                                                                                                class EventDispatcher<T extends {}> {}

                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                  constructor(settings?: EventDispatcherSettings);

                                                                                                                                                                                                                                                                                                                    method dispatch

                                                                                                                                                                                                                                                                                                                    dispatch: <K extends string, U extends MappedEvent<T, K>>(
                                                                                                                                                                                                                                                                                                                    name: K,
                                                                                                                                                                                                                                                                                                                    args?: U
                                                                                                                                                                                                                                                                                                                    ) => EditorEvent<U>;

                                                                                                                                                                                                                                                                                                                      method fire

                                                                                                                                                                                                                                                                                                                      fire: <K extends string, U extends MappedEvent<T, K>>(
                                                                                                                                                                                                                                                                                                                      name: K,
                                                                                                                                                                                                                                                                                                                      args?: U
                                                                                                                                                                                                                                                                                                                      ) => EditorEvent<U>;

                                                                                                                                                                                                                                                                                                                        method has

                                                                                                                                                                                                                                                                                                                        has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                          method isNative

                                                                                                                                                                                                                                                                                                                          static isNative: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                            method off

                                                                                                                                                                                                                                                                                                                            off: <K extends string>(
                                                                                                                                                                                                                                                                                                                            name?: K,
                                                                                                                                                                                                                                                                                                                            callback?: (event: EditorEvent<MappedEvent<T, K>>) => void
                                                                                                                                                                                                                                                                                                                            ) => this;

                                                                                                                                                                                                                                                                                                                              method on

                                                                                                                                                                                                                                                                                                                              on: <K extends string>(
                                                                                                                                                                                                                                                                                                                              name: K,
                                                                                                                                                                                                                                                                                                                              callback:
                                                                                                                                                                                                                                                                                                                              | false
                                                                                                                                                                                                                                                                                                                              | ((event: EditorEvent<MappedEvent<T, K>>) => void | boolean),
                                                                                                                                                                                                                                                                                                                              prepend?: boolean,
                                                                                                                                                                                                                                                                                                                              extra?: {}
                                                                                                                                                                                                                                                                                                                              ) => this;

                                                                                                                                                                                                                                                                                                                                method once

                                                                                                                                                                                                                                                                                                                                once: <K extends string>(
                                                                                                                                                                                                                                                                                                                                name: K,
                                                                                                                                                                                                                                                                                                                                callback: (event: EditorEvent<MappedEvent<T, K>>) => void,
                                                                                                                                                                                                                                                                                                                                prepend?: boolean
                                                                                                                                                                                                                                                                                                                                ) => this;

                                                                                                                                                                                                                                                                                                                                  class EventUtils

                                                                                                                                                                                                                                                                                                                                  class EventUtils {}

                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                    constructor();

                                                                                                                                                                                                                                                                                                                                      property domLoaded

                                                                                                                                                                                                                                                                                                                                      domLoaded: boolean;

                                                                                                                                                                                                                                                                                                                                        property Event

                                                                                                                                                                                                                                                                                                                                        static Event: EventUtils;

                                                                                                                                                                                                                                                                                                                                          property events

                                                                                                                                                                                                                                                                                                                                          events: Record<number, Record<string, CallbackList<any>>>;

                                                                                                                                                                                                                                                                                                                                            method bind

                                                                                                                                                                                                                                                                                                                                            bind: {
                                                                                                                                                                                                                                                                                                                                            <K extends keyof HTMLElementEventMap>(
                                                                                                                                                                                                                                                                                                                                            target: any,
                                                                                                                                                                                                                                                                                                                                            name: K,
                                                                                                                                                                                                                                                                                                                                            callback: EventUtilsCallback<HTMLElementEventMap[K]>,
                                                                                                                                                                                                                                                                                                                                            scope?: any
                                                                                                                                                                                                                                                                                                                                            ): EventUtilsCallback<HTMLElementEventMap[K]>;
                                                                                                                                                                                                                                                                                                                                            <T = any>(
                                                                                                                                                                                                                                                                                                                                            target: any,
                                                                                                                                                                                                                                                                                                                                            names: string,
                                                                                                                                                                                                                                                                                                                                            callback: EventUtilsCallback<T>,
                                                                                                                                                                                                                                                                                                                                            scope?: any
                                                                                                                                                                                                                                                                                                                                            ): EventUtilsCallback<T>;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              method cancel

                                                                                                                                                                                                                                                                                                                                              cancel: <T>(e: EventUtilsEvent<T>) => boolean;

                                                                                                                                                                                                                                                                                                                                                method clean

                                                                                                                                                                                                                                                                                                                                                clean: (target: any) => this;

                                                                                                                                                                                                                                                                                                                                                  method destroy

                                                                                                                                                                                                                                                                                                                                                  destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                    method dispatch

                                                                                                                                                                                                                                                                                                                                                    dispatch: (target: any, name: string, args?: {}) => this;

                                                                                                                                                                                                                                                                                                                                                      method fire

                                                                                                                                                                                                                                                                                                                                                      fire: (target: any, name: string, args?: {}) => this;

                                                                                                                                                                                                                                                                                                                                                        method unbind

                                                                                                                                                                                                                                                                                                                                                        unbind: {
                                                                                                                                                                                                                                                                                                                                                        <K extends keyof HTMLElementEventMap>(
                                                                                                                                                                                                                                                                                                                                                        target: any,
                                                                                                                                                                                                                                                                                                                                                        name: K,
                                                                                                                                                                                                                                                                                                                                                        callback?: EventUtilsCallback<HTMLElementEventMap[K]>
                                                                                                                                                                                                                                                                                                                                                        ): this;
                                                                                                                                                                                                                                                                                                                                                        <T = any>(
                                                                                                                                                                                                                                                                                                                                                        target: any,
                                                                                                                                                                                                                                                                                                                                                        names: string,
                                                                                                                                                                                                                                                                                                                                                        callback?: EventUtilsCallback<T>
                                                                                                                                                                                                                                                                                                                                                        ): this;
                                                                                                                                                                                                                                                                                                                                                        (target: any): this;
                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                          class ScriptLoader

                                                                                                                                                                                                                                                                                                                                                          class ScriptLoader {}

                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                            constructor(settings?: ScriptLoaderSettings);

                                                                                                                                                                                                                                                                                                                                                              property ScriptLoader

                                                                                                                                                                                                                                                                                                                                                              static ScriptLoader: ScriptLoader;

                                                                                                                                                                                                                                                                                                                                                                method add

                                                                                                                                                                                                                                                                                                                                                                add: (url: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                  method isDone

                                                                                                                                                                                                                                                                                                                                                                  isDone: (url: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                    method load

                                                                                                                                                                                                                                                                                                                                                                    load: (url: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                      method loadQueue

                                                                                                                                                                                                                                                                                                                                                                      loadQueue: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        method loadScript

                                                                                                                                                                                                                                                                                                                                                                        loadScript: (url: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                          method loadScripts

                                                                                                                                                                                                                                                                                                                                                                          loadScripts: (scripts: string[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                            method markDone

                                                                                                                                                                                                                                                                                                                                                                            markDone: (url: string) => void;

                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                              remove: (url: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                class Shortcuts

                                                                                                                                                                                                                                                                                                                                                                                class Shortcuts {}

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(editor: Editor);

                                                                                                                                                                                                                                                                                                                                                                                    method add

                                                                                                                                                                                                                                                                                                                                                                                    add: (
                                                                                                                                                                                                                                                                                                                                                                                    pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                    desc: string | null,
                                                                                                                                                                                                                                                                                                                                                                                    cmdFunc: CommandFunc,
                                                                                                                                                                                                                                                                                                                                                                                    scope?: any
                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                      remove: (pattern: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                        class URI

                                                                                                                                                                                                                                                                                                                                                                                        class URI {}

                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                          constructor(url: string, settings?: URISettings);

                                                                                                                                                                                                                                                                                                                                                                                            property anchor

                                                                                                                                                                                                                                                                                                                                                                                            anchor: string;

                                                                                                                                                                                                                                                                                                                                                                                              property authority

                                                                                                                                                                                                                                                                                                                                                                                              authority: string;

                                                                                                                                                                                                                                                                                                                                                                                                property directory

                                                                                                                                                                                                                                                                                                                                                                                                directory: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property file

                                                                                                                                                                                                                                                                                                                                                                                                  file: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property host

                                                                                                                                                                                                                                                                                                                                                                                                    host: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                                      password: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property port

                                                                                                                                                                                                                                                                                                                                                                                                          port: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property protocol

                                                                                                                                                                                                                                                                                                                                                                                                            protocol: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                                                                                                                                              query: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property relative

                                                                                                                                                                                                                                                                                                                                                                                                                relative: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  property settings

                                                                                                                                                                                                                                                                                                                                                                                                                  settings: URISettings;

                                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property user

                                                                                                                                                                                                                                                                                                                                                                                                                      user: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property userInfo

                                                                                                                                                                                                                                                                                                                                                                                                                        userInfo: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          method getDocumentBaseUrl

                                                                                                                                                                                                                                                                                                                                                                                                                          static getDocumentBaseUrl: (loc: {
                                                                                                                                                                                                                                                                                                                                                                                                                          protocol: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          href?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          pathname?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          }) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                            method getURI

                                                                                                                                                                                                                                                                                                                                                                                                                            getURI: (noProtoHost?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                              method isDomSafe

                                                                                                                                                                                                                                                                                                                                                                                                                              static isDomSafe: (
                                                                                                                                                                                                                                                                                                                                                                                                                              uri: string,
                                                                                                                                                                                                                                                                                                                                                                                                                              context?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                              options?: SafeUriOptions
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                method isSameOrigin

                                                                                                                                                                                                                                                                                                                                                                                                                                isSameOrigin: (uri: URI) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method parseDataUri

                                                                                                                                                                                                                                                                                                                                                                                                                                  static parseDataUri: (uri: string) => { type: string | undefined; data: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                    method setPath

                                                                                                                                                                                                                                                                                                                                                                                                                                    setPath: (path: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method toAbsolute

                                                                                                                                                                                                                                                                                                                                                                                                                                      toAbsolute: (uri: string, noHost?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toAbsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                        toAbsPath: (base: string, path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method toRelative

                                                                                                                                                                                                                                                                                                                                                                                                                                          toRelative: (uri: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method toRelPath

                                                                                                                                                                                                                                                                                                                                                                                                                                            toRelPath: (base: string, path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AddOnManager

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AddOnManager<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property add

                                                                                                                                                                                                                                                                                                                                                                                                                                                add: (id: string, addOn: AddOnConstructor<T>) => AddOnConstructor<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property createUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                  createUrl: (baseUrl: UrlObject, dep: string | UrlObject) => UrlObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property get

                                                                                                                                                                                                                                                                                                                                                                                                                                                    get: (name: string) => AddOnConstructor<T> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                      items: AddOnConstructor<T>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property load

                                                                                                                                                                                                                                                                                                                                                                                                                                                        load: (name: string, addOnUrl: string | UrlObject) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property lookup

                                                                                                                                                                                                                                                                                                                                                                                                                                                          lookup: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                          string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          instance: AddOnConstructor<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                            remove: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property requireLangPack

                                                                                                                                                                                                                                                                                                                                                                                                                                                              requireLangPack: (name: string, languages?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                urls: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property waitFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  waitFor: (name: string, state?: WaitState) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Annotator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Annotator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property annotate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      annotate: (name: string, data: DecoratorData) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property annotationChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        annotationChanged: (name: string, f: AnnotationListenerApi) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property getAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getAll: (name: string) => Record<string, Element[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property register

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            register: (name: string, settings: AnnotatorSettings) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remove: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property removeAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeAll: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BookmarkManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BookmarkManager {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getBookmark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getBookmark: (type?: number, normalized?: boolean) => Bookmark;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property moveToBookmark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      moveToBookmark: (bookmark: Bookmark) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ControlSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ControlSelection {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hideResizeRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hideResizeRect: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isResizable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isResizable: (elm: Element) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property showResizeRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showResizeRect: (elm: HTMLElement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property updateResizeRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateResizeRect: (evt: EditorEvent<any>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Delay {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property setEditorInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setEditorInterval: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: () => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      time?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property setEditorTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setEditorTimeout: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: () => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        time?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DomParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DomParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property addAttributeFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addAttributeFilter: (name: string, callback: ParserFilterCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property addNodeFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addNodeFilter: (name: string, callback: ParserFilterCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getAttributeFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getAttributeFilters: () => ParserFilter[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getNodeFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getNodeFilters: () => ParserFilter[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parse: (html: string, args?: ParserArgs) => AstNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property removeAttributeFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeAttributeFilter: (name: string, callback?: ParserFilterCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property removeNodeFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeNodeFilter: (name: string, callback?: ParserFilterCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          schema: Schema;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DomParserSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DomParserSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property allow_conditional_comments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allow_conditional_comments?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property allow_html_data_urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                allow_html_data_urls?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property allow_html_in_named_anchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allow_html_in_named_anchor?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property allow_mathml_annotation_encodings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allow_mathml_annotation_encodings?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allow_script_urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allow_script_urls?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property allow_svg_data_urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allow_svg_data_urls?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allow_unsafe_link_target?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property blob_cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            blob_cache?: BlobCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property convert_fonts_to_spans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              convert_fonts_to_spans?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property convert_unsafe_embeds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                convert_unsafe_embeds?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  document?: Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fix_list_elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fix_list_elements?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property font_size_legacy_values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      font_size_legacy_values?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property forced_root_block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forced_root_block?: boolean | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property forced_root_block_attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forced_root_block_attrs?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property inline_styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inline_styles?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pad_empty_with_br

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pad_empty_with_br?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property preserve_cdata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                preserve_cdata?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property root_name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  root_name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sandbox_iframes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sandbox_iframes?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sandbox_iframes_exclusions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sandbox_iframes_exclusions?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sanitize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sanitize?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          validate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DomSerializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DomSerializer extends DomSerializerImpl {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DomSerializerSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DomSerializerSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends DomParserSettings,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WriterSettings,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SchemaSettings,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HtmlSerializerSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property remove_trailing_brs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                remove_trailing_brs?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property url_converter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url_converter?: URLConverter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property url_converter_scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    url_converter_scope?: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DOMUtils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DOMUtils {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        add: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parentElm: RunArguments,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        attrs?: Record<string, string | boolean | number | null>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html?: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addClass: (elm: RunArguments<Element>, cls: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property addStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addStyle: (cssText: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bind: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <K extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              target: Target,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func: Callback<K>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scope?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): Callback<K>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <K extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              target: Target[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func: Callback<K>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scope?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): Callback<K>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property boundEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                boundEvents: BoundEvent[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property boxModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  boxModel: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clone: (node: Node, deep: boolean) => Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <K extends keyof HTMLElementTagNameMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      attrs?: Record<string, string | boolean | number | null>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html?: string | Node | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): HTMLElementTagNameMap[K];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      attrs?: Record<string, string | boolean | number | null>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html?: string | Node | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property createFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createFragment: (html?: string) => DocumentFragment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property createHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createHTML: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          attrs?: Record<string, string | null>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property createRng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createRng: () => Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decode: (text: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dispatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dispatch: (target: Node | Window, name: string, evt?: {}) => EventUtils;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property doc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    doc: Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dumpRng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dumpRng: (r: Range) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        encode: (text: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          events: EventUtils;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            files: Record<string, boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property findCommonAncestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              findCommonAncestor: (a: Node, b: Node) => Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fire

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fire: (target: Node | Window, name: string, evt?: {}) => EventUtils;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T extends Node>(elm: T): T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (elm: string): HTMLElement | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getAttrib

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getAttrib: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elm: string | Element | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultVal?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getAttribs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAttribs: (elm: string | Element) => NamedNodeMap | Attr[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getContentEditable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getContentEditable: (node: Node) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property getContentEditableParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getContentEditableParent: (node: Node) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getNext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            selector: string | ((node: Node) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getOuterHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getOuterHTML: (elm: string | Node) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getParent: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <K extends keyof HTMLElementTagNameMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selector: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                root?: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): HTMLElementTagNameMap[K] | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <T extends Element>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selector: string | ((node: Node) => node is T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                root?: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): T | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selector?: string | ((node: Node) => boolean | void),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                root?: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Node | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getParents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getParents: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <K extends keyof HTMLElementTagNameMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elm: string | HTMLElementTagNameMap[K] | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  selector: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  root?: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  collect?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): Array<HTMLElementTagNameMap[K]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T extends Element>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  selector: string | ((node: Node) => node is T),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  root?: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  collect?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elm: string | Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  selector?: string | ((node: Node) => boolean | void),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  root?: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  collect?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getPos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getPos: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elm: string | Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rootElm?: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    x: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    y: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getPrev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPrev: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: string | ((node: Node) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getRect: (elm: string | HTMLElement) => GeomRect;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property getRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getRoot: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getSize: (elm: string | HTMLElement) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            w: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            h: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getStyle: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (elm: Element, name: string, computed: true): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (elm: string | Element | null, name: string, computed?: boolean):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getViewPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getViewPort: (argWin?: Window) => GeomRect;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasClass: (elm: string | Element, cls: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hide: (elm: string | Node | Node[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property insertAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      insertAfter: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T extends Node>(node: T | T[], reference: string | Node): T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T extends Node>(node: RunArguments<T>, reference: string | Node): RunResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeof node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property is

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        is: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T extends Element>(elm: Node | Node[] | null, selector: string): elm is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (elm: Node | Node[] | null, selector: string): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBlock: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (node: Node | null): node is HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (node: string): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isChildOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isChildOf: (node: Node, parent: Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isEditable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEditable: (node: Node | null | undefined) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEmpty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elements?: Record<string, any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: IsEmptyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isHidden

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isHidden: (elm: string | Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loadCSS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loadCSS: (url: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nodeIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nodeIndex: (node: Node, normalized?: boolean) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parseStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parseStyle: (cssText: string) => Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: T | T[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepChildren?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): typeof node extends Array<any> ? T[] : T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends Node>(node: string, keepChildren?: boolean): T | false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property removeAllAttribs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeAllAttribs: (e: RunArguments<Element>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeClass: (elm: RunArguments<Element>, cls: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rename: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <K extends keyof HTMLElementTagNameMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elm: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: K
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): HTMLElementTagNameMap[K];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (elm: Element, name: string): Element;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  replace: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T extends Node>(newElm: Node, oldElm: T | T[], keepChildren?: boolean): T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  newElm: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oldElm: RunArguments<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keepChildren?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): false | T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    root: Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      schema: Schema;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        select: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scope?: string | Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): Array<HTMLElementTagNameMap[K]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T extends HTMLElement = HTMLElement>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selector: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scope?: string | Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): T[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property serializeStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializeStyle: (stylesArg: StyleMap, name?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property setAttrib

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setAttrib: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elm: RunArguments<Element>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string | boolean | number | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property setAttribs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setAttribs: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elm: RunArguments<Element>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              attrs: Record<string, string | boolean | number | null>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property setHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setHTML: (elm: RunArguments<Element>, html: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property setOuterHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setOuterHTML: (elm: string | Node | Node[], html: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property setStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setStyle: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elm: string | Element | Element[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string | number | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property setStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setStyles: (elm: string | Element | Element[], stylesArg: StyleMap) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        settings: Partial<DOMUtilsSettings>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          show: (elm: string | Node | Node[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property split

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            split: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T extends Node>(parentElm: Node, splitElm: Node, replacementElm: T):
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T extends Node>(parentElm: Node, splitElm: T): T | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property stdMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stdMode: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                styles: Styles;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property styleSheetLoader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  styleSheetLoader: StyleSheetLoader;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property toggleClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toggleClass: (elm: RunArguments<Element>, cls: string, state?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property unbind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unbind: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <K extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      target: Target,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): EventUtils;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <K extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      target: Target[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): EventUtils[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uniqueId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uniqueId: (prefix?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property win

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          win: Window;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            run: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <R, T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: DOMUtils,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elm: T | T[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func: (node: T) => R,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scope?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): T | T[] extends any[] ? R[] : R;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <R, T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: DOMUtils,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elm: RunArguments<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func: (node: T) => R,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scope?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): false | R | RunResult<T, R> | R[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorManager extends Observable<EditorManagerEventMap> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property activeEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activeEditor: Editor | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property addI18n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addI18n: (code: string, item: Record<string, string>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property baseURI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseURI: URI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property baseURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      baseURL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultOptions: RawEditorOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property documentBaseURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          documentBaseURL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property focusedEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            focusedEditor: Editor | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property i18n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i18n: I18n;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property majorVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                majorVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minorVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minorVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property releaseDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    releaseDate: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property suffix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suffix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property translate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        translate: (text: Untranslated) => TranslatedString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property triggerSave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          triggerSave: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            add: (this: EditorManager, editor: Editor) => Editor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createEditor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: EditorManager,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: RawEditorOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Editor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method execCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                execCommand: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: EditorManager,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cmd: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ui: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (this: EditorManager): Editor[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (this: EditorManager, id: string | number): Editor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    init: (this: EditorManager, options: RawEditorOptions) => Promise<Editor[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method overrideDefaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      overrideDefaults: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      this: EditorManager,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultOptions: Partial<RawEditorOptions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remove: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (this: EditorManager): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (this: EditorManager, selector: string): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (this: EditorManager, editor: Editor): Editor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setActive: (this: EditorManager, editor: Editor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setup: (this: EditorManager) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorModeApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorModeApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deactivate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property editorReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editorReadOnly: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EditorObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EditorObservable extends Observable<EditorEventMap> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method bindPendingEventDelegates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bindPendingEventDelegates: (this: Editor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toggleNativeEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toggleNativeEvent: (this: Editor, name: string, state: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method unbindAllNativeEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unbindAllNativeEvents: (this: Editor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorOptions extends NormalizedEditorOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property a11y_advanced_options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                a11y_advanced_options: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allow_unsafe_link_target: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property anchor_bottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    anchor_bottom: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property anchor_top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      anchor_top: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property automatic_uploads

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        automatic_uploads: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property block_formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          block_formats: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property body_class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            body_class: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property body_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              body_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property br_newline_selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                br_newline_selector: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property color_cols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  color_cols: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property color_cols_background

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    color_cols_background: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property color_cols_foreground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      color_cols_foreground: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property color_default_background

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        color_default_background: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property color_default_foreground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          color_default_foreground: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property color_map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color_map: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property content_css

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              content_css: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contextmenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contextmenu: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property convert_unsafe_embeds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  convert_unsafe_embeds: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property custom_colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    custom_colors: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property default_font_stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      default_font_stack: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property document_base_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        document_base_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property draggable_modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          draggable_modal: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property editable_class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editable_class: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property editable_root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editable_root: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property font_css

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                font_css: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property font_family_formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  font_family_formats: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property font_size_classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    font_size_classes: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property font_size_formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      font_size_formats: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property font_size_input_default_unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        font_size_input_default_unit: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property font_size_legacy_values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          font_size_legacy_values: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property font_size_style_values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            font_size_style_values: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property forced_root_block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forced_root_block: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property forced_root_block_attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                forced_root_block_attrs: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property format_noneditable_selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  format_noneditable_selector: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    height: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property highlight_on_focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      highlight_on_focus: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property iframe_attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iframe_attrs: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property images_file_types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          images_file_types: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property images_upload_base_path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            images_upload_base_path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property images_upload_credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              images_upload_credentials: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property images_upload_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                images_upload_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property indent_use_margin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  indent_use_margin: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property indentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    indentation: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property init_content_sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      init_content_sync: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inline_boundaries_selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inline_boundaries_selector: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            language: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property language_load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              language_load: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property language_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                language_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property line_height_formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  line_height_formats: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property menu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    menu: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    items: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property menubar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      menubar: boolean | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        model: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property newdocument_content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          newdocument_content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property no_newline_selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            no_newline_selector: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property noneditable_class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noneditable_class: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property noneditable_regexp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noneditable_regexp: RegExp[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property object_resizing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  object_resizing: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pad_empty_with_br

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pad_empty_with_br: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property paste_as_text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      paste_as_text: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property preview_styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        preview_styles: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property promotion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          promotion: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property readonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property removed_menuitems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removed_menuitems: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sandbox_iframes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sandbox_iframes: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sandbox_iframes_exclusions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sandbox_iframes_exclusions: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text_patterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text_patterns: Pattern[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text_patterns_lookup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text_patterns_lookup: DynamicPatternsLookup;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property toolbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toolbar: boolean | string | string[] | Array<ToolbarGroup>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property toolbar_groups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toolbar_groups: Record<string, GroupToolbarButtonSpec>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property toolbar_location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toolbar_location: ToolbarLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property toolbar_mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toolbar_mode: ToolbarMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property toolbar_persist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toolbar_persist: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property toolbar_sticky

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toolbar_sticky: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property toolbar_sticky_offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toolbar_sticky_offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property visual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      visual: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property visual_anchor_class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        visual_anchor_class: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property visual_table_class

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visual_table_class: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property xss_sanitization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              xss_sanitization: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorSelection {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bookmarkManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bookmarkManager: BookmarkManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property collapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    collapse: (toStart?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property controlSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      controlSelection: ControlSelection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dom: DOMUtils;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor: Editor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              expand: (options?: { type: 'word' }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getBookmark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getBookmark: (type?: number, normalized?: boolean) => Bookmark;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getBoundingClientRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getBoundingClientRect: () => ClientRect | DOMRect;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property getContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getContent: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    format: 'tree';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & Partial<GetSelectionContentArgs>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): AstNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (args?: Partial<GetSelectionContentArgs>): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getEnd: (real?: boolean) => Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getNode: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property getRng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getRng: () => Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getScrollContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getScrollContainer: () => HTMLElement | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getSel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSel: () => Selection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getSelectedBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getSelectedBlocks: (startElm?: Element, endElm?: Element) => Element[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property getStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getStart: (real?: boolean) => Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isCollapsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isCollapsed: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isEditable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isEditable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isForward

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isForward: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property moveToBookmark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          moveToBookmark: (bookmark: Bookmark) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property normalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            normalize: () => Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placeCaretAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placeCaretAt: (clientX: number, clientY: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scrollIntoView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollIntoView: (elm?: HTMLElement, alignToTop?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  select: (node: Node, content?: boolean) => Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selectorChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selectorChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selector: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    active: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selector: String;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parents: Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => EditorSelection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property selectorChangedWithUnbind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selectorChangedWithUnbind: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      active: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector: String;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parents: Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unbind: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property serializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializer: DomSerializer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property setContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setContent: (content: string, args?: Partial<SetSelectionContentArgs>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property setCursorLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setCursorLocation: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (node: Node, offset: number): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property setNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setNode: (elm: Element) => Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property setRng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setRng: (rng: Range, forward?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property win

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  win: Window;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Entities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Entities {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      decode: (text: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property encodeAllRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        encodeAllRaw: (text: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property encodeNamed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encodeNamed: (text: string, attr?: boolean, entities?: EntitiesMap) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property encodeNumeric

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encodeNumeric: (text: string, attr?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property encodeRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encodeRaw: (text: string, attr?: boolean) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getEncodeFunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getEncodeFunc: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                entities?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) =>