jodit 4.18.2 → 4.18.4

package/esm/plugins/link/link.js

@@ -16,7 +16,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { autobind } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/index.js";
 import { pluginSystem } from "../../core/global.js";
-import { attr, call, convertMediaUrlToVideoEmbed, isString, isURL, refs, stripTags } from "../../core/helpers/index.js";
+import { attr, call, convertMediaUrlToVideoEmbed, isString, isURL, prepareEmbedCode, refs, stripTags } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/index.js";
 import "./config.js";
 /**
@@ -85,7 +85,10 @@ export class link extends Plugin {
                 height: (_d = jodit.o.video) === null || _d === void 0 ? void 0 : _d.defaultHeight
             });
             if (embed !== html) {
-                return jodit.createInside.fromHTML(embed);
+                const media = prepareEmbedCode(jodit, embed);
+                return isString(media)
+                    ? jodit.createInside.fromHTML(media)
+                    : media;
             }
         }
         if (jodit.s.isCollapsed()) {

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

@@ -28,7 +28,8 @@ declare module 'jodit/config' {
          * - is wrapped in it instead of the editor-only `mediaFakeTag` when its tag
          * is one of `mediaBlocks`, or left in it when it's already in one
          * - goes in inside it when the video popup inserts it, as an upload, a
-         * link's embed or embed code that is one element
+         * link's embed or embed code that is one element, and when a pasted
+         * video link is turned into its embed
          * - opens the media popup for its wrapper when clicked, whose Align and
          * Delete act on the wrapper
          *

package/esm/plugins/media/media.js

@@ -5,7 +5,7 @@
  */
 import * as consts from "../../core/constants.js";
 import { Dom } from "../../core/dom/dom.js";
-import { pluginSystem } from "../../core/global.js";
+import { getContainer, pluginSystem } from "../../core/global.js";
 import { $$, attr, dataBind, getMediaWrapper, wrapMedia } from "../../core/helpers/utils/index.js";
 import { css, cssInline } from "../../core/helpers/utils/css.js";
 import "./config.js";
@@ -26,6 +26,7 @@ export function media(editor) {
                 (_a = getMediaWrapper(editor, element)) !== null && _a !== void 0 ? _a : wrapMedia(editor, element);
         }
         else if (mediaInFakeBlock) {
+            const media = element;
             const wrapper = editor.createInside.element(mediaFakeTag, {
                 'data-jodit-temp': 1,
                 contenteditable: false,
@@ -33,13 +34,21 @@ export function media(editor) {
                 [`data-${keyFake}`]: 1
             });
             attr(wrapper, 'style', attr(element, 'style'));
-            css(wrapper, {
-                display: cssInline(element, 'display') === 'inline-block'
-                    ? 'inline-block'
-                    : 'block',
-                width: element.offsetWidth,
-                height: element.offsetHeight
-            });
+            // The wrapper fits the media, whose size changes as its metadata loads
+            // and as it's resized. A percentage width is of the line, so it takes that
+            const fit = () => {
+                css(wrapper, {
+                    display: cssInline(media, 'display') === 'inline-block'
+                        ? 'inline-block'
+                        : 'block',
+                    width: cssInline(media, 'width').endsWith('%')
+                        ? ''
+                        : 'fit-content',
+                    height: ''
+                });
+            };
+            fit();
+            editor.e.on(media, 'changesize', fit);
             if (element.parentNode) {
                 Dom.before(element, wrapper);
             }
@@ -49,12 +58,31 @@ export function media(editor) {
         else {
             return;
         }
+        // Selected, as an image is, so Delete and Backspace remove it
         editor.e
             .off(element, 'mousedown.select touchstart.select')
             .on(element, 'mousedown.select touchstart.select', () => {
-            editor.s.setCursorAfter(element);
+            editor.s.select(element);
         });
     };
+    // Media in a wrapper kept in the content let clicks through to it, as
+    // jodit-media covers its media, so a click selects the media rather than
+    // playing it. An inline wrapper holds it as an inline-block, unless its
+    // classes or style give it a display of their own
+    const wrappers = Object.values(mediaWrappers);
+    if (wrappers.length) {
+        editor.e.on('afterInit', () => {
+            const selectors = (list) => [...new Set(list)].join(',');
+            const scoped = ({ tag, className }) => `.jodit-wysiwyg ${tag}.${className}`;
+            const inline = selectors(wrappers
+                .filter(({ tag }) => consts.IS_INLINE.test(tag))
+                .map(scoped));
+            const media = selectors(wrappers.flatMap(wrapper => mediaBlocks.map(tag => `${scoped(wrapper)}>${tag}`)));
+            getContainer(editor, 'media-wrappers', 'style', true).innerHTML =
+                (inline ? `:where(${inline}){display:inline-block}` : '') +
+                    `${media}{pointer-events:none}`;
+        });
+    }
     if (mediaInFakeBlock || Object.keys(mediaWrappers).length) {
         editor.e
             .on('afterGetValueFromEditor', (data) => {

package/esm/plugins/paste/helpers.d.ts

@@ -8,6 +8,14 @@
  */
 import type { IDialog, IJodit, InsertMode, IUIOption, Nullable } from "../../types/index";
 import type { PasteEvent } from "./interface";
+/**
+ * Google Docs wraps the copied content in
+ * `<b style="font-weight:normal;" id="docs-internal-guid-…">`. Kept, the
+ * wrapper holds the pasted blocks, and without its style it makes the whole
+ * paste bold
+ * @private
+ */
+export declare function removeGoogleDocsWrapper(html: string): string;
 /**
  * One insert point for clipboard plugins
  * @private

package/esm/plugins/paste/helpers.js

@@ -5,6 +5,7 @@
  */
 import { TEXT_PLAIN } from "../../core/constants.js";
 import { Dom } from "../../core/dom/dom.js";
+import { toArray } from "../../core/helpers/array/to-array.js";
 import { isArray, isNumber, isString, isVoid } from "../../core/helpers/checker/index.js";
 import { Button } from "../../core/ui/button/button/button.js";
 /**
@@ -23,6 +24,22 @@ function removeExtraFragments(html) {
     }
     return html;
 }
+/**
+ * Google Docs wraps the copied content in
+ * `<b style="font-weight:normal;" id="docs-internal-guid-…">`. Kept, the
+ * wrapper holds the pasted blocks, and without its style it makes the whole
+ * paste bold
+ * @private
+ */
+export function removeGoogleDocsWrapper(html) {
+    if (!/<b\s[^>]*docs-internal-guid-/i.test(html)) {
+        return html;
+    }
+    // An inert document: images don't load and handlers don't run
+    const { body } = new DOMParser().parseFromString(html, 'text/html');
+    toArray(body.querySelectorAll('b[id^="docs-internal-guid-"]')).forEach(Dom.unwrap);
+    return body.innerHTML;
+}
 /**
  * @private
  */
@@ -46,7 +63,7 @@ export function pasteInsertHtml(e, editor, html) {
         html = result;
     }
     if (isString(html)) {
-        html = removeExtraFragments(html);
+        html = removeExtraFragments(removeGoogleDocsWrapper(html));
     }
     editor.s.insertHTML(html);
 }

package/esm/plugins/paste/paste.js

@@ -20,7 +20,7 @@ import { pluginSystem } from "../../core/global.js";
 import { cleanFromWord, getDataTransfer, htmlspecialchars, isHTML, isString, LimitedStack, nl2br, stripTags, trim } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/plugin.js";
 import "./config.js";
-import { askInsertTypeDialog, getAllTypes, pasteInsertHtml } from "./helpers.js";
+import { askInsertTypeDialog, getAllTypes, pasteInsertHtml, removeGoogleDocsWrapper } from "./helpers.js";
 /**
  * Ask before paste HTML source
  */
@@ -143,7 +143,7 @@ export class paste extends Plugin {
             this.j.buffer.set(CLIPBOARD_ID, html);
             switch (action) {
                 case INSERT_CLEAR_HTML:
-                    html = cleanFromWord(html);
+                    html = cleanFromWord(removeGoogleDocsWrapper(html));
                     break;
                 case INSERT_ONLY_TEXT:
                     html = stripTags(html, this.j.ed, new Set(this.j.o.pasteExcludeStripTags), this.j.o.nl2brInPlainText);

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

@@ -10,7 +10,7 @@ import type { HTMLTagNames } from "../../types/index";
 declare module 'jodit/config' {
     interface Config {
         /**
-         * Set of HTML tag names whose elements can be resized by the user via drag handles (e.g. images, iframes, tables)
+         * Set of HTML tag names whose elements can be resized by the user via drag handles (e.g. images, iframes, tables, videos)
          */
         allowResizeTags: Set<HTMLTagNames>;
         resizer: {
@@ -23,14 +23,16 @@ declare module 'jodit/config' {
              * Save width and height proportions when resizing
              * ```js
              * Jodit.make('#editor', {
-             *   allowResizeTags: ['img', 'iframe', 'table', 'jodit'],
+             *   allowResizeTags: new Set(['img', 'iframe', 'table', 'jodit', 'video']),
              *   resizer: {
              *     useAspectRatio: false, // don't save,
-             *     useAspectRatio: ['img'], // save only for images (default value)
+             *     useAspectRatio: new Set(['img']), // save only for images
              *     useAspectRatio: true // save for all
              *   }
              * });
              * ```
+             * Images and videos keep it by default. A video with no height of its
+             * own keeps it by being given only a width.
              */
             useAspectRatio: boolean | Set<HTMLTagNames>;
             /**

package/esm/plugins/resizer/config.js

@@ -4,12 +4,18 @@
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
 import { Config } from "../../config.js";
-Config.prototype.allowResizeTags = new Set(['img', 'iframe', 'table', 'jodit']);
+Config.prototype.allowResizeTags = new Set([
+    'img',
+    'iframe',
+    'table',
+    'jodit',
+    'video'
+]);
 Config.prototype.resizer = {
     showSize: true,
     hideSizeTimeout: 1000,
     forImageChangeAttributes: true,
     min_width: 10,
     min_height: 10,
-    useAspectRatio: new Set(['img'])
+    useAspectRatio: new Set(['img', 'video'])
 };

package/esm/plugins/resizer/resizer.d.ts

@@ -26,6 +26,7 @@ export declare class resizer extends Plugin {
     private height;
     private ratio;
     private rect;
+    private layer;
     private sizeViewer;
     /** @override */
     protected afterInit(editor: IJodit): void;
@@ -33,6 +34,11 @@ export declare class resizer extends Plugin {
      * Click in the editor area
      */
     protected onEditorClick(e: MouseEvent): void;
+    /**
+     * What a click on `node` resizes: the media in it when it's a media
+     * wrapper (`jodit-media`, or one from `mediaWrappers`), or `node` itself
+     */
+    private __resizable;
     protected __afterInsertImage(image: HTMLImageElement): void;
     private addEventListeners;
     private onStartResizing;
@@ -46,6 +52,10 @@ export declare class resizer extends Plugin {
     private onClickOutside;
     private getWorkplacePosition;
     private applySize;
+    /**
+     * The framed element can go with a wrapper round it, keeping its parent
+     */
+    private get isElementInEditor();
     private onDelete;
     private __onChangeEditor;
     /**

package/esm/plugins/resizer/resizer.js

@@ -18,7 +18,7 @@ import { IS_ES_NEXT, IS_IE, KEY_ALT } from "../../core/constants.js";
 import { autobind, watch } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/dom.js";
 import { eventEmitter, pluginSystem } from "../../core/global.js";
-import { $$, attr, css, dataBind, innerWidth, markOwner, offset } from "../../core/helpers/index.js";
+import { $$, attr, css, dataBind, getWrappedMedia, innerWidth, markOwner, offset } from "../../core/helpers/index.js";
 import { cssInline } from "../../core/helpers/utils/css.js";
 import { Plugin } from "../../core/plugin/plugin.js";
 import "./config.js";
@@ -36,6 +36,15 @@ function attrPixelSize(element, key) {
     }
     return parseFloat(value);
 }
+/**
+ * A video with no height of its own takes it from its width and its ratio,
+ * so resizing it keeps the ratio without setting a height.
+ */
+function heightFollowsWidth(element) {
+    return (Dom.isTag(element, 'video') &&
+        !attr(element, 'height') &&
+        !cssInline(element, 'height'));
+}
 /**
  * The module creates a supporting frame for resizing of the elements img and table
  */
@@ -58,6 +67,8 @@ export class resizer extends Plugin {
 				<div class="jodit-resizer__bottom-left"></div>
 				<span>100x100</span>
 			</div>`);
+        // Clips the frame to the workplace, without the frame making it scroll
+        this.layer = this.j.c.div('jodit-resizer-layer');
         this.sizeViewer = this.rect.getElementsByTagName('span')[0];
         this.pointerX = 0;
         this.pointerY = 0;
@@ -72,6 +83,10 @@ export class resizer extends Plugin {
                 if (Dom.isTag(this.element, 'img') && !this.element.complete) {
                     this.j.e.one(this.element, 'load', this.updateSize);
                 }
+                if (Dom.isTag(this.element, 'video') &&
+                    this.element.readyState < HTMLMediaElement.HAVE_METADATA) {
+                    this.j.e.one(this.element, 'loadedmetadata', this.updateSize);
+                }
             }
         };
         this.updateSize = () => {
@@ -135,14 +150,33 @@ export class resizer extends Plugin {
         let node = e.target;
         const { editor, options: { allowResizeTags } } = this.j;
         while (node && node !== editor) {
-            if (Dom.isTag(node, allowResizeTags)) {
-                this.__bind(node);
-                this.onClickElement(node);
+            const element = this.__resizable(node);
+            if (Dom.isTag(element, allowResizeTags)) {
+                this.__bind(element);
+                this.onClickElement(element);
                 return;
             }
             node = node.parentNode;
         }
     }
+    /**
+     * What a click on `node` resizes: the media in it when it's a media
+     * wrapper (`jodit-media`, or one from `mediaWrappers`), or `node` itself
+     */
+    __resizable(node) {
+        var _a;
+        const media = (_a = getWrappedMedia(this.j, node)) !== null && _a !== void 0 ? _a : (Dom.isHTMLElement(node) && attr(node, 'data-jodit_fake_wrapper')
+            ? node.firstElementChild
+            : null);
+        if (!media) {
+            return node;
+        }
+        // An embed is resized through its own wrapper
+        return Dom.isHTMLElement(media.parentNode) &&
+            attr(media.parentNode, 'data-jodit_iframe_wrapper')
+            ? media.parentNode
+            : media;
+    }
     __afterInsertImage(image) {
         if (this.j.o.resizer.forImageChangeAttributes) {
             return;
@@ -160,7 +194,8 @@ export class resizer extends Plugin {
             .off(editor.ow, '.resizer')
             .on(editor.editor, 'keydown.resizer', (e) => {
             if (this.isShown &&
-                e.key === consts.KEY_DELETE &&
+                (e.key === consts.KEY_DELETE ||
+                    e.key === consts.KEY_BACKSPACE) &&
                 this.element &&
                 !Dom.isTag(this.element, 'table')) {
                 this.onDelete(e);
@@ -168,17 +203,15 @@ export class resizer extends Plugin {
         })
             .on(editor.ow, 'resize.resizer', this.updateSize)
             .on('resize.resizer', this.updateSize)
-            .on([editor.ow, editor.editor], 'scroll.resizer', () => {
-            if (this.isShown && !this.isResizeMode) {
-                this.hide();
-            }
-        })
+            // The frame is outside the content, so it's moved to follow the
+            // element as the content scrolls
+            .on([editor.ow, editor.editor], 'scroll.resizer', this.updateSize)
             .on(editor.ow, 'keydown.resizer', this.onKeyDown)
             .on(editor.ow, 'keyup.resizer', this.onKeyUp)
             .on(editor.ow, 'mouseup.resizer touchend.resizer', this.onClickOutside);
     }
     onStartResizing(resizeHandle, e) {
-        if (!this.element || !this.element.parentNode) {
+        if (!this.element || !this.isElementInEditor) {
             this.hide();
             return false;
         }
@@ -232,8 +265,9 @@ export class resizer extends Plugin {
             const className = this.handle.className;
             let new_w, new_h;
             const uar = this.j.o.resizer.useAspectRatio;
-            if (!this.isAltMode &&
-                (uar === true || (uar && Dom.isTag(this.element, uar)))) {
+            const keepRatio = !this.isAltMode &&
+                (uar === true || Boolean(uar && Dom.isTag(this.element, uar)));
+            if (keepRatio) {
                 if (diff_x) {
                     new_w =
                         this.width +
@@ -265,7 +299,8 @@ export class resizer extends Plugin {
                     this.applySize(this.element, 'width', '100%');
                 }
             }
-            if (new_h > this.j.o.resizer.min_height) {
+            if (new_h > this.j.o.resizer.min_height &&
+                !(keepRatio && heightFollowsWidth(this.element))) {
                 this.applySize(this.element, 'height', new_h);
             }
             this.updateSize();
@@ -311,10 +346,20 @@ export class resizer extends Plugin {
             css(element, key, value);
         }
     }
+    /**
+     * The framed element can go with a wrapper round it, keeping its parent
+     */
+    get isElementInEditor() {
+        return Boolean(this.element && this.j.editor.contains(this.element));
+    }
     onDelete(e) {
         if (!this.element) {
             return;
         }
+        if (!this.isElementInEditor) {
+            this.hide();
+            return;
+        }
         if (this.element.tagName !== 'JODIT') {
             this.j.s.select(this.element);
         }
@@ -326,7 +371,7 @@ export class resizer extends Plugin {
     }
     __onChangeEditor() {
         if (this.isShown) {
-            if (!this.element || !this.element.parentNode) {
+            if (!this.isElementInEditor) {
                 this.hide();
             }
             else {
@@ -396,8 +441,12 @@ export class resizer extends Plugin {
             })
                 .off(element, 'changesize')
                 .on(element, 'changesize', () => {
-                attr(iframe, 'width', element.offsetWidth + 'px');
-                attr(iframe, 'height', element.offsetHeight + 'px');
+                // Only a resize sets the embed's size, and as the plain numbers
+                // the attributes take, so a click leaves `width="100%"` alone
+                if (this.isResizeMode) {
+                    attr(iframe, 'width', element.offsetWidth);
+                    attr(iframe, 'height', element.offsetHeight);
+                }
             });
         }
         this.j.e.on(element, 'dragstart', this.hide);
@@ -434,9 +483,13 @@ export class resizer extends Plugin {
             return;
         }
         this.isShown = true;
+        if (this.layer.parentNode !== this.j.workplace) {
+            markOwner(this.j, this.layer);
+            Dom.append(this.j.workplace, this.layer);
+        }
         if (!this.rect.parentNode) {
             markOwner(this.j, this.rect);
-            Dom.append(this.j.workplace, this.rect);
+            Dom.append(this.layer, this.rect);
         }
         if (this.j.isFullSize) {
             css(this.rect, 'zIndex', css(this.j.container, 'zIndex').toString());
@@ -457,6 +510,7 @@ export class resizer extends Plugin {
     }
     beforeDestruct(jodit) {
         this.hide();
+        Dom.safeRemove(this.layer);
         eventEmitter.off('hideHelpers', this.hide);
         jodit.e.off(this.j.ow, '.resizer').off('.resizer');
     }

package/esm/plugins/select-cells/select-cells.d.ts

@@ -52,10 +52,20 @@ export declare class selectCells extends Plugin {
      * Execute custom commands for table
      */
     private onExecCommand;
+    /**
+     * The cell that takes the caret when rows or columns are deleted: the next
+     * one in the same column (or row) that is not deleted, else the previous one
+     */
+    private __nearestCell;
     /**
      * Add some align after native command
      */
     private onAfterCommand;
+    /**
+     * Remove the table and put the caret where it stood: at the start of what
+     * follows it, else at the end of what precedes it
+     */
+    private __removeTable;
     /** @override */
     protected beforeDestruct(jodit: IJodit): void;
 }

package/esm/plugins/select-cells/select-cells.js

@@ -17,7 +17,7 @@ import { KEY_TAB } from "../../core/constants.js";
 import { autobind, watch } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/dom.js";
 import { pluginSystem } from "../../core/global.js";
-import { $$, alignElement, position } from "../../core/helpers/index.js";
+import { $$, alignElement, position, toArray } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/index.js";
 import { Table } from "../../modules/table/table.js";
 import "./config.js";
@@ -316,15 +316,23 @@ export class selectCells extends Plugin {
                         this.__tableModule.mergeSelected(table);
                         break;
                     case 'empty':
-                        cells.forEach(td => Dom.detach(td));
+                        cells.forEach(td => {
+                            Dom.detach(td);
+                            Dom.append(td, this.j.createInside.element('br'));
+                        });
                         break;
                     case 'bin':
-                        Dom.safeRemove(table);
+                        this.__removeTable(table);
                         break;
                     case 'binrow':
-                        new Set(cells.map(td => td.parentNode)).forEach(row => {
-                            this.__tableModule.removeRow(table, row.rowIndex);
-                        });
+                        {
+                            const rows = new Set(cells.map(td => td.parentNode));
+                            const next = this.__nearestCell(table, cell, toArray(rows).map(row => row.rowIndex), true);
+                            rows.forEach(row => {
+                                this.__tableModule.removeRow(table, row.rowIndex);
+                            });
+                            next && this.j.s.setCursorIn(next);
+                        }
                         break;
                     case 'bincolumn':
                         {
@@ -337,11 +345,13 @@ export class selectCells extends Plugin {
                                     columnsSet.add(col);
                                 }
                             });
+                            const next = this.__nearestCell(table, cell, columns, false);
                             columns
                                 .sort((a, b) => b - a)
                                 .forEach(col => {
                                 this.__tableModule.removeColumn(table, col);
                             });
+                            next && this.j.s.setCursorIn(next);
                         }
                         break;
                     case 'addcolumnafter':
@@ -353,10 +363,39 @@ export class selectCells extends Plugin {
                         this.__tableModule.appendRow(table, cell.parentNode, command === 'addrowafter');
                         break;
                 }
+                if (/^bin(row|column)$/.test(command) &&
+                    !this.__tableModule.getColumnsCount(table)) {
+                    this.__removeTable(table);
+                }
             }
             return false;
         }
     }
+    /**
+     * The cell that takes the caret when rows or columns are deleted: the next
+     * one in the same column (or row) that is not deleted, else the previous one
+     */
+    __nearestCell(table, cell, deleted, isRow) {
+        const box = this.__tableModule.formalMatrix(table);
+        const [row, column] = this.__tableModule.formalCoordinate(table, cell);
+        const start = isRow ? row : column;
+        const count = isRow ? box.length : box[row].length;
+        const find = (i) => (!deleted.includes(i) && (isRow ? box[i][column] : box[row][i])) ||
+            null;
+        for (let i = start + 1; i < count; i += 1) {
+            const next = find(i);
+            if (next) {
+                return next;
+            }
+        }
+        for (let i = start - 1; i >= 0; i -= 1) {
+            const prev = find(i);
+            if (prev) {
+                return prev;
+            }
+        }
+        return null;
+    }
     /**
      * Add some align after native command
      */
@@ -367,6 +406,15 @@ export class selectCells extends Plugin {
                 .forEach(elm => alignElement(command, elm));
         }
     }
+    /**
+     * Remove the table and put the caret where it stood: at the start of what
+     * follows it, else at the end of what precedes it
+     */
+    __removeTable(table) {
+        const parent = table.parentNode, next = Dom.findNotEmptySibling(table, false), prev = Dom.findNotEmptySibling(table, true);
+        Dom.safeRemove(table);
+        this.j.s.setCursorIn(next || prev || parent, Boolean(next));
+    }
     /** @override */
     beforeDestruct(jodit) {
         this.__onRemoveSelection();

package/esm/plugins/table/config.js

@@ -16,6 +16,44 @@ Config.prototype.table = {
     useExtraClassesOptions: false
 };
 Icon.set('table', tableIcon);
+/**
+ * Elements in `dtd.blockLimits` that hold only rows, cells or list items, so
+ * a table can't go directly inside them
+ */
+const ROW_AND_ITEM_HOLDERS = new Set([
+    'table',
+    'thead',
+    'tbody',
+    'tfoot',
+    'tr',
+    'ul',
+    'ol',
+    'dl'
+]);
+/**
+ * The nearest block around the cursor that can hold the new table: an element
+ * in `dtd.blockLimits`, such as a table cell, a list item or a `<div>`. The
+ * cursor's own block of the `enter` tag is a line, not a container, as in the
+ * dtd plugin's `checkBlockNesting`
+ */
+function findTableContainer(editor, current) {
+    const line = Dom.closest(current, Dom.isBlock, editor.editor);
+    const container = Dom.closest(current, node => {
+        var _a;
+        if (!Dom.isElement(node) ||
+            (node === line && Dom.isTag(node, editor.o.enter))) {
+            return false;
+        }
+        const tag = node.nodeName.toLowerCase();
+        return (Boolean((_a = editor.o.dtd) === null || _a === void 0 ? void 0 : _a.blockLimits[tag]) &&
+            !ROW_AND_ITEM_HOLDERS.has(tag));
+    }, editor.editor);
+    // With the cursor between two rows, `current` is the next row's text
+    return container &&
+        Dom.isOrContains(container, editor.s.range.startContainer)
+        ? container
+        : null;
+}
 Config.prototype.controls.table = {
     data: {
         cols: 10,
@@ -129,7 +167,13 @@ Config.prototype.controls.table = {
             editor.s.removeMarkers();
             editor.editor.normalize();
             editor.history.snapshot.restore(snapshot);
-            const block = Dom.furthest(editor.s.current(), Dom.isBlock, editor.editor);
+            const current = editor.s.current();
+            // The table goes into the cell, list item or box holding the
+            // cursor, and only a block inside it is split
+            const container = findTableContainer(editor, current);
+            const block = container === current
+                ? null
+                : Dom.furthest(current, Dom.isBlock, container !== null && container !== void 0 ? container : editor.editor);
             if (block && Dom.isEmpty(block)) {
                 Dom.replace(block, table, undefined, false, true);
             }
@@ -155,6 +199,12 @@ Config.prototype.controls.table = {
                         }
                     }
                 }
+                else if (container &&
+                    !Dom.isEmpty(container) &&
+                    !editor.o.table.splitBlockOnInsertTable) {
+                    // With no block to go after, the table goes after the text
+                    Dom.append(container, table);
+                }
                 else {
                     editor.s.insertNode(table, false);
                 }