jodit 4.18.4 → 4.18.7

package/esm/langs/zh_tw.d.ts

@@ -217,5 +217,8 @@ declare const _exports: {
     Loop: string;
     Muted: string;
     Controls: string;
+    'Start at...': string;
+    'Start numbering at': string;
+    'Number for the first item': string;
 };
 export = _exports;

package/esm/langs/zh_tw.js

@@ -229,5 +229,8 @@ export default {
 	Autoplay: '自動播放',
 	Loop: '循環播放',
 	Muted: '靜音',
-	Controls: '播放控制項'
+	Controls: '播放控制項',
+	'Start at...': '起始於...',
+	'Start numbering at': '編號起始值',
+	'Number for the first item': '第一項的編號'
 };

package/esm/modules/dialog/dialog.d.ts

@@ -48,6 +48,13 @@ export declare class Dialog extends ViewWithToolbar implements IDialog {
      */
     private minSize;
     private __onResizerMouseDown;
+    /**
+     * The width `box` takes with its content on one line. The header and
+     * footer are flex rows as wide as the dialog, so the footer's
+     * `scrollWidth` was the dialog's width and kept it from getting any
+     * narrower
+     */
+    private __contentWidth;
     private __addGlobalResizeListeners;
     private __removeGlobalResizeListeners;
     OPTIONS: IDialogOptions;

package/esm/modules/dialog/dialog.js

@@ -179,7 +179,12 @@ let Dialog = Dialog_1 = class Dialog extends ViewWithToolbar {
         }
     }
     __onResizerMouseDown(e) {
-        var _a, _b, _c;
+        var _a, _b;
+        // As for the header: otherwise Safari selects the dialog's text as
+        // the pointer moves
+        if (e.cancelable) {
+            e.preventDefault();
+        }
         this.resizable = true;
         this.startX = e.clientX;
         this.startY = e.clientY;
@@ -195,11 +200,11 @@ let Dialog = Dialog_1 = class Dialog extends ViewWithToolbar {
             : 0;
         this.minSize.w = isNumber(this.o.minWidth)
             ? this.o.minWidth
-            : Math.max(100, (_a = footer === null || footer === void 0 ? void 0 : footer.scrollWidth) !== null && _a !== void 0 ? _a : 0);
+            : Math.max(100, header ? this.__contentWidth(header) : 0, footer ? this.__contentWidth(footer) : 0);
         this.minSize.h = isNumber(this.o.minHeight)
             ? this.o.minHeight
-            : ((_b = header === null || header === void 0 ? void 0 : header.offsetHeight) !== null && _b !== void 0 ? _b : 0) +
-                ((_c = footer === null || footer === void 0 ? void 0 : footer.offsetHeight) !== null && _c !== void 0 ? _c : 0) +
+            : ((_a = header === null || header === void 0 ? void 0 : header.offsetHeight) !== null && _a !== void 0 ? _a : 0) +
+                ((_b = footer === null || footer === void 0 ? void 0 : footer.offsetHeight) !== null && _b !== void 0 ? _b : 0) +
                 contentMinHeight +
                 this.resizer.offsetHeight;
         this.lockSelect();
@@ -211,6 +216,19 @@ let Dialog = Dialog_1 = class Dialog extends ViewWithToolbar {
             this.e.fire(this, 'startResize');
         }
     }
+    /**
+     * The width `box` takes with its content on one line. The header and
+     * footer are flex rows as wide as the dialog, so the footer's
+     * `scrollWidth` was the dialog's width and kept it from getting any
+     * narrower
+     */
+    __contentWidth(box) {
+        const { width } = box.style;
+        box.style.width = 'max-content';
+        const contentWidth = box.offsetWidth;
+        box.style.width = width;
+        return contentWidth;
+    }
     __addGlobalResizeListeners() {
         const self = this;
         self.e
@@ -220,8 +238,8 @@ let Dialog = Dialog_1 = class Dialog extends ViewWithToolbar {
     __removeGlobalResizeListeners() {
         const self = this;
         self.e
-            .off(self.ow, 'mousemove pointermove', self.__onMouseMove)
-            .off(self.ow, 'mouseup pointerup', self.__onMouseUp);
+            .off(self.ow, 'pointermove touchmove', self.__onMouseMove)
+            .off(self.ow, 'pointerup touchend', self.__onMouseUp);
     }
     /**
      * Specifies the size of the window

package/esm/modules/file-browser/ui/files/files.js

@@ -3,9 +3,24 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { component } from "../../../../core/decorators/index.js";
 import { UIGroup } from "../../../../core/ui/index.js";
-export class FileBrowserFiles extends UIGroup {
+let FileBrowserFiles = class FileBrowserFiles extends UIGroup {
     className() {
         return 'FileBrowserFiles';
     }
-}
+};
+FileBrowserFiles = __decorate([
+    component
+], FileBrowserFiles);
+export { FileBrowserFiles };

package/esm/modules/file-browser/ui/tree/tree.js

@@ -3,9 +3,24 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { component } from "../../../../core/decorators/index.js";
 import { UIGroup } from "../../../../core/ui/index.js";
-export class FileBrowserTree extends UIGroup {
+let FileBrowserTree = class FileBrowserTree extends UIGroup {
     className() {
         return 'FileBrowserTree';
     }
-}
+};
+FileBrowserTree = __decorate([
+    component
+], FileBrowserTree);
+export { FileBrowserTree };

package/esm/modules/table/table.d.ts

@@ -15,6 +15,12 @@ export declare class Table extends ViewComponent<IJodit> {
     className(): string;
     private selected;
     private static __selectedByTable;
+    /**
+     * Rewrite the `<style>` that marks the selected cells once for all the
+     * cells (un)selected in one go: a drag over a block of cells unmarks and
+     * marks every one of them on each move. `@debounce()` was never applied,
+     * as a Table never reaches `ready`
+     */
     private __recalculateStyles;
     addSelection(td: HTMLTableCellElement): void;
     removeSelection(td: HTMLTableCellElement): void;

package/esm/modules/table/table.js

@@ -3,19 +3,8 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-        r = Reflect.decorate(decorators, target, key, desc);
-    else
-        for (var i = decorators.length - 1; i >= 0; i--)
-            if (d = decorators[i])
-                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 import { ViewComponent } from "../../core/component/index.js";
 import * as consts from "../../core/constants.js";
-import { debounce } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/index.js";
 import { getContainer } from "../../core/global.js";
 import { attr, css, cssPath, isNumber, toArray, trim } from "../../core/helpers/index.js";
@@ -25,23 +14,29 @@ export class Table extends ViewComponent {
     constructor() {
         super(...arguments);
         this.selected = new Set();
+        /**
+         * Rewrite the `<style>` that marks the selected cells once for all the
+         * cells (un)selected in one go: a drag over a block of cells unmarks and
+         * marks every one of them on each move. `@debounce()` was never applied,
+         * as a Table never reaches `ready`
+         */
+        this.__recalculateStyles = this.async.microDebounce(() => {
+            const style = getContainer(this.j, Table, 'style', true);
+            const selectors = [];
+            this.selected.forEach(td => {
+                const selector = cssPath(td);
+                selector && selectors.push(selector);
+            });
+            style.innerHTML = selectors.length
+                ? selectors.join(',') +
+                    `{${this.jodit.options.table.selectionCellStyle}}`
+                : '';
+        });
     }
     /** @override */
     className() {
         return 'Table';
     }
-    __recalculateStyles() {
-        const style = getContainer(this.j, Table, 'style', true);
-        const selectors = [];
-        this.selected.forEach(td => {
-            const selector = cssPath(td);
-            selector && selectors.push(selector);
-        });
-        style.innerHTML = selectors.length
-            ? selectors.join(',') +
-                `{${this.jodit.options.table.selectionCellStyle}}`
-            : '';
-    }
     addSelection(td) {
         this.selected.add(td);
         this.__recalculateStyles();
@@ -701,7 +696,4 @@ export class Table extends ViewComponent {
     }
 }
 Table.__selectedByTable = new WeakMap();
-__decorate([
-    debounce()
-], Table.prototype, "__recalculateStyles", null);
 const instance = (j) => j.getInstance('Table', j.o);

package/esm/plugins/backspace/cases/check-join-neighbors.js

@@ -3,7 +3,7 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { LIST_TAGS } from "../../../core/constants.js";
+import { INSEPARABLE_TAGS, LIST_TAGS } from "../../../core/constants.js";
 import { Dom } from "../../../core/dom/dom.js";
 import { getMoveFilter } from "../helpers.js";
 /**
@@ -21,6 +21,10 @@ export function checkJoinNeighbors(jodit, fakeNode, backspace) {
     }
     if (Dom.isElement(mainClosestBox) &&
         Dom.isContentEditable(mainClosestBox, jodit.editor)) {
+        // A table cell is never joined with its neighbour
+        if (Dom.up(fakeNode, Dom.isCell, mainClosestBox, true)) {
+            return false;
+        }
         const sibling = Dom.findNotEmptySibling(mainClosestBox, backspace);
         // A line break before the cursor is a single unit: remove it instead of
         // merging the current element into the (void) `<br>`, which used to move
@@ -30,15 +34,60 @@ export function checkJoinNeighbors(jodit, fakeNode, backspace) {
             jodit.s.setCursorBefore(fakeNode);
             return true;
         }
+        // Backspace leaves a block after a table alone, as Word does, rather
+        // than moving its text into the last cell
+        if (backspace && Dom.isTag(sibling, 'table')) {
+            jodit.s.setCursorBefore(fakeNode);
+            return true;
+        }
+        const box = findCaretBox(fakeNode, mainClosestBox);
         if (sibling &&
-            (checkMoveListContent(jodit, mainClosestBox, sibling, backspace) ||
-                moveContentAndRemoveEmpty(jodit, mainClosestBox, resolveTableSibling(sibling, backspace), backspace))) {
+            (checkPullNextLine(jodit, fakeNode, box, sibling, backspace) ||
+                checkMoveListContent(jodit, box, sibling, backspace) ||
+                moveContentAndRemoveEmpty(jodit, box, findEdgeBlock(resolveTableSibling(sibling, backspace), backspace, jodit.editor), backspace))) {
             jodit.s.setCursorBefore(fakeNode);
             return true;
         }
     }
     return false;
 }
+/**
+ * The block holding the caret inside the box that has the sibling, so
+ * `<p>one</p><div><p>|two</p></div>` joins the two paragraphs instead of
+ * moving the whole `<div>` into the first one. For a list item that is its
+ * list, which the list cases handle.
+ */
+function findCaretBox(fakeNode, mainClosestBox) {
+    const block = Dom.up(fakeNode, Dom.isBlock, mainClosestBox);
+    if (!block) {
+        return mainClosestBox;
+    }
+    return Dom.isLeaf(block) && block.parentElement
+        ? block.parentElement
+        : block;
+}
+/**
+ * The innermost block on the sibling's edge facing the caret, so the
+ * content is joined to text: `<div><p>one</p></div><p>|two</p>` gives
+ * `<div><p>one|two</p></div>`
+ */
+function findEdgeBlock(sibling, backspace, root) {
+    let block = sibling;
+    while (block) {
+        const edge = backspace ? block.lastChild : block.firstChild;
+        const child = edge && Dom.isEmptyTextNode(edge)
+            ? Dom.findNotEmptySibling(edge, backspace)
+            : edge;
+        if (!Dom.isBlock(child) ||
+            Dom.isTag(child, INSEPARABLE_TAGS) ||
+            Dom.isTag(child, 'table') ||
+            !Dom.isContentEditable(child, root)) {
+            return block;
+        }
+        block = child;
+    }
+    return block;
+}
 /**
  * Content cannot be merged into the `<table>` element itself — it would land
  * between the table sections (after `</tbody>`), which is invalid HTML and
@@ -56,6 +105,44 @@ function resolveTableSibling(sibling, backspace) {
     });
     return cells.length ? cells[backspace ? cells.length - 1 : 0] : null;
 }
+/**
+ * Delete at the edge of a list pulls the next line up to the caret, as the
+ * browsers do, instead of moving the caret's line into the next block:
+ * `<ul><li>one|</li></ul><p>two</p>` gives `<ul><li>one|two</li></ul>`, and
+ * `<p>one|</p><ul><li>two</li></ul>` gives `<p>one|two</p>`
+ * @private
+ */
+function checkPullNextLine(jodit, fakeNode, box, sibling, backspace) {
+    if (backspace || !(Dom.isList(box) || Dom.isList(sibling))) {
+        return false;
+    }
+    const target = Dom.up(fakeNode, Dom.isBlock, box, true);
+    const source = Dom.isList(sibling) ? sibling.firstElementChild : sibling;
+    if (!target ||
+        !source ||
+        Dom.isTag(source, INSEPARABLE_TAGS) ||
+        Dom.isTag(source, 'table')) {
+        return false;
+    }
+    if (!Dom.isEmpty(source)) {
+        const line = [];
+        for (let node = source.firstChild; node && !Dom.isBlock(node); node = node.nextSibling) {
+            line.push(node);
+        }
+        if (!line.length) {
+            return false;
+        }
+        const filter = getMoveFilter(jodit);
+        line.forEach(node => filter(node) ? Dom.append(target, node) : Dom.safeRemove(node));
+    }
+    let remove = source;
+    while (remove && remove !== jodit.editor && Dom.isEmpty(remove)) {
+        const parent = remove.parentElement;
+        Dom.safeRemove(remove);
+        remove = parent;
+    }
+    return true;
+}
 function checkMoveListContent(jodit, mainClosestBox, sibling, backspace) {
     // Process UL/LI/OL cases
     const siblingIsList = Dom.isTag(sibling, LIST_TAGS);

package/esm/plugins/backspace/cases/check-remove-char.d.ts

@@ -19,6 +19,7 @@ import type { DeleteMode } from "../interface";
  * ```html
  * t|st
  * ```
+ * With `stopBeforeSpace`, nothing is removed when the next char is a space.
  * @private
  */
-export declare function checkRemoveChar(jodit: IJodit, fakeNode: Node, backspace: boolean, mode: DeleteMode): boolean;
+export declare function checkRemoveChar(jodit: IJodit, fakeNode: Node, backspace: boolean, mode: DeleteMode, stopBeforeSpace?: boolean): boolean;

package/esm/plugins/backspace/cases/check-remove-char.js

@@ -18,10 +18,11 @@ import { findMostNestedNeighbor } from "../helpers.js";
  * ```html
  * t|st
  * ```
+ * With `stopBeforeSpace`, nothing is removed when the next char is a space.
  * @private
  */
 // eslint-disable-next-line complexity
-export function checkRemoveChar(jodit, fakeNode, backspace, mode) {
+export function checkRemoveChar(jodit, fakeNode, backspace, mode, stopBeforeSpace = false) {
     var _a, _b;
     const step = backspace ? -1 : 1;
     const anotherSibling = Dom.sibling(fakeNode, !backspace);
@@ -40,6 +41,10 @@ export function checkRemoveChar(jodit, fakeNode, backspace, mode) {
             break;
         }
         if ((_a = sibling.nodeValue) === null || _a === void 0 ? void 0 : _a.length) {
+            if (stopBeforeSpace &&
+                isSpace(nextChar(sibling.nodeValue, backspace))) {
+                break;
+            }
             removed = tryRemoveChar(sibling, backspace, step, anotherSibling);
             if (!sibling.nodeValue.length &&
                 Dom.isInlineBlock(sibling.parentNode)) {
@@ -160,8 +165,24 @@ function replaceSpaceOnNBSP(anotherSibling, backspace, value) {
 }
 function checkRepeatRemoveCharAction(backspace, sibling, fakeNode, mode, removed, jodit) {
     call(backspace ? Dom.after : Dom.before, sibling, fakeNode);
-    if (mode === 'sentence' ||
-        (mode === 'word' && removed !== ' ' && removed !== NBSP_SPACE)) {
-        checkRemoveChar(jodit, fakeNode, backspace, mode);
+    const wordChar = mode === 'word' && !isSpace(removed);
+    // Backspace by word removes the spaces before the caret, then the word, and keeps the space in front of it
+    if (mode === 'sentence' || wordChar || (mode === 'word' && backspace)) {
+        checkRemoveChar(jodit, fakeNode, backspace, mode, wordChar && backspace);
     }
 }
+/**
+ * The char tryRemoveChar would remove next
+ */
+function nextChar(value, backspace) {
+    const chars = toArray(value);
+    const step = backspace ? -1 : 1;
+    let index = backspace ? chars.length - 1 : 0;
+    while (chars[index] === INVISIBLE_SPACE) {
+        index += step;
+    }
+    return chars[index];
+}
+function isSpace(char) {
+    return char === ' ' || char === NBSP_SPACE;
+}

package/esm/plugins/backspace/config.d.ts

@@ -7,6 +7,8 @@ declare module 'jodit/config' {
     interface Config {
         /**
          * Keyboard hotkey mappings for delete and backspace operations (character, word, sentence).
+         * On macOS the defaults leave out Cmd+Backspace, Ctrl+Backspace, Ctrl+Option+Backspace
+         * and Cmd+Option+Backspace, so the browser applies the system's own bindings to them.
          */
         delete: {
             hotkeys: {

package/esm/plugins/backspace/config.js

@@ -6,14 +6,17 @@
 /**
  * @module plugins/backspace
  */
+import { IS_MAC } from "../../core/constants.js";
 import { Config } from "../../config.js";
 Config.prototype.delete = {
     hotkeys: {
-        delete: ['delete', 'cmd+backspace'],
-        deleteWord: ['ctrl+delete', 'cmd+alt+backspace', 'ctrl+alt+backspace'],
+        delete: IS_MAC ? ['delete'] : ['delete', 'cmd+backspace'],
+        deleteWord: IS_MAC
+            ? ['ctrl+delete']
+            : ['ctrl+delete', 'cmd+alt+backspace', 'ctrl+alt+backspace'],
         deleteSentence: ['ctrl+shift+delete', 'cmd+shift+delete'],
         backspace: ['backspace'],
-        backspaceWord: ['ctrl+backspace'],
+        backspaceWord: IS_MAC ? [] : ['ctrl+backspace'],
         backspaceSentence: ['ctrl+shift+backspace', 'cmd+shift+backspace']
     }
 };

package/esm/plugins/clean-html/clean-html.d.ts

@@ -23,6 +23,14 @@ export declare class cleanHtml extends Plugin {
      */
     protected onChangeCleanHTML(): void;
     private currentSelectionNode;
+    /**
+     * Typing into an empty block (`<p><br></p>`) replaces its `<br>`, but the
+     * browser keeps the `<br>` when the caret is in an invisible-space text
+     * node in front of it, as Jodit leaves the caret in many of the empty
+     * blocks it makes (a cleared editor, a heading in an empty table cell).
+     * See #1632
+     */
+    protected onInputRemovePlaceholderBr(event: InputEvent | CompositionEvent): void;
     private walker;
     protected startWalker(): void;
     protected beforeCommand(command: string): void | false;

package/esm/plugins/clean-html/clean-html.js

@@ -21,7 +21,7 @@ import { safeHTML } from "../../core/helpers/html/safe-html.js";
 import { Plugin } from "../../core/plugin/plugin.js";
 import "./config.js";
 import { replaceOldTags } from "./helpers/visitor/filters/replace-old-tags.js";
-import { getHash, removeFormatForCollapsedSelection, removeFormatForSelection, visitNodeWalker } from "./helpers/index.js";
+import { getHash, removeFormatForCollapsedSelection, removeFormatForSelection, removePlaceholderBr, visitNodeWalker } from "./helpers/index.js";
 /**
  * Clean HTML after removeFormat and insertHorizontalRule command
  */
@@ -72,6 +72,23 @@ export class cleanHtml extends Plugin {
         this.walker.setWork(editor.editor);
         this.currentSelectionNode = editor.s.current();
     }
+    /**
+     * Typing into an empty block (`<p><br></p>`) replaces its `<br>`, but the
+     * browser keeps the `<br>` when the caret is in an invisible-space text
+     * node in front of it, as Jodit leaves the caret in many of the empty
+     * blocks it makes (a cleared editor, a heading in an empty table cell).
+     * See #1632
+     */
+    onInputRemovePlaceholderBr(event) {
+        var _a;
+        if (!this.isEditMode ||
+            (event.type === 'input' &&
+                (event.isComposing ||
+                    !((_a = event.inputType) === null || _a === void 0 ? void 0 : _a.startsWith('insert'))))) {
+            return;
+        }
+        removePlaceholderBr(this.j);
+    }
     startWalker() {
         const { jodit } = this;
         const allow = getHash(this.j.o.cleanHTML.allowTags);
@@ -239,6 +256,9 @@ export class cleanHtml extends Plugin {
 __decorate([
     watch([':change', ':afterSetMode', ':afterInit', ':mousedown', ':keydown'])
 ], cleanHtml.prototype, "onChangeCleanHTML", null);
+__decorate([
+    watch([':input', 'jodit.editor:compositionend'])
+], cleanHtml.prototype, "onInputRemovePlaceholderBr", null);
 __decorate([
     hook('ready')
 ], cleanHtml.prototype, "startWalker", null);

package/esm/plugins/clean-html/helpers/index.d.ts

@@ -10,4 +10,5 @@ export * from "./get-hash";
 export * from "./is-allowed-media-embed";
 export * from "./remove-format/remove-format-for-collapsed-selection";
 export * from "./remove-format/remove-format-for-selection";
+export * from "./remove-placeholder-br";
 export * from "./visitor/visit-node-walker";

package/esm/plugins/clean-html/helpers/index.js

@@ -10,4 +10,5 @@ export * from "./get-hash.js";
 export * from "./is-allowed-media-embed.js";
 export * from "./remove-format/remove-format-for-collapsed-selection.js";
 export * from "./remove-format/remove-format-for-selection.js";
+export * from "./remove-placeholder-br.js";
 export * from "./visitor/visit-node-walker.js";

package/esm/plugins/clean-html/helpers/remove-placeholder-br.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module plugins/clean-html
+ */
+import type { IJodit } from "../../../types/index";
+/**
+ * Remove the `<br>` that kept the block with the caret open while it was
+ * empty, once text has gone into the block: when the block is one line of
+ * text that ends in that `<br>`, the `<br>` adds nothing to it
+ * @private
+ */
+export declare function removePlaceholderBr(jodit: IJodit): void;

package/esm/plugins/clean-html/helpers/remove-placeholder-br.js

@@ -0,0 +1,51 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import { INSEPARABLE_TAGS } from "../../../core/constants.js";
+import { Dom } from "../../../core/dom/dom.js";
+import { trim } from "../../../core/helpers/string/trim.js";
+function lastNode(node) {
+    let last = node.lastChild;
+    while (Dom.isText(last) && !last.nodeValue) {
+        last = last.previousSibling;
+    }
+    return last;
+}
+/**
+ * Remove the `<br>` that kept the block with the caret open while it was
+ * empty, once text has gone into the block: when the block is one line of
+ * text that ends in that `<br>`, the `<br>` adds nothing to it
+ * @private
+ */
+export function removePlaceholderBr(jodit) {
+    var _a;
+    const block = Dom.closest(jodit.s.current(), Dom.isBlock, jodit.editor);
+    if (!block || !trim((_a = block.textContent) !== null && _a !== void 0 ? _a : '')) {
+        return;
+    }
+    let br = lastNode(block);
+    while (Dom.isElement(br) &&
+        !Dom.isTag(br, INSEPARABLE_TAGS) &&
+        !Dom.isBlock(br)) {
+        br = lastNode(br);
+    }
+    if (!Dom.isTag(br, 'br')) {
+        return;
+    }
+    // Another line break, a block, an image or an embed means the `<br>` may
+    // end an empty line, or give the caret a place after the embed
+    const isOneLineOfText = Dom.each(block, (node) => {
+        if (node !== br &&
+            Dom.isElement(node) &&
+            (Dom.isTag(node, INSEPARABLE_TAGS) ||
+                Dom.isBlock(node) ||
+                (Dom.isHTMLElement(node) && !node.isContentEditable))) {
+            return false;
+        }
+    });
+    if (isOneLineOfText) {
+        Dom.safeRemove(br);
+    }
+}

package/esm/plugins/delete/delete.d.ts

@@ -20,13 +20,23 @@ export declare class deleteCommand extends Plugin {
      */
     private __afterDeleteCommand;
     private __onDeleteCommand;
+    /**
+     * A selection that starts or ends in a table cell clears the selected part
+     * of each cell it covers and keeps the cells, as the browsers do.
+     * `deleteContents` would remove the cells it fully covers, and the cells
+     * it cuts would then be merged as blocks. The range is moved out of those
+     * tables, so only the content between them is left to delete.
+     *
+     * Returns where the caret goes, or null when no table is involved
+     */
+    private __clearSelectedCells;
     private __moveContentInLeftSibling;
     /**
      * If left sibling is list - return last leaf
      */
     private __defineRightLeftBox;
     /**
-     * Add BR in empty blocks left and right(for table cell)
+     * Add BR in the empty block left at the caret
      */
     private __addBrInEmptyBlock;
     private __moveCursorInEditableSibling;