jodit 4.4.2 → 4.4.3

package/esm/config.d.ts

@@ -1,616 +1,616 @@
-import type { AjaxOptions } from 'jodit/types';
-import type { IDialogOptions } from 'jodit/types';
-import type { IFileBrowserOptions } from 'jodit/types';
-import type { ImageEditorOptions } from 'jodit/types';
-import type { IUploaderOptions } from 'jodit/types';
-import type { IUploader } from 'jodit/types';
-import type { HTMLTagNames } from 'jodit/types';
-import type { AiAssistantSettings } from 'jodit/plugins/ai-assistant/interface';
-import type { IDictionary } from './types';
-import type { Nullable } from './types';
-import type { ImagePropertiesOptions } from 'jodit/plugins/image-properties/interface';
-import type { IControlType } from './types';
-import type { IJodit } from 'jodit/types';
-import type { formTemplate } from 'jodit/plugins/link/template';
-import type { IUIForm } from 'jodit/types';
-import type { IUIOption } from 'jodit/types';
-import type { ButtonsOption } from './types';
-import type { InsertMode } from './types';
-import type { FuzzySearch } from 'jodit/types';
-import type { ISourceEditor } from 'jodit/types';
-import type { ISpeechRecognizeConstructor } from 'jodit/plugins/speech-recognize/interface';
-import type { Attributes } from './types';
-import type { Controls } from './types';
-import type { IExtraPlugin } from './types';
-import type { IUIButtonState } from './types';
-import type { IViewOptions } from './types';
-import type { NodeFunction } 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
  */
 declare class Config implements IViewOptions {
-	private constructor();
-	/**
-	 * Use cache for heavy methods
-	 */
-	cache: boolean;
-	/**
-	 * Timeout of all asynchronous methods
-	 */
-	defaultTimeout: number;
-	namespace: string;
-	/**
-	 * Editor loads completely without plugins. Useful when debugging your own plugin.
-	 */
-	safeMode: boolean;
-	/**
-	 * Editor's width
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    width: '100%',
-	 * })
-	 * ```
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    width: 600, // equivalent for '600px'
-	 * })
-	 * ```
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    width: 'auto', // autosize
-	 * })
-	 * ```
-	 */
-	width: number | string;
-	/**
-	 * Editor's height
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    height: '100%',
-	 * })
-	 * ```
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    height: 600, // equivalent for '600px'
-	 * })
-	 * ```
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    height: 'auto', // default - autosize
-	 * })
-	 * ```
-	 */
-	height: number | string;
-	/**
-	 * List of plugins that will be initialized in safe mode.
-	 *
-	 * ```js
-	 * Jodit.make('#editor', {
-	 * 	safeMode: true,
-	 * 	safePluginsList: ['about'],
-	 * 	extraPlugins: ['yourPluginDev']
-	 * });
-	 * ```
-	 */
-	safePluginsList: string[];
-	commandToHotkeys: IDictionary<string | string[]>;
-	/**
-	 * Reserved for the paid version of the editor
-	 */
-	license: string;
-	/**
-	 * The name of the preset that will be used to initialize the editor.
-	 * The list of available presets can be found here Jodit.defaultOptions.presets
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 * 	preset: 'inline'
-	 * });
-	 * ```
-	 */
-	preset: string;
-	presets: IDictionary;
-	ownerDocument: Document;
-	/**
-	 * Allows you to specify the window in which the editor will be created. Default - window
-	 * This is necessary if you are creating the editor inside an iframe but the code is running in the parent window
-	 */
-	ownerWindow: Window;
-	/**
-	 * Shadow root if Jodit was created in it
-	 *
-	 * ```html
-	 * <div id="editor"></div>
-	 * ```
-	 *
-	 * ```js
-	 * const app = document.getElementById('editor');
-	 * app.attachShadow({ mode: 'open' });
-	 * const root = app.shadowRoot;
-	 *
-	 * root.innerHTML = `
-	 * <link rel="stylesheet" href="./build/jodit.css"/>
-	 * <h1>Jodit example in Shadow DOM</h1>
-	 * <div id="edit"></div>
-	 * `;
-	 *
-	 * const editor = Jodit.make(root.getElementById('edit'), {
-	 * 	globalFullSize: false,
-	 * 	shadowRoot: root
-	 * });
-	 * editor.value = '<p>start</p>';
-	 * ```
-	 */
-	shadowRoot: Nullable<ShadowRoot>;
-	/**
-	 * z-index For editor
-	 */
-	zIndex: number;
-	/**
-	 * Change the read-only state of the editor
-	 */
-	readonly: boolean;
-	/**
-	 * Change the disabled state of the editor
-	 */
-	disabled: boolean;
-	/**
-	 * In readOnly mode, some buttons can still be useful, for example, the button to view source code or print
-	 */
-	activeButtonsInReadOnly: string[];
-	/**
-	 * When the editor is in read-only mode, some commands can still be executed:
-	 * ```javascript
-	 * const editor = Jodit.make('.editor', {
-	 * 	 allowCommandsInReadOnly: ['selectall', 'preview', 'print']
-	 * 	 readonly: true
-	 * });
-	 * editor.execCommand('selectall');// will be selected all content
-	 * editor.execCommand('delete');// but content will not be deleted
-	 * ```
-	 */
-	allowCommandsInReadOnly: string[];
-	/**
-	 * Size of icons in the toolbar (can be "small", "middle", "large")
-	 *
-	 * @example
-	 * ```javascript
-	 * const editor = Jodit.make(".dark_editor", {
-	 *      toolbarButtonSize: "small"
-	 * });
-	 * ```
-	 */
-	toolbarButtonSize: IUIButtonState['size'];
-	/**
-	 * Allow navigation in the toolbar of the editor by Tab key
-	 */
-	allowTabNavigation: boolean;
-	/**
-	 * Inline editing mode
-	 */
-	inline: boolean;
-	/**
-	 * Theme (can be "dark")
-	 * @example
-	 * ```javascript
-	 * const editor = Jodit.make(".dark_editor", {
-	 *      theme: "dark"
-	 * });
-	 * ```
-	 */
-	theme: string;
-	/**
-	 * if set true, then the current mode is saved in a cookie, and is restored after a reload of the page
-	 */
-	saveModeInStorage: boolean;
-	/**
-	 * Class name that can be appended to the editable area
-	 *
-	 * @see [[Config.iframeCSSLinks]]
-	 * @see [[Config.iframeStyle]]
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor', {
-	 *    editorClassName: 'some_my_class'
-	 * });
-	 * ```
-	 * ```html
-	 * <style>
-	 * .some_my_class p{
-	 *    line-height: 16px;
-	 * }
-	 * </style>
-	 * ```
-	 */
-	editorClassName: false | string;
-	/**
-	 * Class name that can be appended to the main editor container
-	 * @example
-	 * ```javascript
-	 * const jodit = Jodit.make('#editor', {
-	 *    className: 'some_my_class'
-	 * });
-	 *
-	 * console.log(jodit.container.classList.contains('some_my_class')); // true
-	 * ```
-	 * ```html
-	 * <style>
-	 * .some_my_class {
-	 *    max-width: 600px;
-	 *    margin: 0 auto;
-	 * }
-	 * </style>
-	 * ```
-	 */
-	className: false | string;
-	/**
-	 * The internal styles of the editable area. They are intended to change
-	 * not the appearance of the editor, but to change the appearance of the content.
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor', {
-	 * 		style: {
-	 * 		 font: '12px Arial',
-	 * 		 color: '#0c0c0c'
-	 * 		}
-	 * });
-	 * ```
-	 */
-	style: false | IDictionary;
-	/**
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor', {
-	 * 		editorStyle: {
-	 * 		 font: '12px Arial',
-	 * 		 color: '#0c0c0c'
-	 * 		}
-	 * });
-	 * ```
-	 */
-	containerStyle: false | IDictionary;
-	/**
-	 * Dictionary of variable values in css, a complete list can be found here
-	 * https://github.com/xdan/jodit/blob/main/src/styles/variables.less#L25
-	 *
-	 * @example
-	 * ```js
-	 * const editor = Jodit.make('#editor', {
-	 *   styleValues: {
-	 *		'color-text': 'red',
-	 *		colorBorder: 'black',
-	 *		'color-panel': 'blue'
-	 *   }
-	 * });
-	 * ```
-	 */
-	styleValues: IDictionary;
-	/**
-	 * After all, changes in editors for textarea will call change trigger
-	 *
-	 * @example
-	 * ```javascript
-	 * const editor = Jodit.make('#editor');
-	 * document.getElementById('editor').addEventListener('change', function () {
-	 *      console.log(this.value);
-	 * })
-	 * ```
-	 */
-	triggerChangeEvent: boolean;
-	/**
-	 * The writing direction of the language which is used to create editor content. Allowed values are: ''
-	 * (an empty string) – Indicates that content direction will be the same as either the editor UI direction or
-	 * the page element direction. 'ltr' – Indicates a Left-To-Right text direction (like in English).
-	 * 'rtl' – Indicates a Right-To-Left text direction (like in Arabic).
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('.editor', {
-	 *    direction: 'rtl'
-	 * })
-	 * ```
-	 */
-	direction: 'rtl' | 'ltr' | '';
-	/**
-	 * Language by default. if `auto` language set by document.documentElement.lang ||
-	 * (navigator.language && navigator.language.substr(0, 2)) ||
-	 * (navigator.browserLanguage && navigator.browserLanguage.substr(0, 2)) || 'en'
-	 *
-	 * @example
-	 * ```html
-	 * <!-- include in you page lang file -->
-	 * <script src="jodit/lang/de.js"></script>
-	 * <script>
-	 * var editor = Jodit.make('.editor', {
-	 *    language: 'de'
-	 * });
-	 * </script>
-	 * ```
-	 */
-	language: string;
-	/**
-	 * if true all Lang.i18n(key) return `{key}`
-	 *
-	 * @example
-	 * ```html
-	 * <script>
-	 * var editor = Jodit.make('.editor', {
-	 *    debugLanguage: true
-	 * });
-	 *
-	 * console.log(editor.i18n("Test")); // {Test}
-	 * </script>
-	 * ```
-	 */
-	debugLanguage: boolean;
-	/**
-	 * Collection of language pack data `{en: {'Type something': 'Type something', ...}}`
-	 *
-	 * @example
-	 * ```javascript
-	 * const editor = Jodit.make('#editor', {
-	 *     language: 'ru',
-	 *     i18n: {
-	 *         ru: {
-	 *            'Type something': 'Начните что-либо вводить'
-	 *         }
-	 *     }
-	 * });
-	 * console.log(editor.i18n('Type something')) //Начните что-либо вводить
-	 * ```
-	 */
-	i18n: IDictionary<IDictionary<string>> | false;
-	/**
-	 * The tabindex global attribute is an integer indicating if the element can take
-	 * input focus (is focusable), if it should participate to sequential keyboard navigation,
-	 * and if so, at what position. It can take several values
-	 */
-	tabIndex: number;
-	/**
-	 * Boolean, whether the toolbar should be shown.
-	 * Alternatively, a valid css-selector-string to use an element as toolbar container.
-	 */
-	toolbar: boolean | string | HTMLElement;
-	/**
-	 * Boolean, whether the statusbar should be shown.
-	 */
-	statusbar: boolean;
-	/**
-	 * Show tooltip after mouse enter on the button
-	 */
-	showTooltip: boolean;
-	/**
-	 * Delay before show tooltip
-	 */
-	showTooltipDelay: number;
-	/**
-	 * Instead of create custop tooltip - use native title tooltips
-	 */
-	useNativeTooltip: boolean;
-	/**
-	 * Default insert method
-	 * @default insert_as_html
-	 */
-	defaultActionOnPaste: InsertMode;
-	/**
-	 * Element that will be created when you press Enter
-	 */
-	enter: 'p' | 'div' | 'br';
-	/**
-	 * When this option is enabled, the editor's content will be placed in an iframe and isolated from the rest of the page.
-	 *
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor', {
-	 *    iframe: true,
-	 *    iframeStyle: 'html{margin: 0px;}body{padding:10px;background:transparent;color:#000;position:relative;z-index:2;\
-	 *    user-select:auto;margin:0px;overflow:hidden;}body:after{content:"";clear:both;display:block}';
-	 * });
-	 * ```
-	 */
-	iframe: boolean;
-	/**
-	 * Allow editing the entire HTML document(html, head)
-	 * \> Works together with the iframe option.
-	 * @example
-	 * ```js
-	 * const editor = Jodit.make('#editor', {
-	 *   iframe: true,
-	 *   editHTMLDocumentMode: true
-	 * });
-	 * editor.value = '<!DOCTYPE html><html lang="en" style="overflow-y:hidden">' +
-	 * 	'<head><title>Jodit Editor</title></head>' +
-	 * 	'<body spellcheck="false"><p>Some text</p><p> a </p></body>' +
-	 * 	'</html>';
-	 * ```
-	 */
-	editHTMLDocumentMode: boolean;
-	/**
-	 * Use when you need to insert new block element
-	 * use enter option if not set
-	 */
-	enterBlock: 'p' | 'div';
-	/**
-	 * Jodit.MODE_WYSIWYG The HTML editor allows you to write like MSWord,
-	 * Jodit.MODE_SOURCE syntax highlighting source editor
-	 * @example
-	 * ```javascript
-	 * var editor = Jodit.make('#editor', {
-	 *     defaultMode: Jodit.MODE_SPLIT
-	 * });
-	 * console.log(editor.getRealMode())
-	 * ```
-	 */
-	defaultMode: number;
-	/**
-	 * Use split mode
-	 */
-	useSplitMode: boolean;
-	/**
-	 * The colors in HEX representation to select a color for the background and for the text in colorpicker
-	 * @example
-	 * ```javascript
-	 *  Jodit.make('#editor', {
-	 *     colors: ['#ff0000', '#00ff00', '#0000ff']
-	 * })
-	 * ```
-	 */
-	colors: IDictionary<string[]> | string[];
-	/**
-	 * The default tab color picker
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor2', {
-	 *     colorPickerDefaultTab: 'color'
-	 * })
-	 * ```
-	 */
-	colorPickerDefaultTab: 'background' | 'color';
-	/**
-	 * Image size defaults to a larger image
-	 */
-	imageDefaultWidth: number;
-	/**
-	 * Do not display these buttons that are on the list
-	 * @example
-	 * ```javascript
-	 * Jodit.make('#editor2', {
-	 *     removeButtons: ['hr', 'source']
-	 * });
-	 * ```
-	 */
-	removeButtons: string[];
-	/**
-	 * Do not init these plugins
-	 * @example
-	 * ```typescript
-	 * var editor = Jodit.make('.editor', {
-	 *    disablePlugins: 'table,iframe'
-	 * });
-	 * //or
-	 * var editor = Jodit.make('.editor', {
-	 *    disablePlugins: ['table', 'iframe']
-	 * });
-	 * ```
-	 */
-	disablePlugins: string[] | string;
-	/**
-	 * Init and download extra plugins
-	 * @example
-	 * ```typescript
-	 * var editor = Jodit.make('.editor', {
-	 *    extraPlugins: ['emoji']
-	 * });
-	 * ```
-	 * It will try load %SCRIPT_PATH%/plugins/emoji/emoji.js and after load will try init it
-	 */
-	extraPlugins: Array<string | IExtraPlugin>;
-	/**
-	 * Base path for download extra plugins
-	 */
-	basePath?: string;
-	/**
-	 * These buttons list will be added to the option. Buttons
-	 */
-	extraButtons: Array<string | IControlType>;
-	/**
-	 * By default, you can only install an icon from the Jodit suite.
-	 * You can add your icon to the set using the `Jodit.modules.Icon.set (name, svg Code)` method.
-	 * But for a declarative declaration, you can use this option.
-	 *
-	 * @example
-	 * ```js
-	 * Jodit.modules.Icon.set('someIcon', '<svg><path.../></svg>');
-	 * const editor = Jodit.make({
-	 *   extraButtons: [{
-	 *     name: 'someButton',
-	 *     icon: 'someIcon'
-	 *   }]
-	 * });
-	 *
-	 * @example
-	 * const editor = Jodit.make({
-	 *   extraIcons: {
-	 *     someIcon: '<svg><path.../></svg>'
-	 *   },
-	 *   extraButtons: [{
-	 *     name: 'someButton',
-	 *     icon: 'someIcon'
-	 *   }]
-	 * });
-	 * ```
-	 * @example
-	 * ```js
-	 * const editor = Jodit.make({
-	 *   extraButtons: [{
-	 *     name: 'someButton',
-	 *     icon: '<svg><path.../></svg>'
-	 *   }]
-	 * });
-	 * ```
-	 */
-	extraIcons: IDictionary<string>;
-	/**
-	 * Default attributes for created inside editor elements
-	 * @example
-	 * ```js
-	 * const editor2 = Jodit.make('#editor', {
-	 * 	createAttributes: {
-	 * 		div: {
-	 * 			class: 'test'
-	 * 		},
-	 * 		ul: function (ul) {
-	 * 			ul.classList.add('ui-test');
-	 * 		}
-	 * 	}
-	 * });
-	 *
-	 * const div2 = editor2.createInside.div();
-	 * expect(div2.className).equals('test');
-	 *
-	 * const ul = editor2.createInside.element('ul');
-	 * expect(ul.className).equals('ui-test');
-	 * ```
-	 * Or JSX in React
-	 * @example
-	 * ```jsx
-	 * import React, {useState, useRef} from 'react';
-	 * import JoditEditor from "jodit-react";
-	 *
-	 * const config = {
-	 * 	createAttributes: {
-	 * 		div: {
-	 * 			class: 'align-center'
-	 * 		}
-	 * 	}
-	 * };
-	 *
-	 * <JoditEditor config={config}/>
-	 * ```
-	 */
-	createAttributes: IDictionary<Attributes | NodeFunction>;
-	/**
-	 * The width of the editor, accepted as the biggest. Used to the responsive version of the editor
-	 */
-	sizeLG: number;
-	/**
-	 * The width of the editor, accepted as the medium. Used to the responsive version of the editor
-	 */
-	sizeMD: number;
-	/**
-	 * The width of the editor, accepted as the small. Used to the responsive version of the editor
-	 */
-	sizeSM: number;
-	/**
+    private constructor();
+    /**
+     * Use cache for heavy methods
+     */
+    cache: boolean;
+    /**
+     * Timeout of all asynchronous methods
+     */
+    defaultTimeout: number;
+    namespace: string;
+    /**
+     * Editor loads completely without plugins. Useful when debugging your own plugin.
+     */
+    safeMode: boolean;
+    /**
+     * Editor's width
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    width: '100%',
+     * })
+     * ```
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    width: 600, // equivalent for '600px'
+     * })
+     * ```
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    width: 'auto', // autosize
+     * })
+     * ```
+     */
+    width: number | string;
+    /**
+     * Editor's height
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    height: '100%',
+     * })
+     * ```
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    height: 600, // equivalent for '600px'
+     * })
+     * ```
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    height: 'auto', // default - autosize
+     * })
+     * ```
+     */
+    height: number | string;
+    /**
+     * List of plugins that will be initialized in safe mode.
+     *
+     * ```js
+     * Jodit.make('#editor', {
+     * 	safeMode: true,
+     * 	safePluginsList: ['about'],
+     * 	extraPlugins: ['yourPluginDev']
+     * });
+     * ```
+     */
+    safePluginsList: string[];
+    commandToHotkeys: IDictionary<string | string[]>;
+    /**
+     * Reserved for the paid version of the editor
+     */
+    license: string;
+    /**
+     * The name of the preset that will be used to initialize the editor.
+     * The list of available presets can be found here Jodit.defaultOptions.presets
+     * ```javascript
+     * Jodit.make('.editor', {
+     * 	preset: 'inline'
+     * });
+     * ```
+     */
+    preset: string;
+    presets: IDictionary;
+    ownerDocument: Document;
+    /**
+     * Allows you to specify the window in which the editor will be created. Default - window
+     * This is necessary if you are creating the editor inside an iframe but the code is running in the parent window
+     */
+    ownerWindow: Window;
+    /**
+     * Shadow root if Jodit was created in it
+     *
+     * ```html
+     * <div id="editor"></div>
+     * ```
+     *
+     * ```js
+     * const app = document.getElementById('editor');
+     * app.attachShadow({ mode: 'open' });
+     * const root = app.shadowRoot;
+     *
+     * root.innerHTML = `
+     * <link rel="stylesheet" href="./build/jodit.css"/>
+     * <h1>Jodit example in Shadow DOM</h1>
+     * <div id="edit"></div>
+     * `;
+     *
+     * const editor = Jodit.make(root.getElementById('edit'), {
+     * 	globalFullSize: false,
+     * 	shadowRoot: root
+     * });
+     * editor.value = '<p>start</p>';
+     * ```
+     */
+    shadowRoot: Nullable<ShadowRoot>;
+    /**
+     * z-index For editor
+     */
+    zIndex: number;
+    /**
+     * Change the read-only state of the editor
+     */
+    readonly: boolean;
+    /**
+     * Change the disabled state of the editor
+     */
+    disabled: boolean;
+    /**
+     * In readOnly mode, some buttons can still be useful, for example, the button to view source code or print
+     */
+    activeButtonsInReadOnly: string[];
+    /**
+     * When the editor is in read-only mode, some commands can still be executed:
+     * ```javascript
+     * const editor = Jodit.make('.editor', {
+     * 	 allowCommandsInReadOnly: ['selectall', 'preview', 'print']
+     * 	 readonly: true
+     * });
+     * editor.execCommand('selectall');// will be selected all content
+     * editor.execCommand('delete');// but content will not be deleted
+     * ```
+     */
+    allowCommandsInReadOnly: string[];
+    /**
+     * Size of icons in the toolbar (can be "small", "middle", "large")
+     *
+     * @example
+     * ```javascript
+     * const editor = Jodit.make(".dark_editor", {
+     *      toolbarButtonSize: "small"
+     * });
+     * ```
+     */
+    toolbarButtonSize: IUIButtonState['size'];
+    /**
+     * Allow navigation in the toolbar of the editor by Tab key
+     */
+    allowTabNavigation: boolean;
+    /**
+     * Inline editing mode
+     */
+    inline: boolean;
+    /**
+     * Theme (can be "dark")
+     * @example
+     * ```javascript
+     * const editor = Jodit.make(".dark_editor", {
+     *      theme: "dark"
+     * });
+     * ```
+     */
+    theme: string;
+    /**
+     * if set true, then the current mode is saved in a cookie, and is restored after a reload of the page
+     */
+    saveModeInStorage: boolean;
+    /**
+     * Class name that can be appended to the editable area
+     *
+     * @see [[Config.iframeCSSLinks]]
+     * @see [[Config.iframeStyle]]
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    editorClassName: 'some_my_class'
+     * });
+     * ```
+     * ```html
+     * <style>
+     * .some_my_class p{
+     *    line-height: 16px;
+     * }
+     * </style>
+     * ```
+     */
+    editorClassName: false | string;
+    /**
+     * Class name that can be appended to the main editor container
+     * @example
+     * ```javascript
+     * const jodit = Jodit.make('#editor', {
+     *    className: 'some_my_class'
+     * });
+     *
+     * console.log(jodit.container.classList.contains('some_my_class')); // true
+     * ```
+     * ```html
+     * <style>
+     * .some_my_class {
+     *    max-width: 600px;
+     *    margin: 0 auto;
+     * }
+     * </style>
+     * ```
+     */
+    className: false | string;
+    /**
+     * The internal styles of the editable area. They are intended to change
+     * not the appearance of the editor, but to change the appearance of the content.
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     * 		style: {
+     * 		 font: '12px Arial',
+     * 		 color: '#0c0c0c'
+     * 		}
+     * });
+     * ```
+     */
+    style: false | IDictionary;
+    /**
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     * 		editorStyle: {
+     * 		 font: '12px Arial',
+     * 		 color: '#0c0c0c'
+     * 		}
+     * });
+     * ```
+     */
+    containerStyle: false | IDictionary;
+    /**
+     * Dictionary of variable values in css, a complete list can be found here
+     * https://github.com/xdan/jodit/blob/main/src/styles/variables.less#L25
+     *
+     * @example
+     * ```js
+     * const editor = Jodit.make('#editor', {
+     *   styleValues: {
+     *		'color-text': 'red',
+     *		colorBorder: 'black',
+     *		'color-panel': 'blue'
+     *   }
+     * });
+     * ```
+     */
+    styleValues: IDictionary;
+    /**
+     * After all, changes in editors for textarea will call change trigger
+     *
+     * @example
+     * ```javascript
+     * const editor = Jodit.make('#editor');
+     * document.getElementById('editor').addEventListener('change', function () {
+     *      console.log(this.value);
+     * })
+     * ```
+     */
+    triggerChangeEvent: boolean;
+    /**
+     * The writing direction of the language which is used to create editor content. Allowed values are: ''
+     * (an empty string) – Indicates that content direction will be the same as either the editor UI direction or
+     * the page element direction. 'ltr' – Indicates a Left-To-Right text direction (like in English).
+     * 'rtl' – Indicates a Right-To-Left text direction (like in Arabic).
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('.editor', {
+     *    direction: 'rtl'
+     * })
+     * ```
+     */
+    direction: 'rtl' | 'ltr' | '';
+    /**
+     * Language by default. if `auto` language set by document.documentElement.lang ||
+     * (navigator.language && navigator.language.substr(0, 2)) ||
+     * (navigator.browserLanguage && navigator.browserLanguage.substr(0, 2)) || 'en'
+     *
+     * @example
+     * ```html
+     * <!-- include in you page lang file -->
+     * <script src="jodit/lang/de.js"></script>
+     * <script>
+     * var editor = Jodit.make('.editor', {
+     *    language: 'de'
+     * });
+     * </script>
+     * ```
+     */
+    language: string;
+    /**
+     * if true all Lang.i18n(key) return `{key}`
+     *
+     * @example
+     * ```html
+     * <script>
+     * var editor = Jodit.make('.editor', {
+     *    debugLanguage: true
+     * });
+     *
+     * console.log(editor.i18n("Test")); // {Test}
+     * </script>
+     * ```
+     */
+    debugLanguage: boolean;
+    /**
+     * Collection of language pack data `{en: {'Type something': 'Type something', ...}}`
+     *
+     * @example
+     * ```javascript
+     * const editor = Jodit.make('#editor', {
+     *     language: 'ru',
+     *     i18n: {
+     *         ru: {
+     *            'Type something': 'Начните что-либо вводить'
+     *         }
+     *     }
+     * });
+     * console.log(editor.i18n('Type something')) //Начните что-либо вводить
+     * ```
+     */
+    i18n: IDictionary<IDictionary<string>> | false;
+    /**
+     * The tabindex global attribute is an integer indicating if the element can take
+     * input focus (is focusable), if it should participate to sequential keyboard navigation,
+     * and if so, at what position. It can take several values
+     */
+    tabIndex: number;
+    /**
+     * Boolean, whether the toolbar should be shown.
+     * Alternatively, a valid css-selector-string to use an element as toolbar container.
+     */
+    toolbar: boolean | string | HTMLElement;
+    /**
+     * Boolean, whether the statusbar should be shown.
+     */
+    statusbar: boolean;
+    /**
+     * Show tooltip after mouse enter on the button
+     */
+    showTooltip: boolean;
+    /**
+     * Delay before show tooltip
+     */
+    showTooltipDelay: number;
+    /**
+     * Instead of create custop tooltip - use native title tooltips
+     */
+    useNativeTooltip: boolean;
+    /**
+     * Default insert method
+     * @default insert_as_html
+     */
+    defaultActionOnPaste: InsertMode;
+    /**
+     * Element that will be created when you press Enter
+     */
+    enter: 'p' | 'div' | 'br';
+    /**
+     * When this option is enabled, the editor's content will be placed in an iframe and isolated from the rest of the page.
+     *
+     * @example
+     * ```javascript
+     * Jodit.make('#editor', {
+     *    iframe: true,
+     *    iframeStyle: 'html{margin: 0px;}body{padding:10px;background:transparent;color:#000;position:relative;z-index:2;\
+     *    user-select:auto;margin:0px;overflow:hidden;}body:after{content:"";clear:both;display:block}';
+     * });
+     * ```
+     */
+    iframe: boolean;
+    /**
+     * Allow editing the entire HTML document(html, head)
+     * \> Works together with the iframe option.
+     * @example
+     * ```js
+     * const editor = Jodit.make('#editor', {
+     *   iframe: true,
+     *   editHTMLDocumentMode: true
+     * });
+     * editor.value = '<!DOCTYPE html><html lang="en" style="overflow-y:hidden">' +
+     * 	'<head><title>Jodit Editor</title></head>' +
+     * 	'<body spellcheck="false"><p>Some text</p><p> a </p></body>' +
+     * 	'</html>';
+     * ```
+     */
+    editHTMLDocumentMode: boolean;
+    /**
+     * Use when you need to insert new block element
+     * use enter option if not set
+     */
+    enterBlock: 'p' | 'div';
+    /**
+     * Jodit.MODE_WYSIWYG The HTML editor allows you to write like MSWord,
+     * Jodit.MODE_SOURCE syntax highlighting source editor
+     * @example
+     * ```javascript
+     * var editor = Jodit.make('#editor', {
+     *     defaultMode: Jodit.MODE_SPLIT
+     * });
+     * console.log(editor.getRealMode())
+     * ```
+     */
+    defaultMode: number;
+    /**
+     * Use split mode
+     */
+    useSplitMode: boolean;
+    /**
+     * The colors in HEX representation to select a color for the background and for the text in colorpicker
+     * @example
+     * ```javascript
+     *  Jodit.make('#editor', {
+     *     colors: ['#ff0000', '#00ff00', '#0000ff']
+     * })
+     * ```
+     */
+    colors: IDictionary<string[]> | string[];
+    /**
+     * The default tab color picker
+     * @example
+     * ```javascript
+     * Jodit.make('#editor2', {
+     *     colorPickerDefaultTab: 'color'
+     * })
+     * ```
+     */
+    colorPickerDefaultTab: 'background' | 'color';
+    /**
+     * Image size defaults to a larger image
+     */
+    imageDefaultWidth: number;
+    /**
+     * Do not display these buttons that are on the list
+     * @example
+     * ```javascript
+     * Jodit.make('#editor2', {
+     *     removeButtons: ['hr', 'source']
+     * });
+     * ```
+     */
+    removeButtons: string[];
+    /**
+     * Do not init these plugins
+     * @example
+     * ```typescript
+     * var editor = Jodit.make('.editor', {
+     *    disablePlugins: 'table,iframe'
+     * });
+     * //or
+     * var editor = Jodit.make('.editor', {
+     *    disablePlugins: ['table', 'iframe']
+     * });
+     * ```
+     */
+    disablePlugins: string[] | string;
+    /**
+     * Init and download extra plugins
+     * @example
+     * ```typescript
+     * var editor = Jodit.make('.editor', {
+     *    extraPlugins: ['emoji']
+     * });
+     * ```
+     * It will try load %SCRIPT_PATH%/plugins/emoji/emoji.js and after load will try init it
+     */
+    extraPlugins: Array<string | IExtraPlugin>;
+    /**
+     * Base path for download extra plugins
+     */
+    basePath?: string;
+    /**
+     * These buttons list will be added to the option. Buttons
+     */
+    extraButtons: Array<string | IControlType>;
+    /**
+     * By default, you can only install an icon from the Jodit suite.
+     * You can add your icon to the set using the `Jodit.modules.Icon.set (name, svg Code)` method.
+     * But for a declarative declaration, you can use this option.
+     *
+     * @example
+     * ```js
+     * Jodit.modules.Icon.set('someIcon', '<svg><path.../></svg>');
+     * const editor = Jodit.make({
+     *   extraButtons: [{
+     *     name: 'someButton',
+     *     icon: 'someIcon'
+     *   }]
+     * });
+     *
+     * @example
+     * const editor = Jodit.make({
+     *   extraIcons: {
+     *     someIcon: '<svg><path.../></svg>'
+     *   },
+     *   extraButtons: [{
+     *     name: 'someButton',
+     *     icon: 'someIcon'
+     *   }]
+     * });
+     * ```
+     * @example
+     * ```js
+     * const editor = Jodit.make({
+     *   extraButtons: [{
+     *     name: 'someButton',
+     *     icon: '<svg><path.../></svg>'
+     *   }]
+     * });
+     * ```
+     */
+    extraIcons: IDictionary<string>;
+    /**
+     * Default attributes for created inside editor elements
+     * @example
+     * ```js
+     * const editor2 = Jodit.make('#editor', {
+     * 	createAttributes: {
+     * 		div: {
+     * 			class: 'test'
+     * 		},
+     * 		ul: function (ul) {
+     * 			ul.classList.add('ui-test');
+     * 		}
+     * 	}
+     * });
+     *
+     * const div2 = editor2.createInside.div();
+     * expect(div2.className).equals('test');
+     *
+     * const ul = editor2.createInside.element('ul');
+     * expect(ul.className).equals('ui-test');
+     * ```
+     * Or JSX in React
+     * @example
+     * ```jsx
+     * import React, {useState, useRef} from 'react';
+     * import JoditEditor from "jodit-react";
+     *
+     * const config = {
+     * 	createAttributes: {
+     * 		div: {
+     * 			class: 'align-center'
+     * 		}
+     * 	}
+     * };
+     *
+     * <JoditEditor config={config}/>
+     * ```
+     */
+    createAttributes: IDictionary<Attributes | NodeFunction>;
+    /**
+     * The width of the editor, accepted as the biggest. Used to the responsive version of the editor
+     */
+    sizeLG: number;
+    /**
+     * The width of the editor, accepted as the medium. Used to the responsive version of the editor
+     */
+    sizeMD: number;
+    /**
+     * The width of the editor, accepted as the small. Used to the responsive version of the editor
+     */
+    sizeSM: number;
+    /**
      * The list of buttons that appear in the editor's toolbar on large places (≥ options.sizeLG).
      * Note - this is not the width of the device, the width of the editor
      * @example
@@ -672,961 +672,875 @@ declare class Config implements IViewOptions {
      *  });
      * ```
      */
-	buttons: ButtonsOption;
-	/**
-	 * Behavior for buttons
-	 */
-	controls: Controls;
-	/**
-	 * Some events are called when the editor is initialized, for example, the `afterInit` event.
-	 * So this code won't work:
-	 * ```javascript
-	 * const editor = Jodit.make('#editor');
-	 * editor.events.on('afterInit', () => console.log('afterInit'));
-	 * ```
-	 * You need to do this:
-	 * ```javascript
-	 * Jodit.make('#editor', {
-	 * 		events: {
-	 * 	  	afterInit: () => console.log('afterInit')
-	 * 		}
-	 * });
-	 * ```
-	 * The option can use any Jodit events, for example:
-	 * ```javascript
-	 * const editor = Jodit.make('#editor', {
-	 * 		events: {
-	 * 			hello: (name) => console.log('Hello', name)
-	 * 		}
-	 * });
-	 * editor.e.fire('hello', 'Mike');
-	 * ```
-	 */
-	events: IDictionary<(...args: any[]) => any>;
-	/**
-	 * Buttons in toolbat without SVG - only texts
-	 */
-	textIcons: boolean;
-	/**
-	 * Element for dialog container
-	 */
-	popupRoot: Nullable<HTMLElement>;
-	/**
-	 * shows a INPUT[type=color] to open the browser color picker, on the right bottom of widget color picker
-	 */
-	showBrowserColorPicker: boolean;
-	private static __defaultOptions;
-	static get defaultOptions(): Config;
+    buttons: ButtonsOption;
+    /**
+     * Behavior for buttons
+     */
+    controls: Controls;
+    /**
+     * Some events are called when the editor is initialized, for example, the `afterInit` event.
+     * So this code won't work:
+     * ```javascript
+     * const editor = Jodit.make('#editor');
+     * editor.events.on('afterInit', () => console.log('afterInit'));
+     * ```
+     * You need to do this:
+     * ```javascript
+     * Jodit.make('#editor', {
+     * 		events: {
+     * 	  	afterInit: () => console.log('afterInit')
+     * 		}
+     * });
+     * ```
+     * The option can use any Jodit events, for example:
+     * ```javascript
+     * const editor = Jodit.make('#editor', {
+     * 		events: {
+     * 			hello: (name) => console.log('Hello', name)
+     * 		}
+     * });
+     * editor.e.fire('hello', 'Mike');
+     * ```
+     */
+    events: IDictionary<(...args: any[]) => any>;
+    /**
+     * Buttons in toolbat without SVG - only texts
+     */
+    textIcons: boolean;
+    /**
+     * Element for dialog container
+     */
+    popupRoot: Nullable<HTMLElement>;
+    /**
+     * shows a INPUT[type=color] to open the browser color picker, on the right bottom of widget color picker
+     */
+    showBrowserColorPicker: boolean;
+    private static __defaultOptions;
+    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;
+    /**
+     * A set of key/value pairs that configure the Ajax request. All settings are optional
+     */
+    defaultAjaxOptions: AjaxOptions;
 }
 interface Config {
-	dialog: IDialogOptions;
+    dialog: IDialogOptions;
 }
 interface Config {
-	filebrowser: IFileBrowserOptions;
+    filebrowser: IFileBrowserOptions;
 }
 interface Config {
-	history: {
-		enable: boolean;
-
-		/**
-		 * Limit of history length
-		 */
-		maxHistoryLength: number;
-
-		/**
-		 * Delay on every change
-		 */
-		timeout: number;
-	};
+    history: {
+        enable: boolean;
+        /**
+         * Limit of history length
+         */
+        maxHistoryLength: number;
+        /**
+         * Delay on every change
+         */
+        timeout: number;
+    };
 }
 interface Config {
-	imageeditor: ImageEditorOptions;
+    imageeditor: ImageEditorOptions;
 }
 interface Config {
-	/**
-	 * Enable drag and drop file editor
-	 */
-	enableDragAndDropFileToEditor: boolean;
-	uploader: IUploaderOptions<IUploader>;
+    /**
+     * 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;
+    /**
+     * 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;
+    aiAssistant: AiAssistantSettings;
 }
 interface Config {
-	delete: {
-		hotkeys: {
-			delete: string[];
-			deleteWord: string[];
-			deleteSentence: string[];
-			backspace: string[];
-			backspaceWord: string[];
-			backspaceSentence: string[];
-		};
-	};
+    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>>;
-	};
+    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[];
+    /**
+     * 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>;
-	};
+    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;
+    autofocus: boolean;
+    cursorAfterAutofocus: 'start' | 'end';
+    saveSelectionOnBlur: boolean;
 }
 interface Config {
-	defaultFontSizePoints: 'px' | 'pt';
+    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;
+    /**
+     * 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[]>;
+    /**
+     * 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;
+    /**
+     * 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;
-	};
+    imageProcessor: {
+        replaceDataURIToBlobIdInView: boolean;
+    };
 }
 interface Config {
-	image: ImagePropertiesOptions;
+    image: ImagePropertiesOptions;
 }
 interface Config {
-	/**
-	 * The number of pixels to use for indenting the current line.
-	 */
-	indentMargin: number;
+    /**
+     * 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[];
+    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;
+    /**
+     * 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;
+    /**
+     * 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[];
-	};
+    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[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Hide the link to the Jodit site at the bottom of the editor
+     */
+    hidePoweredByJodit: boolean;
 }
 interface Config {
-	tableAllowCellResize: boolean;
+    tableAllowCellResize: boolean;
 }
 interface Config {
-	allowResizeX: boolean;
-	allowResizeY: boolean;
+    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;
-	};
+    /**
+     * 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;
-	};
+    /**
+     * 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;
-	};
+    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;
+    tableAllowCellSelection: boolean;
 }
 interface Config {
-	saveHeightInStorage: boolean;
-
-	minWidth: number | string;
-	minHeight: number | string;
-	maxWidth: number | string;
-	maxHeight: number | string;
+    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,
+    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[];
+         * })
+         * ```
+         */
+    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>;
-	};
+    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;
+    /**
+     * 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;
+    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;
+    /**
+     * @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;
+    specialCharacters: string[];
+    usePopupForSpecialCharacters: boolean;
 }
 interface Config {
-	tab: {
-		/**
-		 * Pressing Tab inside LI will add an internal list
-		 */
-		tabInsideLiInsertNewList: boolean;
-	};
+    tab: {
+        /**
+         * Pressing Tab inside LI will add an internal list
+         */
+        tabInsideLiInsertNewList: boolean;
+    };
 }
 interface Config {
-	table: {
-		selectionCellStyle: string;
-		useExtraClassesOptions: boolean;
-	};
+    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;
-	};
+    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;
-	};
+    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;
+    showXPathInStatusbar: boolean;
 }