jodit 4.4.2 → 4.4.4

package/types/config.d.ts

@@ -1,9 +1,30 @@
-/*!
- * Jodit Editor (https://xdsoft.net/jodit/)
- * Released under MIT see LICENSE.txt in the project root for license information.
- * Copyright (c) 2013-2025 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
- */
-import type { Attributes, ButtonsOption, Controls, IControlType, IDictionary, IExtraPlugin, InsertMode, IUIButtonState, IViewOptions, NodeFunction, Nullable } from "./types";
+import type { AjaxOptions } from "./types/index.d.ts";
+import type { IDialogOptions } from "./types/index.d.ts";
+import type { IFileBrowserOptions } from "./types/index.d.ts";
+import type { ImageEditorOptions } from "./types/index.d.ts";
+import type { IUploaderOptions } from "./types/index.d.ts";
+import type { IUploader } from "./types/index.d.ts";
+import type { HTMLTagNames } from "./types/index.d.ts";
+import type { AiAssistantSettings } from "./plugins/ai-assistant/interface.d.ts";
+import type { IDictionary } from "./types/index.d.ts";
+import type { Nullable } from "./types/index.d.ts";
+import type { ImagePropertiesOptions } from "./plugins/image-properties/interface.d.ts";
+import type { IControlType } from "./types/index.d.ts";
+import type { IJodit } from "./types/index.d.ts";
+import type { formTemplate } from "./plugins/link/template.d.ts";
+import type { IUIForm } from "./types/index.d.ts";
+import type { IUIOption } from "./types/index.d.ts";
+import type { ButtonsOption } from "./types/index.d.ts";
+import type { InsertMode } from "./types/index.d.ts";
+import type { FuzzySearch } from "./types/index.d.ts";
+import type { ISourceEditor } from "./types/index.d.ts";
+import type { ISpeechRecognizeConstructor } from "./plugins/speech-recognize/interface.d.ts";
+import type { Attributes } from "./types/index.d.ts";
+import type { Controls } from "./types/index.d.ts";
+import type { IExtraPlugin } from "./types/index.d.ts";
+import type { IUIButtonState } from "./types/index.d.ts";
+import type { IViewOptions } from "./types/index.d.ts";
+import type { NodeFunction } from "./types/index.d.ts";
 /**
  * Default Editor's Configuration
  */
@@ -563,7 +584,7 @@ declare class Config implements IViewOptions {
      * @example
      * ```jsx
      * import React, {useState, useRef} from 'react';
-     * import JoditEditor from "jodit-react";
+     * import type JoditEditor from "jodit-react";
      *
      * const config = {
      * 	createAttributes: {
@@ -698,3 +719,828 @@ declare class Config implements IViewOptions {
     static get defaultOptions(): Config;
 }
 export { Config };
+interface Config {
+    /**
+     * A set of key/value pairs that configure the Ajax request. All settings are optional
+     */
+    defaultAjaxOptions: AjaxOptions;
+}
+interface Config {
+    dialog: IDialogOptions;
+}
+interface Config {
+    filebrowser: IFileBrowserOptions;
+}
+interface Config {
+    history: {
+        enable: boolean;
+        /**
+         * Limit of history length
+         */
+        maxHistoryLength: number;
+        /**
+         * Delay on every change
+         */
+        timeout: number;
+    };
+}
+interface Config {
+    imageeditor: ImageEditorOptions;
+}
+interface Config {
+    /**
+     * Enable drag and drop file editor
+     */
+    enableDragAndDropFileToEditor: boolean;
+    uploader: IUploaderOptions<IUploader>;
+}
+interface Config {
+    /**
+     * Create helper
+     */
+    addNewLine: boolean;
+    /**
+     * What kind of tags it will be impact
+     */
+    addNewLineTagsTriggers: HTMLTagNames[];
+    /**
+     * On dbl click on empty space of editor it add new P element
+     * @example
+     * ```js
+     * Jodit.make('#editor', {
+     *   addNewLineOnDBLClick: false // disable
+     * })
+     * ```
+     */
+    addNewLineOnDBLClick: boolean;
+    /**
+     * Absolute delta between cursor position and edge(top or bottom)
+     * of element when show line
+     */
+    addNewLineDeltaShow: number;
+}
+interface Config {
+    aiAssistant: AiAssistantSettings;
+}
+interface Config {
+    delete: {
+        hotkeys: {
+            delete: string[];
+            deleteWord: string[];
+            deleteSentence: string[];
+            backspace: string[];
+            backspaceWord: string[];
+            backspaceSentence: string[];
+        };
+    };
+}
+interface Config {
+    cleanHTML: {
+        timeout: number;
+        /**
+         * Replace &amp;nbsp; to plain space
+         */
+        replaceNBSP: boolean;
+        /**
+         * Remove empty P tags, if they are not in the beginning of the text
+         */
+        fillEmptyParagraph: boolean;
+        /**
+         * Remove empty elements
+         */
+        removeEmptyElements: boolean;
+        /**
+         * Replace old tags to new eg. <i> to <em>, <b> to <strong>
+         */
+        replaceOldTags: IDictionary<HTMLTagNames> | false;
+        /**
+         * You can use an iframe with the sandbox attribute to safely paste and test HTML code.
+         * It prevents scripts and handlers from running, but it does slow things down.
+         *
+         * ```javascript
+         * Jodit.make('#editor', {
+         * 	 cleanHTML: {
+         * 	 	 useIframeSandbox: true
+         * 	 }
+         * 	});
+         * ```
+         */
+        useIframeSandbox: boolean;
+        /**
+         * Remove onError attributes
+         */
+        removeOnError: boolean;
+        /**
+         * Safe href="javascript:" links
+         */
+        safeJavaScriptLink: boolean;
+        /**
+         * The allowTags option defines which elements will remain in the
+         * edited text when the editor saves. You can use this limit the returned HTML.
+         * @example
+         * ```javascript
+         * const jodit = new Jodit.make('#editor', {
+         *    cleanHTML: {
+         *       cleanOnPaste: false
+         *    }
+         * });
+         * ```
+         * @example
+         * ```javascript
+         * const editor = Jodit.make('#editor', {
+         *     cleanHTML: {
+         *         allowTags: 'p,a[href],table,tr,td, img[src=1.png]' // allow only <p>,<a>,<table>,<tr>,<td>,<img> tags and
+         *         for <a> allow only `href` attribute and <img> allow only `src` attribute == '1.png'
+         *     }
+         * });
+         * editor.value = 'Sorry! <strong>Goodby</strong>\
+         * <span>mr.</span> <a style="color:red" href="https://xdsoft.net">Freeman</a>';
+         * console.log(editor.value); //Sorry! <a href="https://xdsoft.net">Freeman</a>
+         * ```
+         *
+         * @example
+         * ```javascript
+         * const editor = Jodit.make('#editor', {
+         *     cleanHTML: {
+         *         allowTags: {
+         *             p: true,
+         *             a: {
+         *                 href: true
+         *             },
+         *             table: true,
+         *             tr: true,
+         *             td: true,
+         *             img: {
+         *                 src: '1.png'
+         *             }
+         *         }
+         *     }
+         * });
+         * ```
+         */
+        allowTags: false | string | IDictionary<string>;
+        denyTags: false | string | IDictionary<string>;
+        /**
+         * Node filtering rules that do not need to be applied to content
+         * The full list of rules is generated dynamically from the folder
+         * https://github.com/xdan/jodit/tree/main/src/plugins/clean-html/helpers/visitor/filters
+         */
+        disableCleanFilter: Nullable<Set<string>>;
+    };
+}
+interface Config {
+    /**
+     * Draggable elements
+     */
+    draggableTags: string | string[];
+}
+interface Config {
+    dtd: {
+        /**
+         * Remove extra br element inside block element after pasting
+         */
+        removeExtraBr: boolean;
+        /**
+         * Check when inserting a block element if it can be inside another block element (according `blockLimits`)
+         */
+        checkBlockNesting: boolean;
+        /**
+         * List of elements that contain other blocks
+         */
+        blockLimits: IDictionary<1>;
+    };
+}
+interface Config {
+    autofocus: boolean;
+    cursorAfterAutofocus: 'start' | 'end';
+    saveSelectionOnBlur: boolean;
+}
+interface Config {
+    defaultFontSizePoints: 'px' | 'pt';
+}
+interface Config {
+    /**
+     * Open WYSIWYG in full screen
+     * @example
+     * ```javascript
+     * var editor = Jodit.make({
+     *     fullsize: true // fullsize editor
+     * });
+     * ```
+     * @example
+     * ```javascript
+     * var editor = Jodit.make();
+     * editor.e.fire('toggleFullSize');
+     * editor.e.fire('toggleFullSize', true); // fullsize
+     * editor.e.fire('toggleFullSize', false); // usual mode
+     * ```
+     */
+    fullsize: boolean;
+    /**
+     * True, after `fullsize` -  all editors elements above jodit will get `jodit_fullsize-box_true` class (z-index: 100000 !important;)
+     */
+    globalFullSize: boolean;
+}
+interface Config {
+    /**
+     * You can redefine hotkeys for some command
+     *
+     * @example
+     * ```js
+     * const jodit = Jodit.make('#editor', {
+     *  commandToHotkeys: {
+     *      bold: 'ctrl+shift+b',
+     *      italic: ['ctrl+i', 'ctrl+b'],
+     *  }
+     * })
+     * ```
+     */
+    commandToHotkeys: IDictionary<string | string[]>;
+}
+interface Config {
+    /**
+     * You can redefine default page
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    iframe: true,
+     *    iframeDefaultSrc: 'https://xdsoft.net/jodit/docs/',
+     * });
+     * ```
+     */
+    iframeDefaultSrc: string;
+    /**
+     * Base URL where the root directory for [[Config.iframe]] mode
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    iframe: true,
+     *    iframeBaseUrl: 'https://xdsoft.net/jodit/docs/',
+     * });
+     * ```
+     */
+    iframeBaseUrl: string;
+    /**
+     * Iframe title's content
+     */
+    iframeTitle: string;
+    /**
+     * Iframe's DOCTYPE
+     */
+    iframeDoctype: string;
+    /**
+     * Custom style to be used inside the iframe to display content.
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    iframe: true,
+     *    iframeStyle: 'html{margin: 0px;}',
+     * })
+     * ```
+     */
+    iframeStyle: string;
+    /**
+     * Custom stylesheet files to be used inside the iframe to display content.
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    iframe: true,
+     *    iframeCSSLinks: ['styles/default.css'],
+     * })
+     * ```
+     */
+    iframeCSSLinks: string[];
+    /**
+     * Custom sandbox attribute for the iframe.
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#sandbox
+     * ```javascript
+     * Jodit.make('#editor', {
+     * 		iframe: true,
+     * 		iframeSandbox: 'allow-same-origin allow-scripts'
+     * });
+     * ```
+     * Empty string value means that all restrictions are enabled.
+     */
+    iframeSandbox: string | null;
+}
+interface Config {
+    imageProcessor: {
+        replaceDataURIToBlobIdInView: boolean;
+    };
+}
+interface Config {
+    image: ImagePropertiesOptions;
+}
+interface Config {
+    /**
+     * The number of pixels to use for indenting the current line.
+     */
+    indentMargin: number;
+}
+interface Config {
+    popup: IDictionary<Array<IControlType | string> | ((editor: IJodit, target: HTMLElement | undefined, close: () => void) => Array<IControlType | string> | HTMLElement | string)>;
+    toolbarInlineDisabledButtons: string[];
+    toolbarInline: boolean;
+    toolbarInlineForSelection: boolean;
+    toolbarInlineDisableFor: string | string[];
+}
+interface Config {
+    /**
+     * limit words count
+     */
+    limitWords: false | number;
+    /**
+     * limit chars count
+     */
+    limitChars: false | number;
+    /**
+     * limit html chars count
+     */
+    limitHTML: false;
+}
+interface Config {
+    /**
+     * Default line spacing for the entire editor
+     *
+     * ```js
+     * Jodit.make('#editor', {
+     *   defaultLineHeight: 1.2
+     * })
+     * ```
+     */
+    defaultLineHeight: number | null;
+}
+interface Config {
+    link: {
+        /**
+         * Template for the link dialog form
+         */
+        formTemplate: (editor: IJodit) => string | HTMLElement | IUIForm;
+        formClassName?: string;
+        /**
+         * Follow link address after dblclick
+         */
+        followOnDblClick: boolean;
+        /**
+         * Replace inserted youtube/vimeo link to `iframe`
+         */
+        processVideoLink: boolean;
+        /**
+         * Wrap inserted link
+         */
+        processPastedLink: boolean;
+        /**
+         * Show `no follow` checkbox in link dialog.
+         */
+        noFollowCheckbox: boolean;
+        /**
+         * Show `Open in new tab` checkbox in link dialog.
+         */
+        openInNewTabCheckbox: boolean;
+        /**
+         * Use an input text to ask the classname or a select or not ask
+         */
+        modeClassName: 'input' | 'select';
+        /**
+         * Allow multiple choises (to use with modeClassName="select")
+         */
+        selectMultipleClassName: boolean;
+        /**
+         * The size of the select (to use with modeClassName="select")
+         */
+        selectSizeClassName?: number;
+        /**
+         * The list of the option for the select (to use with modeClassName="select")
+         */
+        selectOptionsClassName: IUIOption[];
+        hotkeys: string[];
+    };
+}
+interface Config {
+    /**
+     * Decorate media elements
+     */
+    mediaInFakeBlock: boolean;
+    /**
+     * Decorate media element with tag
+     */
+    mediaFakeTag: string;
+    /**
+     * Media tags
+     */
+    mediaBlocks: string[];
+}
+interface Config {
+    /**
+     * Mobile timeout for CLICK emulation
+     */
+    mobileTapTimeout: number;
+    /**
+     * After resizing, the set of buttons will change to accommodate different sizes.
+     */
+    toolbarAdaptive: boolean;
+    /**
+     * The list of buttons that appear in the editor's toolbar for medium-sized spaces (≥ options.sizeMD).
+     */
+    buttonsMD: ButtonsOption;
+    /**
+     * The list of buttons that appear in the editor's toolbar for small-sized spaces (≥ options.sizeSM).
+     */
+    buttonsSM: ButtonsOption;
+    /**
+     * The list of buttons that appear in the editor's toolbar for extra-small spaces (less than options.sizeSM).
+     */
+    buttonsXS: ButtonsOption;
+}
+interface Config {
+    /**
+     * Ask before paste HTML in WYSIWYG mode
+     */
+    askBeforePasteHTML: boolean;
+    /**
+     * When the user inserts a snippet of HTML, the plugin will prompt for the insertion method.
+     * If the user inserts the same fragment again, the previously selected option will be used without prompting for confirmation.
+     */
+    memorizeChoiceWhenPasteFragment: boolean;
+    /**
+     * Handle pasted text - similar to HTML
+     */
+    processPasteHTML: boolean;
+    /**
+     * Inserts HTML line breaks before all newlines in a string
+     */
+    nl2brInPlainText: boolean;
+    /**
+     * List of tags that will not be removed from the pasted HTML with INSERT_AS_TEXT mode
+     */
+    pasteExcludeStripTags: HTMLTagNames[];
+    /**
+     * Options when inserting HTML string
+     */
+    pasteHTMLActionList: IUIOption[];
+    /**
+     * Scroll the editor to the pasted fragment
+     */
+    scrollToPastedContent: boolean;
+}
+interface Config {
+    /**
+     * Show the paste dialog if the html is similar to what MSWord gives when copying.
+     */
+    askBeforePasteFromWord: boolean;
+    /**
+     * Handle pasting of HTML - similar to a fragment copied from MSWord
+     */
+    processPasteFromWord: boolean;
+    /**
+     * Default insert method from word, if not define, it will use defaultActionOnPaste instead
+     *
+     * ```js
+     * Jodit.make('#editor', {
+     *   defaultActionOnPasteFromWord: 'insert_clear_html'
+     * })
+     * ```
+     */
+    defaultActionOnPasteFromWord: InsertMode | null;
+    /**
+     * Options when inserting data from Word
+     */
+    pasteFromWordActionList: IUIOption[];
+}
+interface Config {
+    /**
+     * Show placeholder
+     * @example
+     * ```javascript
+     * const editor = Jodit.make('#editor', {
+     *    showPlaceholder: false
+     * });
+     * ```
+     */
+    showPlaceholder: boolean;
+    /**
+     * Use a placeholder from original input field, if it was set
+     * @example
+     * ```javascript
+     * //<textarea id="editor" placeholder="start typing text ..." cols="30" rows="10"></textarea>
+     * const editor = Jodit.make('#editor', {
+     *    useInputsPlaceholder: true
+     * });
+     * ```
+     */
+    useInputsPlaceholder: boolean;
+    /**
+     * Default placeholder
+     * @example
+     * ```javascript
+     * const editor = Jodit.make('#editor', {
+     *    placeholder: 'start typing text ...'
+     * });
+     * ```
+     */
+    placeholder: string;
+}
+interface Config {
+    /**
+     * Hide the link to the Jodit site at the bottom of the editor
+     */
+    hidePoweredByJodit: boolean;
+}
+interface Config {
+    tableAllowCellResize: boolean;
+}
+interface Config {
+    allowResizeX: boolean;
+    allowResizeY: boolean;
+}
+interface Config {
+    /**
+     * Use true frame for editing iframe size
+     */
+    allowResizeTags: Set<HTMLTagNames>;
+    resizer: {
+        /**
+         * Show size
+         */
+        showSize: boolean;
+        hideSizeTimeout: number;
+        /**
+         * Save width and height proportions when resizing
+         * ```js
+         * Jodit.make('#editor', {
+         *   allowResizeTags: ['img', 'iframe', 'table', 'jodit'],
+         *   resizer: {
+         *     useAspectRatio: false, // don't save,
+         *     useAspectRatio: ['img'], // save only for images (default value)
+         *     useAspectRatio: true // save for all
+         *   }
+         * });
+         * ```
+         */
+        useAspectRatio: boolean | Set<HTMLTagNames>;
+        /**
+         * When resizing images, change not the styles but the width and height attributes
+         */
+        forImageChangeAttributes: boolean;
+        /**
+         * The minimum width for the editable element
+         */
+        min_width: number;
+        /**
+         * The minimum height for the item being edited
+         */
+        min_height: number;
+    };
+}
+interface Config {
+    /**
+     * Enable custom search plugin
+     * ![search](https://user-images.githubusercontent.com/794318/34545433-cd0a9220-f10e-11e7-8d26-7e22f66e266d.gif)
+     */
+    useSearch: boolean;
+    search: {
+        lazyIdleTimeout: number;
+        /**
+         * Use custom highlight API https://developer.mozilla.org/en-US/docs/Web/API/CSS_Custom_Highlight_API
+         * or use default implementation (wrap text in span and attribute jd-tmp-selection)
+         */
+        useCustomHighlightAPI: boolean;
+        /**
+         * Function to search for a string within a substring. The default implementation is [[fuzzySearchIndex]]
+         * But you can write your own. It must implement the [[FuzzySearch]] interface.
+         *
+         * ```ts
+         * Jodit.make('#editor', {
+         *   search: {
+         *     fuzzySearch: (needle, haystack, offset) => {
+         *       return [haystack.toLowerCase().indexOf(needle.toLowerCase(), offset), needle.length];
+         *     }
+         *   }
+         * })
+         * ```
+         */
+        fuzzySearch?: FuzzySearch;
+    };
+}
+interface Config {
+    select: {
+        /**
+         * When the user selects the elements of the list - from the beginning to
+         * the end from the inside - when copying, we change the selection
+         * to cover the entire selected container
+         *
+         * `<ul><li>|test|</li></ul>` will be `|<ul><li>test</li></ul>|`
+         * `<ul><li>|test|</li><li>|test</li></ul>` will be `<ul>|<li>test</li><li>|test</li></ul>`
+         */
+        normalizeSelectionBeforeCutAndCopy: boolean;
+        /**
+         * Normalize selection after triple click
+         * @example
+         *
+         * `<ul><li>|test</li><li>|pop</li></ul>` will be `<ul><li>|test|</li><li>pop</li</ul>|`
+         */
+        normalizeTripleClick: boolean;
+    };
+}
+interface Config {
+    tableAllowCellSelection: boolean;
+}
+interface Config {
+    saveHeightInStorage: boolean;
+    minWidth: number | string;
+    minHeight: number | string;
+    maxWidth: number | string;
+    maxHeight: number | string;
+}
+interface Config {
+    sourceEditor: 'area' | 'ace' | ((jodit: IJodit) => ISourceEditor);
+    /**
+         * Options for [ace](https://ace.c9.io/#config) editor
+         * @example
+         * ```js
+         * Jodit.make('#editor', {
+         * 	showGutter: true,
+         * 	theme: 'ace/theme/idle_fingers',
+         * 	mode: 'ace/mode/html',
+         * 	wrap: true,
+§		 * 	highlightActiveLine: true
+         * })
+         * ```
+         */
+    sourceEditorNativeOptions: {
+        showGutter: boolean;
+        theme: string;
+        mode: string;
+        wrap: string | boolean | number;
+        highlightActiveLine: boolean;
+    };
+    /**
+     * Beautify HTML then it possible
+     */
+    beautifyHTML: boolean;
+    /**
+     * CDN URLs for HTML Beautifier
+     */
+    beautifyHTMLCDNUrlsJS: string[];
+    /**
+     * CDN URLs for ACE editor
+     */
+    sourceEditorCDNUrlsJS: string[];
+}
+interface Config {
+    speechRecognize: {
+        readonly api: ISpeechRecognizeConstructor | null;
+        /**
+         * Returns and sets the language of the current SpeechRecognition.
+         * If not specified, this defaults to the HTML lang attribute value, or
+         * the user agent's language setting if that isn't set either.
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition/lang
+         */
+        readonly lang?: string;
+        /**
+         * Controls whether continuous results are returned for each recognition,
+         * or only a single result.
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition/continuous
+         */
+        readonly continuous: boolean;
+        /**
+         * Controls whether interim results should be returned (true) or not (false.)
+         * Interim results are results that are not yet final (e.g. the isFinal property is false.)
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition/interimResults
+         */
+        readonly interimResults: boolean;
+        /**
+         * On recognition error - make an error sound
+         */
+        readonly sound: boolean;
+        /**
+         * You can specify any commands in your language by listing them with the `|` sign.
+         * In the value, write down any commands for
+         * [execCommand](https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand#parameters)
+         * and value (separated by ::)
+         * You can also use [custom Jodit commands](#need-article)
+         * For example
+         * ```js
+         * Jodit.make('#editor', {
+         *   speechRecognize: {
+         *     commands: {
+         *       'remove line|remove paragraph': 'backspaceSentenceButton',
+         *       'start bold': 'bold',
+         *       'insert table|create table': 'insertHTML::<table><tr><td>test</td></tr></table>',
+         *     }
+         *   }
+         * });
+         * ```
+         */
+        readonly commands: IDictionary<string>;
+    };
+}
+interface Config {
+    /**
+     * Options specifies whether the editor is to have its spelling and grammar checked or not
+     * @see http://www.w3schools.com/tags/att_global_spellcheck.asp
+     */
+    spellcheck: boolean;
+}
+interface Config {
+    showCharsCounter: boolean;
+    countHTMLChars: boolean;
+    countTextSpaces: boolean;
+    showWordsCounter: boolean;
+}
+interface Config {
+    /**
+     * @example
+     * ```javascript
+     * var editor = Jodit.make('#someid', {
+     *  toolbarSticky: false
+     * })
+     * ```
+     */
+    toolbarSticky: boolean;
+    toolbarDisableStickyForMobile: boolean;
+    /**
+     * For example, in Joomla, the top menu bar closes Jodit toolbar when scrolling. Therefore, it is necessary to
+     * move the toolbar Jodit by this amount [more](https://xdsoft.net/jodit/docs/#2.5.57)
+     *
+     * @example
+     * ```javascript
+     * var editor = Jodit.make('#someid', {
+     *  toolbarStickyOffset: 100
+     * })
+     * ```
+     */
+    toolbarStickyOffset: number;
+}
+interface Config {
+    specialCharacters: string[];
+    usePopupForSpecialCharacters: boolean;
+}
+interface Config {
+    tab: {
+        /**
+         * Pressing Tab inside LI will add an internal list
+         */
+        tabInsideLiInsertNewList: boolean;
+    };
+}
+interface Config {
+    table: {
+        selectionCellStyle: string;
+        useExtraClassesOptions: boolean;
+    };
+}
+interface Config {
+    video: {
+        /**
+         * Custom function for parsing video URL to embed code
+         * ```javascript
+         * Jodit.make('#editor', {
+         * 		video: {
+         * 			// Defaul behavior
+         * 			parseUrlToVideoEmbed: (url, size) => Jodit.modules.Helpers.convertMediaUrlToVideoEmbed(url, size)
+         * 		}
+         * });
+         * ```
+         */
+        parseUrlToVideoEmbed?: (url: string, { width, height }?: {
+            width?: number;
+            height?: number;
+        }) => string;
+        /**
+         * Default width for video iframe. Default: 400
+         */
+        defaultWidth?: number;
+        /**
+         * Default height for video iframe. Default: 345
+         */
+        defaultHeight?: number;
+    };
+}
+interface Config {
+    wrapNodes: {
+        /**
+         * List of tags that should not be wrapped
+         * Default: `new Set(['hr', 'style', 'br'])`
+         */
+        exclude: Set<HTMLTagNames>;
+        /**
+         * If the editor is empty, then insert an empty paragraph into it
+         * ```javascript
+         * Jodit.make('#editor', {
+         * 	wrapNodes: {
+         * 		emptyBlockAfterInit: true
+         * 	}
+         * });
+         * ```
+         * Default: `true`
+         */
+        emptyBlockAfterInit: boolean;
+    };
+}
+interface Config {
+    showXPathInStatusbar: boolean;
+}