# Class: Config

Defined in: [src/config.ts:137](https://github.com/xdan/jodit/blob/main/src/config.ts#L137)

Default Editor's Configuration.

This class holds all default option values for the Jodit editor.
It uses a **private constructor** and a **lazy singleton** pattern — the single instance
is created on the first access to [Config.defaultOptions](#defaultoptions) (also available as `Jodit.defaultOptions`).

## How options are resolved

When you create an editor with `Jodit.make('#editor', userOptions)`, the library
calls ConfigProto(userOptions, Config.defaultOptions). `ConfigProto` does
**not** deep-clone the defaults. Instead it creates a new object whose JavaScript
prototype is `Config.defaultOptions`:

```
userOptions  ──[[Prototype]]──►  Config.defaultOptions
```

Any key present in `userOptions` shadows the default;
any key **not** present falls through to `Config.defaultOptions` via the prototype chain.
Nested plain objects are recursively prototyped in the same way, so partial overrides
of nested options work automatically:

```js
// Only override `dialogWidth`; all other `image.*` defaults are still available
Jodit.make('#editor', {
  image: { dialogWidth: 500 }
});
```

## How plugins extend the config

Each plugin adds its own defaults by assigning to `Config.prototype` and augmenting
the TypeScript type with `declare module`:

```ts
// 1. Type augmentation (compile-time)
declare module 'jodit/config' {
  interface Config {
    toolbarSticky: boolean;
  }
}

// 2. Runtime default
Config.prototype.toolbarSticky = true;
```

Because the constructor runs `Object.assign(this, ConfigPrototype)` (where
`ConfigPrototype` is captured as `Config.prototype` after the class definition),
all prototype-level values — including those added by plugins — are materialized
as own properties on the singleton. This means `Config.defaultOptions` always
contains every registered option as an own, enumerable property.

## Changing global defaults

You can modify `Jodit.defaultOptions` **before** creating editors to change
defaults globally:

```js
Jodit.defaultOptions.language = 'de';
Jodit.defaultOptions.theme = 'dark';

// Both editors inherit the new defaults
Jodit.make('#editor1');
Jodit.make('#editor2');
```

## `Jodit.atom` — preventing deep merge

By default, `ConfigProto` deep-merges nested plain objects and arrays.
Wrap a value with `Jodit.atom(value)` to make it **atomic** — it will completely
replace the default instead of being merged:

```js
Jodit.make('#editor', {
  controls: {
    fontsize: {
      // Replace the entire list rather than merging with the default one
      list: Jodit.atom([8, 9, 10])
    }
  }
});
```

`Jodit.atom` calls markAsAtomic, which sets a non-enumerable
`isAtom` flag on the object. `ConfigProto` checks this flag and skips
recursive merging when it is present. Note: top-level arrays (depth 0)
are always treated as atomic — they replace rather than merge.

## See

 - ConfigProto for the full merge algorithm
 - markAsAtomic / isAtom for the atom marker implementation

## Implements

- [`IViewOptions`](./interfaces/types.IViewOptions.html)

### cache

**cache**: `boolean` = `true`

Defined in: [src/config.ts:146](https://github.com/xdan/jodit/blob/main/src/config.ts#L146)

When enabled, the editor caches the results of expensive computations (e.g. toolbar rebuilds)
to improve performance. Disable for debugging or when options change frequently at runtime.

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`cache`](./interfaces/types.IViewOptions.html#cache)

***

### defaultTimeout

**defaultTimeout**: `number` = `100`

Defined in: [src/config.ts:151](https://github.com/xdan/jodit/blob/main/src/config.ts#L151)

Timeout of all asynchronous methods

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`defaultTimeout`](./interfaces/types.IViewOptions.html#defaulttimeout)

***

### namespace

**namespace**: `string` = `''`

Defined in: [src/config.ts:157](https://github.com/xdan/jodit/blob/main/src/config.ts#L157)

Prefix used for CSS class names and local-storage keys to avoid collisions
when multiple editor instances or applications share the same page.

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`namespace`](./interfaces/types.IViewOptions.html#namespace)

***

### safeMode

**safeMode**: `boolean` = `false`

Defined in: [src/config.ts:162](https://github.com/xdan/jodit/blob/main/src/config.ts#L162)

Editor loads completely without plugins. Useful when debugging your own plugin.

***

### width

**width**: `string` \| `number` = `'auto'`

Defined in: [src/config.ts:183](https://github.com/xdan/jodit/blob/main/src/config.ts#L183)

Editor's width

```javascript
Jodit.make('.editor', {
   width: '100%',
})
```
```javascript
Jodit.make('.editor', {
   width: 600, // equivalent for '600px'
})
```
```javascript
Jodit.make('.editor', {
   width: 'auto', // autosize
})
```

***

### height

**height**: `string` \| `number` = `'auto'`

Defined in: [src/config.ts:204](https://github.com/xdan/jodit/blob/main/src/config.ts#L204)

Editor's height

```javascript
Jodit.make('.editor', {
   height: '100%',
})
```
```javascript
Jodit.make('.editor', {
   height: 600, // equivalent for '600px'
})
```
```javascript
Jodit.make('.editor', {
   height: 'auto', // default - autosize
})
```

***

### safePluginsList

**safePluginsList**: `string`[]

Defined in: [src/config.ts:217](https://github.com/xdan/jodit/blob/main/src/config.ts#L217)

List of plugins that will be initialized in safe mode.

```js
Jodit.make('#editor', {
  safeMode: true,
  safePluginsList: ['about'],
  extraPlugins: ['yourPluginDev']
});
```

***

### commandToHotkeys

**commandToHotkeys**: [`IDictionary`](./modules/types.html#idictionary)\<`string` \| `string`[]\>

Defined in: [src/config.ts:226](https://github.com/xdan/jodit/blob/main/src/config.ts#L226)

You can redefine hotkeys for some command

```js
const jodit = Jodit.make('#editor', {
 commandToHotkeys: {
     bold: 'ctrl+shift+b',
     italic: ['ctrl+i', 'ctrl+b'],
 }
})
```

***

### license

**license**: `string` = `''`

Defined in: [src/config.ts:231](https://github.com/xdan/jodit/blob/main/src/config.ts#L231)

Reserved for the paid version of the editor

***

### preset

**preset**: `string` = `'custom'`

Defined in: [src/config.ts:242](https://github.com/xdan/jodit/blob/main/src/config.ts#L242)

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'
});
```

***

### presets

**presets**: [`IDictionary`](./modules/types.html#idictionary)

Defined in: [src/config.ts:270](https://github.com/xdan/jodit/blob/main/src/config.ts#L270)

Dictionary of named configuration presets. Each key is a preset name and the value
is a partial options object that will be merged into the editor config when
[Config.preset](#preset) matches the key.

```javascript
// Use a built-in preset
Jodit.make('#editor', {
    preset: 'inline'
});
```

```javascript
// Define and use a custom preset
Jodit.defaultOptions.presets.myCompact = {
    toolbarButtonSize: 'small',
    showCharsCounter: false,
    showWordsCounter: false,
    showXPathInStatusbar: false
};

Jodit.make('#editor', {
    preset: 'myCompact'
});
```

***

### ownerDocument

**ownerDocument**: [`Document`](https://developer.mozilla.org/docs/Web/API/Document) = `globalDocument`

Defined in: [src/config.ts:287](https://github.com/xdan/jodit/blob/main/src/config.ts#L287)

The Document object the editor operates within. Defaults to the current `document`.
Override when the editor is created inside an iframe or a different browsing context.

***

### ownerWindow

**ownerWindow**: [`Window`](https://developer.mozilla.org/docs/Web/API/Window) = `globalWindow`

Defined in: [src/config.ts:293](https://github.com/xdan/jodit/blob/main/src/config.ts#L293)

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

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`ownerWindow`](./interfaces/types.IViewOptions.html#ownerwindow)

***

### shadowRoot

**shadowRoot**: [`Nullable`](./modules/types.html#nullable)\<[`ShadowRoot`](https://developer.mozilla.org/docs/Web/API/ShadowRoot)\> = `null`

Defined in: [src/config.ts:320](https://github.com/xdan/jodit/blob/main/src/config.ts#L320)

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>';
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`shadowRoot`](./interfaces/types.IViewOptions.html#shadowroot)

***

### nonce

**nonce**: `string` = `''`

Defined in: [src/config.ts:335](https://github.com/xdan/jodit/blob/main/src/config.ts#L335)

CSP nonce applied to every `<style>`, `<script>` and `<link>` element
Jodit injects at runtime (plugin styles, CDN scripts for ACE/beautify,
downloaded stylesheets). Set it to the same nonce your server puts in the
`Content-Security-Policy` header so a strict `style-src`/`script-src`
policy does not block the editor.

```js
Jodit.make('#editor', {
  nonce: 'r4nd0m'
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`nonce`](./interfaces/types.IViewOptions.html#nonce)

***

### zIndex

**zIndex**: `number` = `0`

Defined in: [src/config.ts:342](https://github.com/xdan/jodit/blob/main/src/config.ts#L342)

Base CSS `z-index` for the editor UI (toolbar, popups, dialogs).
Set to a higher value when other page elements overlap the editor.
`0` means no explicit z-index is applied.

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`zIndex`](./interfaces/types.IViewOptions.html#zindex)

***

### readonly

**readonly**: `boolean` = `false`

Defined in: [src/config.ts:347](https://github.com/xdan/jodit/blob/main/src/config.ts#L347)

Change the read-only state of the editor

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`readonly`](./interfaces/types.IViewOptions.html#readonly)

***

### disabled

**disabled**: `boolean` = `false`

Defined in: [src/config.ts:352](https://github.com/xdan/jodit/blob/main/src/config.ts#L352)

Change the disabled state of the editor

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`disabled`](./interfaces/types.IViewOptions.html#disabled)

***

### activeButtonsInReadOnly

**activeButtonsInReadOnly**: `string`[]

Defined in: [src/config.ts:357](https://github.com/xdan/jodit/blob/main/src/config.ts#L357)

In readOnly mode, some buttons can still be useful, for example, the button to view source code or print

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`activeButtonsInReadOnly`](./interfaces/types.IViewOptions.html#activebuttonsinreadonly)

***

### allowCommandsInReadOnly

**allowCommandsInReadOnly**: `string`[]

Defined in: [src/config.ts:377](https://github.com/xdan/jodit/blob/main/src/config.ts#L377)

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
```

***

### toolbarButtonSize

**toolbarButtonSize**: `"small"` \| `"tiny"` \| `"xsmall"` \| `"middle"` \| `"large"` = `'middle'`

Defined in: [src/config.ts:388](https://github.com/xdan/jodit/blob/main/src/config.ts#L388)

Size of icons in the toolbar (can be "small", "middle", "large")

```javascript
const editor = Jodit.make(".dark_editor", {
     toolbarButtonSize: "small"
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`toolbarButtonSize`](./interfaces/types.IViewOptions.html#toolbarbuttonsize)

***

### allowTabNavigation

**allowTabNavigation**: `boolean` = `false`

Defined in: [src/config.ts:393](https://github.com/xdan/jodit/blob/main/src/config.ts#L393)

Allow navigation in the toolbar of the editor by Tab key

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`allowTabNavigation`](./interfaces/types.IViewOptions.html#allowtabnavigation)

***

### inline

**inline**: `boolean` = `false`

Defined in: [src/config.ts:400](https://github.com/xdan/jodit/blob/main/src/config.ts#L400)

When enabled, the editor renders without its own container chrome (toolbar, borders, statusbar).
The editable area becomes the element itself. Typically combined with
`toolbarInline: true` so a floating toolbar appears on selection.

***

### theme

**theme**: `string` = `'default'`

Defined in: [src/config.ts:411](https://github.com/xdan/jodit/blob/main/src/config.ts#L411)

Theme (can be "dark")

```javascript
const editor = Jodit.make(".dark_editor", {
     theme: "dark"
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`theme`](./interfaces/types.IViewOptions.html#theme)

***

### saveModeInStorage

**saveModeInStorage**: `boolean` = `false`

Defined in: [src/config.ts:416](https://github.com/xdan/jodit/blob/main/src/config.ts#L416)

if set true, then the current mode is saved in a cookie, and is restored after a reload of the page

***

### asyncStorage

**asyncStorage**: [`IAsyncStorageOptions`](./interfaces/types.IAsyncStorageOptions.html) = `{}`

Defined in: [src/config.ts:438](https://github.com/xdan/jodit/blob/main/src/config.ts#L438)

Configure the provider that backs IViewBased.asyncStorage.

By default the editor's `asyncStorage` uses persistent `IndexedDB` (with an
in-memory fallback when it is unavailable). Set `defaultProvider` to override it:
- `'local'` — persist in `localStorage`;
- `'memory'` — keep everything in memory (nothing survives a reload);
- a custom IAsyncStorage implementation — plug in your own backend.

```javascript
Jodit.make('#editor', {
   asyncStorage: { defaultProvider: 'local' }
});

// or a fully custom backend
Jodit.make('#editor', {
   asyncStorage: { defaultProvider: myAsyncStorage }
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`asyncStorage`](./interfaces/types.IViewOptions.html#asyncstorage)

***

### editorClassName

**editorClassName**: `string` \| `false` = `false`

Defined in: [src/config.ts:459](https://github.com/xdan/jodit/blob/main/src/config.ts#L459)

Class name that can be appended to the editable area

#### See

 - [Config.iframeCSSLinks](#iframecsslinks)
 - [Config.iframeStyle](#iframestyle)

```javascript
Jodit.make('#editor', {
   editorClassName: 'some_my_class'
});
```
```html
<style>
.some_my_class p{
   line-height: 16px;
}
</style>
```

***

### className

**className**: `string` \| `false` = `false`

Defined in: [src/config.ts:480](https://github.com/xdan/jodit/blob/main/src/config.ts#L480)

Class name that can be appended to the main editor container

```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>
```

***

### style

**style**: `false` \| [`IDictionary`](./modules/types.html#idictionary) = `false`

Defined in: [src/config.ts:495](https://github.com/xdan/jodit/blob/main/src/config.ts#L495)

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.

```javascript
Jodit.make('#editor', {
    style: {
     font: '12px Arial',
     color: '#0c0c0c'
    }
});
```

***

### containerStyle

**containerStyle**: `false` \| [`IDictionary`](./modules/types.html#idictionary) = `false`

Defined in: [src/config.ts:510](https://github.com/xdan/jodit/blob/main/src/config.ts#L510)

Inline CSS styles applied to the outer editor container element.
Use this to style the editor wrapper (borders, background, etc.) without affecting content.

```javascript
Jodit.make('#editor', {
    containerStyle: {
     border: '1px solid #ccc',
     background: '#f9f9f9'
    }
});
```

***

### styleValues

**styleValues**: [`IDictionary`](./modules/types.html#idictionary) = `{}`

Defined in: [src/config.ts:526](https://github.com/xdan/jodit/blob/main/src/config.ts#L526)

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

```js
const editor = Jodit.make('#editor', {
  styleValues: {
    'color-text': 'red',
    colorBorder: 'black',
    'color-panel': 'blue'
  }
});
```

***

### triggerChangeEvent

**triggerChangeEvent**: `boolean` = `true`

Defined in: [src/config.ts:539](https://github.com/xdan/jodit/blob/main/src/config.ts#L539)

When enabled, the editor dispatches a native `change` event on the original
`<textarea>` element whenever the content changes, so standard DOM listeners work.

```javascript
const editor = Jodit.make('#editor');
document.getElementById('editor').addEventListener('change', function () {
     console.log(this.value);
})
```

***

### direction

**direction**: `""` \| `"rtl"` \| `"ltr"` = `''`

Defined in: [src/config.ts:553](https://github.com/xdan/jodit/blob/main/src/config.ts#L553)

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).

```javascript
Jodit.make('.editor', {
   direction: 'rtl'
})
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`direction`](./interfaces/types.IViewOptions.html#direction)

***

### language

**language**: `string` = `'auto'`

Defined in: [src/config.ts:570](https://github.com/xdan/jodit/blob/main/src/config.ts#L570)

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'

```html
<!-- include in you page lang file -->
<script src="jodit/lang/de.js"></script>
<script>
var editor = Jodit.make('.editor', {
   language: 'de'
});
</script>
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`language`](./interfaces/types.IViewOptions.html#language)

***

### debugLanguage

**debugLanguage**: `boolean` = `false`

Defined in: [src/config.ts:585](https://github.com/xdan/jodit/blob/main/src/config.ts#L585)

if true all Lang.i18n(key) return `{key}`

```html
<script>
var editor = Jodit.make('.editor', {
   debugLanguage: true
});

console.log(editor.i18n("Test")); // {Test}
</script>
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`debugLanguage`](./interfaces/types.IViewOptions.html#debuglanguage)

***

### i18n

**i18n**: `false` \| [`IDictionary`](./modules/types.html#idictionary)\<[`IDictionary`](./modules/types.html#idictionary)\<`string`\>\> = `false`

Defined in: [src/config.ts:602](https://github.com/xdan/jodit/blob/main/src/config.ts#L602)

Collection of language pack data `{en: {'Type something': 'Type something', ...}}`

```javascript
const editor = Jodit.make('#editor', {
    language: 'ru',
    i18n: {
        ru: {
           'Type something': 'Начните что-либо вводить'
        }
    }
});
console.log(editor.i18n('Type something')) //Начните что-либо вводить
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`i18n`](./interfaces/types.IViewOptions.html#i18n)

***

### tabIndex

**tabIndex**: `number` = `-1`

Defined in: [src/config.ts:609](https://github.com/xdan/jodit/blob/main/src/config.ts#L609)

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

***

### toolbar

**toolbar**: `string` \| `boolean` \| [`HTMLElement`](https://developer.mozilla.org/docs/Web/API/HTMLElement) = `true`

Defined in: [src/config.ts:615](https://github.com/xdan/jodit/blob/main/src/config.ts#L615)

Boolean, whether the toolbar should be shown.
Alternatively, a valid css-selector-string to use an element as toolbar container.

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`toolbar`](./interfaces/types.IViewOptions.html#toolbar)

***

### statusbar

**statusbar**: `boolean` = `true`

Defined in: [src/config.ts:620](https://github.com/xdan/jodit/blob/main/src/config.ts#L620)

Boolean, whether the statusbar should be shown.

***

### showTooltip

**showTooltip**: `boolean` = `true`

Defined in: [src/config.ts:625](https://github.com/xdan/jodit/blob/main/src/config.ts#L625)

Show tooltip after mouse enter on the button

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`showTooltip`](./interfaces/types.IViewOptions.html#showtooltip)

***

### showTooltipDelay

**showTooltipDelay**: `number` = `200`

Defined in: [src/config.ts:630](https://github.com/xdan/jodit/blob/main/src/config.ts#L630)

Delay before show tooltip

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`showTooltipDelay`](./interfaces/types.IViewOptions.html#showtooltipdelay)

***

### useNativeTooltip

**useNativeTooltip**: `boolean` = `false`

Defined in: [src/config.ts:635](https://github.com/xdan/jodit/blob/main/src/config.ts#L635)

Instead of creating a custom tooltip, use the browser's native title tooltips

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`useNativeTooltip`](./interfaces/types.IViewOptions.html#usenativetooltip)

***

### defaultActionOnPaste

**defaultActionOnPaste**: [`InsertMode`](./modules/types.html#insertmode) = `INSERT_AS_HTML`

Defined in: [src/config.ts:641](https://github.com/xdan/jodit/blob/main/src/config.ts#L641)

How pasted content is inserted into the editor by default.
Possible values: `insert_as_html`, `insert_as_text`, `insert_only_text`, `insert_clear_html`.

***

### enter

**enter**: `"br"` \| `"div"` \| `"p"` = `consts.PARAGRAPH`

Defined in: [src/config.ts:652](https://github.com/xdan/jodit/blob/main/src/config.ts#L652)

Element that will be created when you press Enter

***

### iframe

**iframe**: `boolean` = `false`

Defined in: [src/config.ts:665](https://github.com/xdan/jodit/blob/main/src/config.ts#L665)

When this option is enabled, the editor's content will be placed in an iframe and isolated from the rest of the page.

```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}';
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`iframe`](./interfaces/types.IViewOptions.html#iframe)

***

### editHTMLDocumentMode

**editHTMLDocumentMode**: `boolean` = `false`

Defined in: [src/config.ts:682](https://github.com/xdan/jodit/blob/main/src/config.ts#L682)

Allow editing the entire HTML document(html, head)
\> Works together with the iframe option.

```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>';
```

***

### enterBlock

**enterBlock**: `"div"` \| `"p"`

Defined in: [src/config.ts:688](https://github.com/xdan/jodit/blob/main/src/config.ts#L688)

Use when you need to insert new block element
use enter option if not set

***

### defaultMode

**defaultMode**: `number` = `consts.MODE_WYSIWYG`

Defined in: [src/config.ts:702](https://github.com/xdan/jodit/blob/main/src/config.ts#L702)

Jodit.MODE_WYSIWYG The HTML editor allows you to write like MSWord,
Jodit.MODE_SOURCE syntax highlighting source editor

```javascript
var editor = Jodit.make('#editor', {
    defaultMode: Jodit.MODE_SPLIT
});
console.log(editor.getRealMode())
```

***

### useSplitMode

**useSplitMode**: `boolean` = `false`

Defined in: [src/config.ts:707](https://github.com/xdan/jodit/blob/main/src/config.ts#L707)

When enabled, the editor displays both the WYSIWYG view and the source-code view side by side.

***

### colors

**colors**: `string`[] \| [`IDictionary`](./modules/types.html#idictionary)\<`string`[]\>

Defined in: [src/config.ts:718](https://github.com/xdan/jodit/blob/main/src/config.ts#L718)

The colors in HEX representation to select a color for the background and for the text in colorpicker

```javascript
 Jodit.make('#editor', {
    colors: ['#ff0000', '#00ff00', '#0000ff']
})
```

***

### colorPickerDefaultTab

**colorPickerDefaultTab**: `"background"` \| `"color"` = `'background'`

Defined in: [src/config.ts:816](https://github.com/xdan/jodit/blob/main/src/config.ts#L816)

The default tab color picker

```javascript
Jodit.make('#editor2', {
    colorPickerDefaultTab: 'color'
})
```

***

### imageDefaultWidth

**imageDefaultWidth**: `number` = `300`

Defined in: [src/config.ts:821](https://github.com/xdan/jodit/blob/main/src/config.ts#L821)

Default width (in pixels) applied to images inserted into the editor

***

### removeButtons

**removeButtons**: `string`[] = `[]`

Defined in: [src/config.ts:832](https://github.com/xdan/jodit/blob/main/src/config.ts#L832)

Do not display these buttons that are on the list

```javascript
Jodit.make('#editor2', {
    removeButtons: ['hr', 'source']
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`removeButtons`](./interfaces/types.IViewOptions.html#removebuttons)

***

### disablePlugins

**disablePlugins**: `string` \| `string`[] = `[]`

Defined in: [src/config.ts:847](https://github.com/xdan/jodit/blob/main/src/config.ts#L847)

Do not init these plugins

```typescript
var editor = Jodit.make('.editor', {
   disablePlugins: 'table,iframe'
});
//or
var editor = Jodit.make('.editor', {
   disablePlugins: ['table', 'iframe']
});
```

***

### extraPlugins

**extraPlugins**: (`string` \| [`IExtraPlugin`](./interfaces/types.IExtraPlugin.html))[] = `[]`

Defined in: [src/config.ts:884](https://github.com/xdan/jodit/blob/main/src/config.ts#L884)

Init and download extra plugins that are **not** already bundled/registered.

For every name in this list that is not found in the plugin registry, Jodit
loads it **at runtime over the network** from:

```text
<basePath>plugins/<name>/<name>(.min).js
```

(see [Config.basePath](#basepath) and Config.minified). If the plugin is
already registered — e.g. you imported it statically, or you use a bundle
that ships it (such as the `jodit-pro` / `jodit-pro-react` "all plugins"
build) — it is **skipped** and no request is made; in that case you don't
need `extraPlugins` at all, just add the plugin's button.

```typescript
// Dynamic loading: fetches <basePath>plugins/emoji/emoji.js
const editor = Jodit.make('.editor', {
   extraPlugins: ['emoji']
});
```

You can also pass an explicit URL to bypass the `basePath` convention:

```typescript
const editor = Jodit.make('.editor', {
   extraPlugins: [{ name: 'emoji', url: 'https://cdn.example.com/emoji.js' }]
});
```

Note: if you see a request to a malformed URL (e.g. `.../src/main.tsx?t=...plugins/emoji/emoji.js`),
it means `basePath` was auto-detected incorrectly under your bundler — set
[Config.basePath](#basepath) explicitly. See the Plugin System docs for details.

***

### basePath?

`optional` **basePath?**: `string`

Defined in: [src/config.ts:908](https://github.com/xdan/jodit/blob/main/src/config.ts#L908)

Base path used to build the URL for dynamically loaded [Config.extraPlugins](#extraplugins)
(and their styles): `<basePath>plugins/<name>/<name>(.min).js`.

When not set, Jodit auto-detects it from `document.currentScript`, then the
last `<script src>` on the page, then `location.href`. That detection works
for classic `<script>` includes, but **fails under ESM bundlers / dev
servers** (Vite, Webpack dev, etc.) where there is no script tag for the
bundle — it falls back to the entry module URL (e.g. `main.tsx`) and produces
a broken plugin URL.

Fix: host the plugin files at a public location and point `basePath` there
(note the trailing slash):

```typescript
const editor = Jodit.make('.editor', {
   basePath: 'https://your-site.com/jodit-assets/',
   extraPlugins: ['emoji']
   // → loads https://your-site.com/jodit-assets/plugins/emoji/emoji.js
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`basePath`](./interfaces/types.IViewOptions.html#basepath)

***

### extraButtons

**extraButtons**: (`string` \| [`IControlType`](./interfaces/types.IControlType.html)\<[`IViewBased`](./interfaces/types.IViewBased.html)\<[`IViewOptions`](./interfaces/types.IViewOptions.html)\> \| [`IJodit`](./interfaces/types.IJodit.html) \| [`IFileBrowser`](./interfaces/types.IFileBrowser.html)\<[`IFileBrowserOptions`](./interfaces/types.IFileBrowserOptions.html)\>, [`IToolbarButton`](./interfaces/types.IToolbarButton.html)\>)[] = `[]`

Defined in: [src/config.ts:913](https://github.com/xdan/jodit/blob/main/src/config.ts#L913)

Additional buttons appended to the [Config.buttons](#buttons) list

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`extraButtons`](./interfaces/types.IViewOptions.html#extrabuttons)

***

### extraIcons

**extraIcons**: [`IDictionary`](./modules/types.html#idictionary)\<`string`\> = `{}`

Defined in: [src/config.ts:951](https://github.com/xdan/jodit/blob/main/src/config.ts#L951)

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.

```js
Jodit.modules.Icon.set('someIcon', '<svg><path.../></svg>');
const editor = Jodit.make({
  extraButtons: [{
    name: 'someButton',
    icon: 'someIcon'
  }]
});
```

```js
const editor = Jodit.make({
  extraIcons: {
    someIcon: '<svg><path.../></svg>'
  },
  extraButtons: [{
    name: 'someButton',
    icon: 'someIcon'
  }]
});
```

```js
const editor = Jodit.make({
  extraButtons: [{
    name: 'someButton',
    icon: '<svg><path.../></svg>'
  }]
});
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`extraIcons`](./interfaces/types.IViewOptions.html#extraicons)

***

### createAttributes

**createAttributes**: [`IDictionary`](./modules/types.html#idictionary)\<[`Attributes`](./modules/types.html#attributes) \| [`NodeFunction`](./modules/types.html#nodefunction)\>

Defined in: [src/config.ts:991](https://github.com/xdan/jodit/blob/main/src/config.ts#L991)

Default attributes for created inside editor elements

```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

```jsx
import React, {useState, useRef} from 'react';
import JoditEditor from "jodit-react";

const config = {
  createAttributes: {
    div: {
      class: 'align-center'
    }
  }
};

<JoditEditor config={config}/>
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`createAttributes`](./interfaces/types.IViewOptions.html#createattributes)

***

### sizeLG

**sizeLG**: `number` = `900`

Defined in: [src/config.ts:1000](https://github.com/xdan/jodit/blob/main/src/config.ts#L1000)

The width of the editor, accepted as the biggest. Used to the responsive version of the editor

***

### sizeMD

**sizeMD**: `number` = `700`

Defined in: [src/config.ts:1005](https://github.com/xdan/jodit/blob/main/src/config.ts#L1005)

The width of the editor, accepted as the medium. Used to the responsive version of the editor

***

### sizeSM

**sizeSM**: `number` = `400`

Defined in: [src/config.ts:1010](https://github.com/xdan/jodit/blob/main/src/config.ts#L1010)

The width of the editor, accepted as the small. Used to the responsive version of the editor

***

### buttons

**buttons**: [`ButtonsOption`](./modules/types.html#buttonsoption)

Defined in: [src/config.ts:1074](https://github.com/xdan/jodit/blob/main/src/config.ts#L1074)

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

```javascript
Jodit.make('#editor', {
    buttons: ['bold', 'italic', 'source'],
    buttonsMD: ['bold', 'italic'],
    buttonsXS: ['bold', 'fullsize'],
});
```

```javascript
Jodit.make('#editor2', {
    buttons: [{
        name: 'empty',
        icon: 'source',
        exec: function (editor) {
            const dialog = new Jodit.modules.Dialog({}),
                text = editor.c.element('textarea');

            dialog.setHeader('Source code');
            dialog.setContent(text);
            dialog.setSize(400, 300);

            Jodit.modules.Helpers.css(elm, {
                width: '100%',
                height: '100%'
            })

            dialog.open();
        }
    }]
});
```

```javascript
Jodit.make('#editor2', {
    buttons: Jodit.defaultOptions.buttons.concat([{
       name: 'listsss',
       iconURL: 'stuf/dummy.png',
       list: {
           h1: 'insert Header 1',
           h2: 'insert Header 2',
           clear: 'Empty editor',
       },
       exec: ({originalEvent, control, btn}) => {
            var key = control.args[0],
               value = control.args[1];
            if (key === 'clear') {
                this.val('');
                return;
            }
            this.s.insertNode(this.c.element(key, ''));
            this.message.info('Was inserted ' + value);
       },
       template: function (key, value) {
           return '<div>' + value + '</div>';
       }
 });
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`buttons`](./interfaces/types.IViewOptions.html#buttons)

***

### controls

**controls**: [`Controls`](./interfaces/types.Controls.html)

Defined in: [src/config.ts:1148](https://github.com/xdan/jodit/blob/main/src/config.ts#L1148)

Map of toolbar button names to their control definitions (icon, tooltip, exec handler, etc.).
Plugins extend this object with their own button definitions via `Config.prototype.controls`.

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`controls`](./interfaces/types.IViewOptions.html#controls)

***

### events

**events**: [`IDictionary`](./modules/types.html#idictionary)\<(...`args`) => `any`\> = `{}`

Defined in: [src/config.ts:1175](https://github.com/xdan/jodit/blob/main/src/config.ts#L1175)

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');
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`events`](./interfaces/types.IViewOptions.html#events)

***

### textIcons

**textIcons**: `boolean` = `false`

Defined in: [src/config.ts:1180](https://github.com/xdan/jodit/blob/main/src/config.ts#L1180)

Buttons in toolbar without SVG - only texts

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`textIcons`](./interfaces/types.IViewOptions.html#texticons)

***

### popupRoot

**popupRoot**: [`Nullable`](./modules/types.html#nullable)\<[`HTMLElement`](https://developer.mozilla.org/docs/Web/API/HTMLElement)\> = `null`

Defined in: [src/config.ts:1185](https://github.com/xdan/jodit/blob/main/src/config.ts#L1185)

Element for dialog container

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`popupRoot`](./interfaces/types.IViewOptions.html#popuproot)

***

### showBrowserColorPicker

**showBrowserColorPicker**: `boolean` = `true`

Defined in: [src/config.ts:1190](https://github.com/xdan/jodit/blob/main/src/config.ts#L1190)

shows a INPUT[type=color] to open the browser color picker, on the right bottom of widget color picker

***

### defaultAjaxOptions

**defaultAjaxOptions**: [`AjaxOptions`](./interfaces/types.AjaxOptions.html)

Defined in: [src/core/request/config.ts:19](https://github.com/xdan/jodit/blob/main/src/core/request/config.ts#L19)

A set of key/value pairs that configure the Ajax request. All settings are optional

***

### dialog

**dialog**: [`IDialogOptions`](./interfaces/types.IDialogOptions.html)

Defined in: [src/modules/dialog/dialog.ts:47](https://github.com/xdan/jodit/blob/main/src/modules/dialog/dialog.ts#L47)

***

### filebrowser

**filebrowser**: [`IFileBrowserOptions`](./interfaces/types.IFileBrowserOptions.html)

Defined in: [src/modules/file-browser/config.ts:31](https://github.com/xdan/jodit/blob/main/src/modules/file-browser/config.ts#L31)

***

### history

**history**: `object`

Defined in: [src/modules/history/history.ts:31](https://github.com/xdan/jodit/blob/main/src/modules/history/history.ts#L31)

#### enable

**enable**: `boolean`

#### maxHistoryLength

**maxHistoryLength**: `number`

Limit of history length

#### timeout

**timeout**: `number`

Delay on every change

***

### imageeditor

**imageeditor**: [`ImageEditorOptions`](./interfaces/types.ImageEditorOptions.html)

Defined in: [src/modules/image-editor/config.ts:20](https://github.com/xdan/jodit/blob/main/src/modules/image-editor/config.ts#L20)

***

### enableDragAndDropFileToEditor

**enableDragAndDropFileToEditor**: `boolean`

Defined in: [src/modules/uploader/config.ts:26](https://github.com/xdan/jodit/blob/main/src/modules/uploader/config.ts#L26)

Enable drag and drop file editor

***

### uploader

**uploader**: [`IUploaderOptions`](./interfaces/types.IUploaderOptions.html)\<[`IUploader`](./interfaces/types.IUploader.html)\>

Defined in: [src/modules/uploader/config.ts:27](https://github.com/xdan/jodit/blob/main/src/modules/uploader/config.ts#L27)

***

### addNewLine

**addNewLine**: `boolean`

Defined in: [src/plugins/add-new-line/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/add-new-line/config.ts#L23)

Show a green "add paragraph" bar when the cursor hovers near the top or bottom
edge of certain block elements (tables, images, iframes, etc.)

***

### addNewLineTagsTriggers

**addNewLineTagsTriggers**: [`HTMLTagNames`](./modules/types.html#htmltagnames)[]

Defined in: [src/plugins/add-new-line/config.ts:28](https://github.com/xdan/jodit/blob/main/src/plugins/add-new-line/config.ts#L28)

Block-level tag names near which the "add new line" bar will appear

***

### addNewLineOnDBLClick

**addNewLineOnDBLClick**: `boolean`

Defined in: [src/plugins/add-new-line/config.ts:39](https://github.com/xdan/jodit/blob/main/src/plugins/add-new-line/config.ts#L39)

On dbl click on empty space of editor it add new P element

```js
Jodit.make('#editor', {
  addNewLineOnDBLClick: false // disable
})
```

***

### addNewLineDeltaShow

**addNewLineDeltaShow**: `number`

Defined in: [src/plugins/add-new-line/config.ts:45](https://github.com/xdan/jodit/blob/main/src/plugins/add-new-line/config.ts#L45)

Absolute delta between cursor position and edge(top or bottom)
of element when show line

***

### aiAssistant

**aiAssistant**: [`AiAssistantSettings`](./interfaces/plugins_ai_assistant.AiAssistantSettings.html)

Defined in: [src/plugins/ai-assistant/config.ts:21](https://github.com/xdan/jodit/blob/main/src/plugins/ai-assistant/config.ts#L21)

***

### delete

**delete**: `object`

Defined in: [src/plugins/backspace/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/backspace/config.ts#L18)

Keyboard hotkey mappings for delete and backspace operations (character, word, sentence).

#### hotkeys

**hotkeys**: `object`

##### hotkeys.delete

**delete**: `string`[]

##### hotkeys.deleteWord

**deleteWord**: `string`[]

##### hotkeys.deleteSentence

**deleteSentence**: `string`[]

##### hotkeys.backspace

**backspace**: `string`[]

##### hotkeys.backspaceWord

**backspaceWord**: `string`[]

##### hotkeys.backspaceSentence

**backspaceSentence**: `string`[]

#### disableCases?

`optional` **disableCases?**: [`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)\<`string`\>

Disable specific Backspace/Delete cleanup cases by their stable
key, so the plugin no longer applies that particular behavior.
Available keys: `remove-unbreakable`, `remove-not-editable`,
`remove-char`, `table-cell`, `remove-empty-parent`,
`remove-empty-neighbor`, `join-two-lists`, `join-neighbors`,
`unwrap-first-list-item`.

```javascript
Jodit.make('#editor', {
   delete: { disableCases: new Set(['remove-empty-parent']) }
});
```

***

### cleanHTML

**cleanHTML**: `object`

Defined in: [src/plugins/clean-html/config.ts:19](https://github.com/xdan/jodit/blob/main/src/plugins/clean-html/config.ts#L19)

#### timeout

**timeout**: `number`

#### replaceNBSP

**replaceNBSP**: `boolean`

Replace &amp;nbsp; to plain space

#### fillEmptyParagraph

**fillEmptyParagraph**: `boolean`

Remove empty P tags, if they are not in the beginning of the text

#### removeEmptyElements

**removeEmptyElements**: `boolean`

Remove empty elements

#### collapseEmptyValueToEmptyString

**collapseEmptyValueToEmptyString**: `boolean`

Return an empty string from `editor.value` (and the synced source
element) when the editor holds only a single empty block — e.g.
`<p><br></p>` left after the user deletes all the content.
`contenteditable` keeps that caret container in the DOM, so by
default the value getter returns it as-is; enable this to collapse
it to `''` for form submission.

#### replaceOldTags

**replaceOldTags**: `false` \| [`IDictionary`](./modules/types.html#idictionary)\<[`HTMLTagNames`](./modules/types.html#htmltagnames)\>

Replace old tags to new eg. <i> to <em>, <b> to <strong>

#### useIframeSandbox

**useIframeSandbox**: `boolean`

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
   }
  });
```

#### ~~removeOnError~~

**removeOnError**: `boolean`

##### Deprecated

Use `removeEventAttributes` instead
Remove onError attributes

#### removeEventAttributes

**removeEventAttributes**: `boolean`

Remove all `on*` event handler attributes (onerror, onclick, onload, onmouseover, etc.)
When enabled, this replaces the legacy `removeOnError` behavior with comprehensive protection.

```javascript
Jodit.make('#editor', {
   cleanHTML: {
      removeEventAttributes: true
   }
});
```

#### safeJavaScriptLink

**safeJavaScriptLink**: `boolean`

Safe href="javascript:" links

#### safeLinksTarget

**safeLinksTarget**: `boolean`

Automatically add `rel="noopener noreferrer"` to links with `target="_blank"`

```javascript
Jodit.make('#editor', {
   cleanHTML: {
      safeLinksTarget: true
   }
});
```

#### allowedStyles

**allowedStyles**: `false` \| [`IDictionary`](./modules/types.html#idictionary)\<`string`[]\>

Whitelist of allowed CSS properties inside `style` attributes.
If set, all CSS properties not in the list will be removed.

```javascript
Jodit.make('#editor', {
    cleanHTML: {
        allowedStyles: {
            '*': ['color', 'background-color', 'font-size', 'text-align'],
            img: ['width', 'height']
        }
    }
});
```

#### sanitizer

**sanitizer**: `false` \| ((`value`) => `string`)

Custom sanitizer function. Called after Jodit's built-in sanitization.
Use this to integrate DOMPurify or other external sanitizers.

```javascript
import DOMPurify from 'dompurify';

Jodit.make('#editor', {
    cleanHTML: {
        sanitizer: (html) => DOMPurify.sanitize(html)
    }
});
```

#### sandboxIframesInContent

**sandboxIframesInContent**: `boolean`

Automatically add `sandbox=""` attribute to all `<iframe>` elements in editor content.
Prevents embedded content from running scripts or accessing the parent page.

```javascript
Jodit.make('#editor', {
    cleanHTML: {
        sandboxIframesInContent: true
    }
});
```

#### convertUnsafeEmbeds

**convertUnsafeEmbeds**: `false` \| `string`[]

Convert unsafe embed elements to sandboxed `<iframe>`.
- `['object', 'embed']` — default
- `false` — disabled
- `string[]` — custom list of tag names to convert

```javascript
Jodit.make('#editor', {
    cleanHTML: {
        convertUnsafeEmbeds: Jodit.atom(['object', 'embed', 'applet'])
    }
});
```

#### allowTags

**allowTags**: `string` \| `false` \| [`IDictionary`](./modules/types.html#idictionary)\<`string`\>

The allowTags option defines which elements will remain in the
edited text when the editor saves. You can use this limit the returned HTML.

```javascript
const jodit = new Jodit.make('#editor', {
   cleanHTML: {
      cleanOnPaste: false
   }
});
```

```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>
```

```javascript
const editor = Jodit.make('#editor', {
    cleanHTML: {
        allowTags: {
            p: true,
            a: {
                href: true
            },
            table: true,
            tr: true,
            td: true,
            img: {
                src: '1.png'
            }
        }
    }
});
```

#### denyTags

**denyTags**: `string` \| `false` \| [`IDictionary`](./modules/types.html#idictionary)\<`string`\>

#### disableCleanFilter

**disableCleanFilter**: [`Nullable`](./modules/types.html#nullable)\<[`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)\<`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

***

### draggableTags

**draggableTags**: `string` \| `string`[]

Defined in: [src/plugins/drag-and-drop-element/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/drag-and-drop-element/config.ts#L18)

Draggable elements

***

### dtd

**dtd**: `object`

Defined in: [src/plugins/dtd/config.ts:16](https://github.com/xdan/jodit/blob/main/src/plugins/dtd/config.ts#L16)

#### removeExtraBr

**removeExtraBr**: `boolean`

Remove extra br element inside block element after pasting

#### checkBlockNesting

**checkBlockNesting**: `boolean`

Check when inserting a block element if it can be inside another block element (according `blockLimits`)

#### blockLimits

**blockLimits**: [`IDictionary`](./modules/types.html#idictionary)\<`1`\>

List of elements that contain other blocks

***

### autofocus

**autofocus**: `boolean`

Defined in: [src/plugins/focus/focus.ts:20](https://github.com/xdan/jodit/blob/main/src/plugins/focus/focus.ts#L20)

***

### cursorAfterAutofocus

**cursorAfterAutofocus**: `"end"` \| `"start"`

Defined in: [src/plugins/focus/focus.ts:21](https://github.com/xdan/jodit/blob/main/src/plugins/focus/focus.ts#L21)

***

### saveSelectionOnBlur

**saveSelectionOnBlur**: `boolean`

Defined in: [src/plugins/focus/focus.ts:22](https://github.com/xdan/jodit/blob/main/src/plugins/focus/focus.ts#L22)

***

### defaultFontSizePoints

**defaultFontSizePoints**: `"px"` \| `"pt"`

Defined in: [src/plugins/font/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/font/config.ts#L23)

***

### fullsize

**fullsize**: `boolean`

Defined in: [src/plugins/fullsize/config.ts:39](https://github.com/xdan/jodit/blob/main/src/plugins/fullsize/config.ts#L39)

Open WYSIWYG in full screen

```javascript
var editor = Jodit.make({
    fullsize: true // fullsize editor
});
```

```javascript
var editor = Jodit.make();
editor.e.fire('toggleFullSize');
editor.e.fire('toggleFullSize', true); // fullsize
editor.e.fire('toggleFullSize', false); // usual mode
```

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`fullsize`](./interfaces/types.IViewOptions.html#fullsize)

***

### globalFullSize

**globalFullSize**: `boolean`

Defined in: [src/plugins/fullsize/config.ts:44](https://github.com/xdan/jodit/blob/main/src/plugins/fullsize/config.ts#L44)

True, after `fullsize` -  all editors elements above jodit will get `jodit_fullsize-box_true` class (z-index: 100000 !important;)

#### Implementation of

[`IViewOptions`](./interfaces/types.IViewOptions.html).[`globalFullSize`](./interfaces/types.IViewOptions.html#globalfullsize)

***

### iframeDefaultSrc

**iframeDefaultSrc**: `string`

Defined in: [src/plugins/iframe/config.ts:25](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L25)

You can redefine default page

```javascript
Jodit.make('#editor', {
   iframe: true,
   iframeDefaultSrc: 'https://xdsoft.net/jodit/docs/',
});
```

***

### iframeBaseUrl

**iframeBaseUrl**: `string`

Defined in: [src/plugins/iframe/config.ts:37](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L37)

Base URL where the root directory for [Config.iframe](#iframe) mode

```javascript
Jodit.make('#editor', {
   iframe: true,
   iframeBaseUrl: 'https://xdsoft.net/jodit/docs/',
});
```

***

### iframeTitle

**iframeTitle**: `string`

Defined in: [src/plugins/iframe/config.ts:42](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L42)

Iframe title's content

***

### iframeDoctype

**iframeDoctype**: `string`

Defined in: [src/plugins/iframe/config.ts:47](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L47)

Iframe's DOCTYPE

***

### iframeStyle

**iframeStyle**: `string`

Defined in: [src/plugins/iframe/config.ts:59](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L59)

Custom style to be used inside the iframe to display content.

```javascript
Jodit.make('#editor', {
   iframe: true,
   iframeStyle: 'html{margin: 0px;}',
})
```

***

### iframeCSSLinks

**iframeCSSLinks**: `string`[]

Defined in: [src/plugins/iframe/config.ts:71](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L71)

Custom stylesheet files to be used inside the iframe to display content.

```javascript
Jodit.make('#editor', {
   iframe: true,
   iframeCSSLinks: ['styles/default.css'],
})
```

***

### iframeSandbox

**iframeSandbox**: `string` \| `null`

Defined in: [src/plugins/iframe/config.ts:84](https://github.com/xdan/jodit/blob/main/src/plugins/iframe/config.ts#L84)

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.

***

### imageProcessor

**imageProcessor**: `object`

Defined in: [src/plugins/image-processor/config.ts:22](https://github.com/xdan/jodit/blob/main/src/plugins/image-processor/config.ts#L22)

Options for processing images inserted into the editor (e.g. converting base64 data URIs to Blob URLs).

#### replaceDataURIToBlobIdInView

**replaceDataURIToBlobIdInView**: `boolean`

***

### image

**image**: [`ImagePropertiesOptions`](./interfaces/plugins_image_properties.ImagePropertiesOptions.html)

Defined in: [src/plugins/image-properties/config.ts:20](https://github.com/xdan/jodit/blob/main/src/plugins/image-properties/config.ts#L20)

Configuration for the image properties dialog (opened on double-click).
Controls which editing tabs are available: src, alt, title, link, size, margins, classes, styles, etc.

***

### indentMargin

**indentMargin**: `number`

Defined in: [src/plugins/indent/config.ts:69](https://github.com/xdan/jodit/blob/main/src/plugins/indent/config.ts#L69)

The number of pixels to use for indenting the current line.

***

### popup

**popup**: [`IDictionary`](./modules/types.html#idictionary)\<([`IControlType`](./interfaces/types.IControlType.html) \| `string`)[] \| ((`editor`, `target`, `close`) => ([`IControlType`](./interfaces/types.IControlType.html) \| `string`)[] \| [`HTMLElement`](https://developer.mozilla.org/docs/Web/API/HTMLElement) \| `string`)\>

Defined in: [src/plugins/inline-popup/config/config.ts:36](https://github.com/xdan/jodit/blob/main/src/plugins/inline-popup/config/config.ts#L36)

Element-specific popup toolbars. Keys are tag names (e.g. `img`, `a`, `cells`)
and values are button lists or factory functions that return them.

***

### toolbarInlineDisabledButtons

**toolbarInlineDisabledButtons**: `string`[]

Defined in: [src/plugins/inline-popup/config/config.ts:48](https://github.com/xdan/jodit/blob/main/src/plugins/inline-popup/config/config.ts#L48)

List of button names to exclude from the inline toolbar

***

### toolbarInline

**toolbarInline**: `boolean`

Defined in: [src/plugins/inline-popup/config/config.ts:53](https://github.com/xdan/jodit/blob/main/src/plugins/inline-popup/config/config.ts#L53)

Show an inline toolbar when the user clicks inside the editor area (e.g. near images, links)

***

### toolbarInlineForSelection

**toolbarInlineForSelection**: `boolean`

Defined in: [src/plugins/inline-popup/config/config.ts:58](https://github.com/xdan/jodit/blob/main/src/plugins/inline-popup/config/config.ts#L58)

Show an inline toolbar when the user selects text

***

### toolbarInlineDisableFor

**toolbarInlineDisableFor**: `string` \| `string`[]

Defined in: [src/plugins/inline-popup/config/config.ts:63](https://github.com/xdan/jodit/blob/main/src/plugins/inline-popup/config/config.ts#L63)

CSS selector or array of selectors for elements that should not trigger the inline toolbar

***

### limitWords

**limitWords**: `number` \| `false`

Defined in: [src/plugins/limit/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/limit/config.ts#L18)

Maximum number of words allowed in the editor. Set to `false` to disable the limit.

***

### limitChars

**limitChars**: `number` \| `false`

Defined in: [src/plugins/limit/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/limit/config.ts#L23)

Maximum number of characters allowed in the editor. Set to `false` to disable the limit.

***

### limitHTML

**limitHTML**: `false`

Defined in: [src/plugins/limit/config.ts:28](https://github.com/xdan/jodit/blob/main/src/plugins/limit/config.ts#L28)

Maximum number of characters counted from the raw HTML source. Set to `false` to disable the limit.

***

### defaultLineHeight

**defaultLineHeight**: `number` \| `null`

Defined in: [src/plugins/line-height/config.ts:29](https://github.com/xdan/jodit/blob/main/src/plugins/line-height/config.ts#L29)

Default line spacing for the entire editor

```js
Jodit.make('#editor', {
  defaultLineHeight: 1.2
})
```

***

### link

**link**: `object`

Defined in: [src/plugins/link/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/link/config.ts#L23)

#### formTemplate

**formTemplate**: (`editor`) => `string` \| [`HTMLElement`](https://developer.mozilla.org/docs/Web/API/HTMLElement) \| [`IUIForm`](./interfaces/types.IUIForm.html)

Template for the link dialog form

##### Parameters

| Parameter | Type |
| ------ | ------ |
| `editor` | [`IJodit`](./interfaces/types.IJodit.html) |

##### Returns

`string` \| [`HTMLElement`](https://developer.mozilla.org/docs/Web/API/HTMLElement) \| [`IUIForm`](./interfaces/types.IUIForm.html)

#### formClassName?

`optional` **formClassName?**: `string`

#### followOnDblClick

**followOnDblClick**: `boolean`

Follow link address after dblclick

#### processVideoLink

**processVideoLink**: `boolean`

Replace inserted youtube/vimeo link to `iframe`

#### processPastedLink

**processPastedLink**: `boolean`

Wrap inserted link

#### deriveUrlFromText

**deriveUrlFromText**: `boolean`

When opening the link dialog for a new link with an empty URL field,
pre-fill it from the selected text if that text looks like a URL or
an email address (`example.com` → `https://example.com`,
`user@site.com` → `mailto:user@site.com`). Plain text that is not a
URL/email is left untouched. Default: false.

#### noFollowCheckbox

**noFollowCheckbox**: `boolean`

Show `no follow` checkbox in link dialog.

#### openInNewTabCheckbox

**openInNewTabCheckbox**: `boolean`

Show `Open in new tab` checkbox in link dialog.

#### openInNewTabCheckboxDefaultChecked

**openInNewTabCheckboxDefaultChecked**: `boolean`

Default value for the `Open in new tab` checkbox when inserting a new link.

#### ariaLabelInput

**ariaLabelInput**: `boolean`

Show an `aria-label` text input in the link dialog so an
accessible name can be set on the `<a>` (useful when several
links share the same visible text, e.g. "here"). Default: false.

#### modeClassName

**modeClassName**: `"input"` \| `"select"`

Use an input text to ask the classname or a select or not ask

#### selectMultipleClassName

**selectMultipleClassName**: `boolean`

Allow multiple choises (to use with modeClassName="select")

#### selectSizeClassName?

`optional` **selectSizeClassName?**: `number`

The size of the select (to use with modeClassName="select")

#### selectOptionsClassName

**selectOptionsClassName**: [`IUIOption`](./interfaces/types.IUIOption.html)[]

The list of the option for the select (to use with modeClassName="select")

#### hotkeys

**hotkeys**: `string`[]

#### preventReadOnlyNavigation

**preventReadOnlyNavigation**: `boolean`

Prevent navigation to the link if it is readonly. Default: true

***

### mediaInFakeBlock

**mediaInFakeBlock**: `boolean`

Defined in: [src/plugins/media/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/media/config.ts#L18)

Decorate media elements

***

### mediaFakeTag

**mediaFakeTag**: `string`

Defined in: [src/plugins/media/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/media/config.ts#L23)

Decorate media element with tag

***

### mediaBlocks

**mediaBlocks**: `string`[]

Defined in: [src/plugins/media/config.ts:28](https://github.com/xdan/jodit/blob/main/src/plugins/media/config.ts#L28)

Media tags

***

### mobileTapTimeout

**mobileTapTimeout**: `number`

Defined in: [src/plugins/mobile/config.ts:29](https://github.com/xdan/jodit/blob/main/src/plugins/mobile/config.ts#L29)

Mobile timeout for CLICK emulation

***

### toolbarAdaptive

**toolbarAdaptive**: `boolean`

Defined in: [src/plugins/mobile/config.ts:34](https://github.com/xdan/jodit/blob/main/src/plugins/mobile/config.ts#L34)

After resizing, the set of buttons will change to accommodate different sizes.

***

### buttonsMD

**buttonsMD**: [`ButtonsOption`](./modules/types.html#buttonsoption)

Defined in: [src/plugins/mobile/config.ts:45](https://github.com/xdan/jodit/blob/main/src/plugins/mobile/config.ts#L45)

The list of buttons that appear in the editor's toolbar for medium-sized spaces (≥ options.sizeMD).

The set is constrained to `buttons`: resizing may only drop buttons on
smaller widths, never surface a button that is not in `buttons`. So if
you customise only `buttons` and leave this at its default, a narrow
editor still shows just your `buttons`. Set this explicitly (as a subset
of `buttons`) to get a different medium-width set.

***

### buttonsSM

**buttonsSM**: [`ButtonsOption`](./modules/types.html#buttonsoption)

Defined in: [src/plugins/mobile/config.ts:52](https://github.com/xdan/jodit/blob/main/src/plugins/mobile/config.ts#L52)

The list of buttons that appear in the editor's toolbar for small-sized spaces (≥ options.sizeSM).

Constrained to `buttons` — see [buttonsMD](#buttonsmd).

***

### buttonsXS

**buttonsXS**: [`ButtonsOption`](./modules/types.html#buttonsoption)

Defined in: [src/plugins/mobile/config.ts:59](https://github.com/xdan/jodit/blob/main/src/plugins/mobile/config.ts#L59)

The list of buttons that appear in the editor's toolbar for extra-small spaces (less than options.sizeSM).

Constrained to `buttons` — see [buttonsMD](#buttonsmd).

***

### askBeforePasteFromWord

**askBeforePasteFromWord**: `boolean`

Defined in: [src/plugins/paste-from-word/config.ts:24](https://github.com/xdan/jodit/blob/main/src/plugins/paste-from-word/config.ts#L24)

Show the paste dialog if the html is similar to what MSWord gives when copying.

***

### processPasteFromWord

**processPasteFromWord**: `boolean`

Defined in: [src/plugins/paste-from-word/config.ts:29](https://github.com/xdan/jodit/blob/main/src/plugins/paste-from-word/config.ts#L29)

Handle pasting of HTML - similar to a fragment copied from MSWord

***

### defaultActionOnPasteFromWord

**defaultActionOnPasteFromWord**: [`InsertMode`](./modules/types.html#insertmode) \| `null`

Defined in: [src/plugins/paste-from-word/config.ts:40](https://github.com/xdan/jodit/blob/main/src/plugins/paste-from-word/config.ts#L40)

Default insert method from word, if not define, it will use defaultActionOnPaste instead

```js
Jodit.make('#editor', {
  defaultActionOnPasteFromWord: 'insert_clear_html'
})
```

***

### pasteFromWordActionList

**pasteFromWordActionList**: [`IUIOption`](./interfaces/types.IUIOption.html)[]

Defined in: [src/plugins/paste-from-word/config.ts:45](https://github.com/xdan/jodit/blob/main/src/plugins/paste-from-word/config.ts#L45)

Options when inserting data from Word

***

### askBeforePasteHTML

**askBeforePasteHTML**: `boolean`

Defined in: [src/plugins/paste/config.ts:35](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L35)

Ask before paste HTML in WYSIWYG mode

***

### memorizeChoiceWhenPasteFragment

**memorizeChoiceWhenPasteFragment**: `boolean`

Defined in: [src/plugins/paste/config.ts:41](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L41)

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.

***

### processPasteHTML

**processPasteHTML**: `boolean`

Defined in: [src/plugins/paste/config.ts:46](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L46)

Handle pasted text - similar to HTML

***

### nl2brInPlainText

**nl2brInPlainText**: `boolean`

Defined in: [src/plugins/paste/config.ts:51](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L51)

Inserts HTML line breaks before all newlines in a string

***

### pasteExcludeStripTags

**pasteExcludeStripTags**: [`HTMLTagNames`](./modules/types.html#htmltagnames)[]

Defined in: [src/plugins/paste/config.ts:56](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L56)

List of tags that will not be removed from the pasted HTML with INSERT_AS_TEXT mode

***

### pasteHTMLActionList

**pasteHTMLActionList**: [`IUIOption`](./interfaces/types.IUIOption.html)[]

Defined in: [src/plugins/paste/config.ts:61](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L61)

Options when inserting HTML string

***

### scrollToPastedContent

**scrollToPastedContent**: `boolean`

Defined in: [src/plugins/paste/config.ts:66](https://github.com/xdan/jodit/blob/main/src/plugins/paste/config.ts#L66)

Scroll the editor to the pasted fragment

***

### showPlaceholder

**showPlaceholder**: `boolean`

Defined in: [src/plugins/placeholder/config.ts:27](https://github.com/xdan/jodit/blob/main/src/plugins/placeholder/config.ts#L27)

Show placeholder

```javascript
const editor = Jodit.make('#editor', {
   showPlaceholder: false
});
```

***

### useInputsPlaceholder

**useInputsPlaceholder**: `boolean`

Defined in: [src/plugins/placeholder/config.ts:39](https://github.com/xdan/jodit/blob/main/src/plugins/placeholder/config.ts#L39)

Use a placeholder from original input field, if it was set

```javascript
//<textarea id="editor" placeholder="start typing text ..." cols="30" rows="10"></textarea>
const editor = Jodit.make('#editor', {
   useInputsPlaceholder: true
});
```

***

### placeholder

**placeholder**: `string`

Defined in: [src/plugins/placeholder/config.ts:50](https://github.com/xdan/jodit/blob/main/src/plugins/placeholder/config.ts#L50)

Default placeholder

```javascript
const editor = Jodit.make('#editor', {
   placeholder: 'start typing text ...'
});
```

***

### hidePoweredByJodit

**hidePoweredByJodit**: `boolean`

Defined in: [src/plugins/powered-by-jodit/powered-by-jodit.ts:21](https://github.com/xdan/jodit/blob/main/src/plugins/powered-by-jodit/powered-by-jodit.ts#L21)

Hide the link to the Jodit site at the bottom of the editor

***

### tableAllowCellResize

**tableAllowCellResize**: `boolean`

Defined in: [src/plugins/resize-cells/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/resize-cells/config.ts#L18)

Allow users to resize table cells by dragging the cell borders

***

### allowResizeX

**allowResizeX**: `boolean`

Defined in: [src/plugins/resize-handler/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/resize-handler/config.ts#L18)

Allow the user to resize the editor horizontally by dragging the resize handle

***

### allowResizeY

**allowResizeY**: `boolean`

Defined in: [src/plugins/resize-handler/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/resize-handler/config.ts#L23)

Allow the user to resize the editor vertically by dragging the resize handle

***

### allowResizeTags

**allowResizeTags**: [`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)\<[`HTMLTagNames`](./modules/types.html#htmltagnames)\>

Defined in: [src/plugins/resizer/config.ts:19](https://github.com/xdan/jodit/blob/main/src/plugins/resizer/config.ts#L19)

Set of HTML tag names whose elements can be resized by the user via drag handles (e.g. images, iframes, tables)

***

### resizer

**resizer**: `object`

Defined in: [src/plugins/resizer/config.ts:21](https://github.com/xdan/jodit/blob/main/src/plugins/resizer/config.ts#L21)

#### showSize

**showSize**: `boolean`

Show size

#### hideSizeTimeout

**hideSizeTimeout**: `number`

#### useAspectRatio

**useAspectRatio**: `boolean` \| [`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)\<[`HTMLTagNames`](./modules/types.html#htmltagnames)\>

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
  }
});
```

#### forImageChangeAttributes

**forImageChangeAttributes**: `boolean`

When resizing images, change not the styles but the width and height attributes

#### min\_width

**min\_width**: `number`

The minimum width for the editable element

#### min\_height

**min\_height**: `number`

The minimum height for the item being edited

***

### useSearch

**useSearch**: `boolean`

Defined in: [src/plugins/search/config.ts:26](https://github.com/xdan/jodit/blob/main/src/plugins/search/config.ts#L26)

Enable custom search plugin
![search](https://user-images.githubusercontent.com/794318/34545433-cd0a9220-f10e-11e7-8d26-7e22f66e266d.gif)

***

### search

**search**: `object`

Defined in: [src/plugins/search/config.ts:28](https://github.com/xdan/jodit/blob/main/src/plugins/search/config.ts#L28)

#### lazyIdleTimeout

**lazyIdleTimeout**: `number`

#### useCustomHighlightAPI

**useCustomHighlightAPI**: `boolean`

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)

#### fuzzySearch?

`optional` **fuzzySearch?**: [`FuzzySearch`](./interfaces/types.FuzzySearch.html)

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](./interfaces/types.FuzzySearch.html) interface.

```ts
Jodit.make('#editor', {
  search: {
    fuzzySearch: (needle, haystack, offset) => {
      return [haystack.toLowerCase().indexOf(needle.toLowerCase(), offset), needle.length];
    }
  }
})
```

***

### tableAllowCellSelection

**tableAllowCellSelection**: `boolean`

Defined in: [src/plugins/select-cells/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/select-cells/config.ts#L18)

Allow users to select multiple table cells by clicking and dragging

***

### select

**select**: `object`

Defined in: [src/plugins/select/config.ts:15](https://github.com/xdan/jodit/blob/main/src/plugins/select/config.ts#L15)

#### normalizeSelectionBeforeCutAndCopy

**normalizeSelectionBeforeCutAndCopy**: `boolean`

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>`

#### normalizeTripleClick

**normalizeTripleClick**: `boolean`

Normalize selection after triple click

`<ul><li>|test</li><li>|pop</li></ul>` will be `<ul><li>|test|</li><li>pop</li</ul>|`

***

### saveHeightInStorage

**saveHeightInStorage**: `boolean`

Defined in: [src/plugins/size/config.ts:15](https://github.com/xdan/jodit/blob/main/src/plugins/size/config.ts#L15)

***

### minWidth

**minWidth**: `string` \| `number`

Defined in: [src/plugins/size/config.ts:17](https://github.com/xdan/jodit/blob/main/src/plugins/size/config.ts#L17)

***

### minHeight

**minHeight**: `string` \| `number`

Defined in: [src/plugins/size/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/size/config.ts#L18)

***

### maxWidth

**maxWidth**: `string` \| `number`

Defined in: [src/plugins/size/config.ts:19](https://github.com/xdan/jodit/blob/main/src/plugins/size/config.ts#L19)

***

### maxHeight

**maxHeight**: `string` \| `number`

Defined in: [src/plugins/size/config.ts:20](https://github.com/xdan/jodit/blob/main/src/plugins/size/config.ts#L20)

***

### sourceEditor

**sourceEditor**: `"area"` \| `"ace"` \| ((`jodit`) => [`ISourceEditor`](./interfaces/types.ISourceEditor.html))

Defined in: [src/plugins/source/config.ts:24](https://github.com/xdan/jodit/blob/main/src/plugins/source/config.ts#L24)

Which source-code editor to use: `'area'` for a plain textarea, `'ace'` to load the Ace editor,
or a factory function that returns a custom source editor instance.

***

### sourceEditorNativeOptions

**sourceEditorNativeOptions**: `object`

Defined in: [src/plugins/source/config.ts:46](https://github.com/xdan/jodit/blob/main/src/plugins/source/config.ts#L46)

Options for [ace](https://ace.c9.io/#config) editor.

Besides the named keys below, any other native ACE option is
forwarded to `editor.setOptions()` as is, so e.g. `fontSize`,
`tabSize` or `useSoftTabs` work too.

```js
Jodit.make('#editor', {
  sourceEditorNativeOptions: {
    showGutter: true,
    theme: 'ace/theme/idle_fingers',
    mode: 'ace/mode/html',
    wrap: true,
    highlightActiveLine: true,
    fontSize: '16px'
  }
})
```

#### Index Signature

\[`option`: `string`\]: `string` \| `number` \| `boolean` \| `undefined`

#### showGutter

**showGutter**: `boolean`

#### theme

**theme**: `string`

#### mode

**mode**: `string`

#### wrap

**wrap**: `string` \| `number` \| `boolean`

#### highlightActiveLine

**highlightActiveLine**: `boolean`

***

### beautifyHTML

**beautifyHTML**: `boolean`

Defined in: [src/plugins/source/config.ts:58](https://github.com/xdan/jodit/blob/main/src/plugins/source/config.ts#L58)

Beautify HTML then it possible

***

### beautifyHTMLCDNUrlsJS

**beautifyHTMLCDNUrlsJS**: `string`[]

Defined in: [src/plugins/source/config.ts:63](https://github.com/xdan/jodit/blob/main/src/plugins/source/config.ts#L63)

CDN URLs for HTML Beautifier

***

### sourceEditorCDNUrlsJS

**sourceEditorCDNUrlsJS**: `string`[]

Defined in: [src/plugins/source/config.ts:68](https://github.com/xdan/jodit/blob/main/src/plugins/source/config.ts#L68)

CDN URLs for ACE editor

***

### speechRecognize

**speechRecognize**: `object`

Defined in: [src/plugins/speech-recognize/config.ts:26](https://github.com/xdan/jodit/blob/main/src/plugins/speech-recognize/config.ts#L26)

#### api

`readonly` **api**: [`ISpeechRecognizeConstructor`](./interfaces/plugins_speech_recognize.ISpeechRecognizeConstructor.html) \| `null`

#### lang?

`readonly` `optional` **lang?**: `string`

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

#### continuous

`readonly` **continuous**: `boolean`

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

#### interimResults

`readonly` **interimResults**: `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

#### sound

`readonly` **sound**: `boolean`

On recognition error - make an error sound

#### commands

`readonly` **commands**: [`IDictionary`](./modules/types.html#idictionary)\<`string`\>

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>',
    }
  }
});
```

***

### spellcheck

**spellcheck**: `boolean`

Defined in: [src/plugins/spellcheck/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/spellcheck/config.ts#L23)

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

***

### showCharsCounter

**showCharsCounter**: `boolean`

Defined in: [src/plugins/stat/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/stat/config.ts#L18)

Display a character counter in the statusbar

***

### countHTMLChars

**countHTMLChars**: `boolean`

Defined in: [src/plugins/stat/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/stat/config.ts#L23)

When true, count characters from the raw HTML source instead of visible text only

***

### countTextSpaces

**countTextSpaces**: `boolean`

Defined in: [src/plugins/stat/config.ts:28](https://github.com/xdan/jodit/blob/main/src/plugins/stat/config.ts#L28)

When true, include whitespace characters in the character count

***

### showWordsCounter

**showWordsCounter**: `boolean`

Defined in: [src/plugins/stat/config.ts:33](https://github.com/xdan/jodit/blob/main/src/plugins/stat/config.ts#L33)

Display a word counter in the statusbar

***

### toolbarSticky

**toolbarSticky**: `boolean`

Defined in: [src/plugins/sticky/config.ts:24](https://github.com/xdan/jodit/blob/main/src/plugins/sticky/config.ts#L24)

Keep the toolbar visible at the top of the viewport when scrolling past the editor

```javascript
var editor = Jodit.make('#someid', {
 toolbarSticky: false
})
```

***

### toolbarDisableStickyForMobile

**toolbarDisableStickyForMobile**: `boolean`

Defined in: [src/plugins/sticky/config.ts:29](https://github.com/xdan/jodit/blob/main/src/plugins/sticky/config.ts#L29)

Disable sticky toolbar on mobile devices to save screen space

***

### toolbarStickyOffset

**toolbarStickyOffset**: `number`

Defined in: [src/plugins/sticky/config.ts:41](https://github.com/xdan/jodit/blob/main/src/plugins/sticky/config.ts#L41)

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)

```javascript
var editor = Jodit.make('#someid', {
 toolbarStickyOffset: 100
})
```

***

### specialCharacters

**specialCharacters**: `string`[]

Defined in: [src/plugins/symbols/config.ts:22](https://github.com/xdan/jodit/blob/main/src/plugins/symbols/config.ts#L22)

Array of HTML entities or characters displayed in the special-characters picker

***

### usePopupForSpecialCharacters

**usePopupForSpecialCharacters**: `boolean`

Defined in: [src/plugins/symbols/config.ts:27](https://github.com/xdan/jodit/blob/main/src/plugins/symbols/config.ts#L27)

When true, show the special-characters picker as a toolbar popup instead of a modal dialog

***

### tab

**tab**: `object`

Defined in: [src/plugins/tab/config.ts:15](https://github.com/xdan/jodit/blob/main/src/plugins/tab/config.ts#L15)

#### tabInsideLiInsertNewList

**tabInsideLiInsertNewList**: `boolean`

Pressing Tab inside LI will add an internal list

***

### table

**table**: `object`

Defined in: [src/plugins/table/config.ts:33](https://github.com/xdan/jodit/blob/main/src/plugins/table/config.ts#L33)

Options for table insertion and behavior.

#### splitBlockOnInsertTable

**splitBlockOnInsertTable**: `boolean`

#### selectionCellStyle

**selectionCellStyle**: `string`

#### useExtraClassesOptions

**useExtraClassesOptions**: `boolean`

***

### video

**video**: `object`

Defined in: [src/plugins/video/config.ts:23](https://github.com/xdan/jodit/blob/main/src/plugins/video/config.ts#L23)

#### parseUrlToVideoEmbed?

`optional` **parseUrlToVideoEmbed?**: (`url`, `__namedParameters?`) => `string`

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)
    }
});
```

##### Parameters

| Parameter | Type |
| ------ | ------ |
| `url` | `string` |
| `__namedParameters?` | \{ `width?`: `number`; `height?`: `number`; \} |
| `__namedParameters.width?` | `number` |
| `__namedParameters.height?` | `number` |

##### Returns

`string`

#### defaultWidth?

`optional` **defaultWidth?**: `number`

Default width for video iframe. Default: 400

#### defaultHeight?

`optional` **defaultHeight?**: `number`

Default height for video iframe. Default: 345

***

### wrapNodes

**wrapNodes**: `object`

Defined in: [src/plugins/wrap-nodes/config.ts:16](https://github.com/xdan/jodit/blob/main/src/plugins/wrap-nodes/config.ts#L16)

#### exclude

**exclude**: [`Set`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)\<[`HTMLTagNames`](./modules/types.html#htmltagnames)\>

List of tags that should not be wrapped
Default: `new Set(['hr', 'style', 'br'])`

#### emptyBlockAfterInit

**emptyBlockAfterInit**: `boolean`

If the editor is empty, then insert an empty paragraph into it
```javascript
Jodit.make('#editor', {
  wrapNodes: {
    emptyBlockAfterInit: true
  }
});
```
Default: `true`

***

### showXPathInStatusbar

**showXPathInStatusbar**: `boolean`

Defined in: [src/plugins/xpath/config.ts:18](https://github.com/xdan/jodit/blob/main/src/plugins/xpath/config.ts#L18)

Show the element breadcrumb path (e.g. `body > p > strong`) in the statusbar

#### Get Signature

**get** `static` **defaultOptions**(): `Config`

Defined in: [src/config.ts:1194](https://github.com/xdan/jodit/blob/main/src/config.ts#L1194)

##### Returns

`Config`