jodit 4.18.4 → 4.18.7

package/esm/plugins/delete/delete.js

@@ -5,7 +5,7 @@
  */
 import { Dom } from "../../core/dom/index.js";
 import { pluginSystem } from "../../core/global.js";
-import { $$ } from "../../core/helpers/index.js";
+import { toArray } from "../../core/helpers/index.js";
 import { trim } from "../../core/helpers/string/trim.js";
 import { Plugin } from "../../core/plugin/index.js";
 import "./interface.js";
@@ -56,6 +56,11 @@ export class deleteCommand extends Plugin {
         }
         jodit.s.expandSelection();
         const range = jodit.s.range;
+        const caret = this.__clearSelectedCells(range);
+        if (caret && range.collapsed) {
+            jodit.s.selectRange(caret);
+            return false;
+        }
         range.deleteContents();
         const fake = jodit.createInside.fake();
         range.insertNode(fake);
@@ -65,13 +70,78 @@ export class deleteCommand extends Plugin {
         range.setStartBefore(fake);
         range.collapse(true);
         this.__moveCursorInEditableSibling(jodit, leftSibling, fake, range);
-        this.__addBrInEmptyBlock(fake, rightSibling, range);
+        this.__addBrInEmptyBlock(fake, range);
         Dom.safeRemove(fake);
-        jodit.s.selectRange(range);
+        jodit.s.selectRange(caret !== null && caret !== void 0 ? caret : range);
         return false;
     }
+    /**
+     * 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
+     */
+    __clearSelectedCells(range) {
+        const { editor, createInside } = this.j;
+        const startCell = Dom.closest(range.startContainer, Dom.isCell, editor);
+        const endCell = Dom.closest(range.endContainer, Dom.isCell, editor);
+        if (startCell === endCell) {
+            return null;
+        }
+        const startTable = Dom.closest(startCell, 'table', editor);
+        const endTable = Dom.closest(endCell, 'table', editor);
+        const caret = range.cloneRange();
+        caret.collapse(true);
+        const parts = [];
+        const addParts = (table) => {
+            toArray(table.rows)
+                .flatMap(row => toArray(row.cells))
+                .filter(cell => range.intersectsNode(cell))
+                .forEach(cell => {
+                const part = range.cloneRange();
+                if (!Dom.isOrContains(cell, range.startContainer)) {
+                    part.setStart(cell, 0);
+                }
+                if (!Dom.isOrContains(cell, range.endContainer)) {
+                    part.setEnd(cell, cell.childNodes.length);
+                }
+                parts.push([cell, part]);
+            });
+        };
+        if (startTable) {
+            addParts(startTable);
+            if (startTable === endTable) {
+                range.collapse(true);
+            }
+            else {
+                range.setStartAfter(startTable);
+            }
+        }
+        if (endTable && endTable !== startTable) {
+            addParts(endTable);
+            range.setEndBefore(endTable);
+        }
+        parts.forEach(([cell, part]) => {
+            part.deleteContents();
+            if (Dom.isEmpty(cell)) {
+                Dom.detach(cell);
+                Dom.append(cell, createInside.element('br'));
+            }
+        });
+        return startTable ? caret : null;
+    }
     __moveContentInLeftSibling(fake, leftSibling, rightSibling) {
         leftSibling = this.__defineRightLeftBox(leftSibling);
+        // Nothing is moved into a table, and a block left empty after it goes
+        if (Dom.isTag(leftSibling, 'table')) {
+            if (Dom.isBlock(rightSibling) && Dom.isEmpty(rightSibling)) {
+                Dom.safeRemove(rightSibling);
+            }
+            return;
+        }
         if (!Dom.isList(rightSibling) &&
             !Dom.isTag(rightSibling, 'table') &&
             Dom.isBlock(rightSibling) &&
@@ -80,11 +150,24 @@ export class deleteCommand extends Plugin {
             Dom.moveContent(rightSibling, leftSibling);
             Dom.safeRemove(rightSibling);
         }
-        // Remove empty right LI
         if (Dom.isList(rightSibling) &&
-            Dom.isLeaf(rightSibling.firstElementChild) &&
-            Dom.isEmpty(rightSibling.firstElementChild)) {
-            Dom.safeRemove(rightSibling.firstElementChild);
+            Dom.isLeaf(rightSibling.firstElementChild)) {
+            const item = rightSibling.firstElementChild;
+            // What's left of the right list's first item joins the left block,
+            // up to a list nested in the item
+            if (!Dom.isEmpty(item) && Dom.isBlock(leftSibling)) {
+                Dom.append(leftSibling, fake);
+                while (item.firstChild && !Dom.isBlock(item.firstChild)) {
+                    Dom.append(leftSibling, item.firstChild);
+                }
+            }
+            // Remove empty right LI
+            if (Dom.isEmpty(item)) {
+                Dom.safeRemove(item);
+            }
+            if (Dom.isEmpty(rightSibling)) {
+                Dom.safeRemove(rightSibling);
+            }
         }
     }
     /**
@@ -102,9 +185,9 @@ export class deleteCommand extends Plugin {
         return lastLeaf;
     }
     /**
-     * Add BR in empty blocks left and right(for table cell)
+     * Add BR in the empty block left at the caret
      */
-    __addBrInEmptyBlock(fake, rightSibling, range) {
+    __addBrInEmptyBlock(fake, range) {
         const jodit = this.j;
         if (fake.isConnected &&
             Dom.isBlock(fake.parentNode) &&
@@ -115,13 +198,6 @@ export class deleteCommand extends Plugin {
             range.setStartBefore(br);
             range.collapse(true);
         }
-        // Add BR in the right empty table cell
-        if (Dom.isTag(rightSibling, 'table')) {
-            const firstCell = $$('td,th', rightSibling).shift();
-            if (Dom.isCell(firstCell) && Dom.isEmpty(firstCell)) {
-                Dom.append(firstCell, jodit.createInside.element('br'));
-            }
-        }
     }
     __moveCursorInEditableSibling(jodit, leftSibling, fake, range) {
         var _a;

package/esm/plugins/focus/focus.js

@@ -67,7 +67,18 @@ export function focus(editor) {
     editor.e.on('afterInit', () => {
         if (editor.o.autofocus) {
             if (editor.defaultTimeout) {
-                editor.async.setTimeout(focus, 300);
+                // A click or key in the editor during the delay has put the
+                // caret where the user wants it, so autofocus leaves it there
+                const userInput = 'mousedown touchstart keydown';
+                const cancel = () => {
+                    editor.async.clearTimeout(timeout);
+                    editor.e.off(userInput, cancel);
+                };
+                const timeout = editor.async.setTimeout(() => {
+                    editor.e.off(userInput, cancel);
+                    focus();
+                }, 300);
+                editor.e.on(userInput, cancel);
             }
             else {
                 focus();

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

@@ -37,6 +37,9 @@ declare module 'jodit/config' {
         iframeDoctype: string;
         /**
          * Custom style to be used inside the iframe to display content.
+         * It goes in after `iframeCSSLinks`. The rules Jodit's own plugins need
+         * in the editing document are added apart from it, so a value of your
+         * own doesn't have to repeat them.
          *
          * ```javascript
          * Jodit.make('#editor', {

package/esm/plugins/iframe/config.js

@@ -51,33 +51,6 @@ Config.prototype.iframeStyle =
         'p{' +
         'margin-top:0;' +
         '}' +
-        '[data-jodit_iframe_wrapper]{' +
-        'display: block;' +
-        'user-select: none;' +
-        'position: relative;' +
-        '}' +
-        '[data-jodit_iframe_wrapper] iframe{' +
-        'position: relative;' +
-        '}' +
-        '[data-jodit_iframe_wrapper]:after {' +
-        'position:absolute;' +
-        'content:"";' +
-        'z-index:1;' +
-        'top:0;' +
-        'left:0;' +
-        'right: 0;' +
-        'bottom: 0;' +
-        'cursor: pointer;' +
-        'display: block;' +
-        'background: rgba(0, 0, 0, 0);' +
-        '} ' +
-        '[data-jodit_iframe_wrapper][data-jodit-wrapper_active=true] iframe{' +
-        'z-index: 2;' +
-        '}' +
-        '.jodit-wysiwyg_image-selected::selection,' +
-        '.jodit-wysiwyg_image-selected *:not(img)::selection{' +
-        'background:transparent' +
-        '}' +
         '.jodit_disabled{' +
         'user-select: none;' +
         '-o-user-select: none;' +

package/esm/plugins/iframe/iframe.js

@@ -7,7 +7,7 @@ import { MODE_SOURCE } from "../../core/constants.js";
 import { Dom } from "../../core/dom/dom.js";
 import { pluginSystem } from "../../core/global.js";
 import { error } from "../../core/helpers/index.js";
-import { attr, callPromise, css, defaultLanguage } from "../../core/helpers/index.js";
+import { $$, attr, callPromise, css, defaultLanguage } from "../../core/helpers/index.js";
 import "./config.js";
 /**
  * Iframe plugin - use `iframe` instead of DIV in editor. It can be need when you want to attach custom styles in editor
@@ -43,6 +43,8 @@ export function iframe(editor) {
                 attr(link, 'rel', 'stylesheet');
                 attr(link, 'href', href);
                 doc.head && Dom.append(doc.head, link);
+                // What plugins measured in the editing document changes once it's styled
+                jodit.e.on(link, 'load', () => jodit.e.fire('resize'));
             });
         }
         if (opt.iframeStyle) {
@@ -83,6 +85,8 @@ export function iframe(editor) {
                     null);
             };
             const clearMarkers = (html) => {
+                // The plugins' own styles, from `getContainer`, aren't part of the value
+                html = html.replace(/<style[^>]+jodit-box[^>]*>[\s\S]*?<\/style>/gi, '');
                 const bodyReg = /<body.*<\/body>/im, bodyMarker = '{%%BODY%%}', body = bodyReg.exec(html);
                 if (body) {
                     // remove markers
@@ -119,7 +123,10 @@ export function iframe(editor) {
             const replaceDocument = (html) => {
                 const inert = new DOMParser().parseFromString(html, 'text/html');
                 editor.e.fire('safeHTML', inert.documentElement);
+                // The plugins' own styles stay, as the value leaves them out
+                const styles = $$('style.jodit-box', doc.head);
                 doc.replaceChild(doc.adoptNode(inert.documentElement), doc.documentElement);
+                styles.forEach(style => Dom.append(doc.head, style));
             };
             if (docMode) {
                 const tag = editor.element.tagName;

package/esm/plugins/image-processor/image-processor.js

@@ -16,7 +16,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { INVISIBLE_SPACE_REG_EXP, SOURCE_CONSUMER } from "../../core/constants.js";
 import { autobind, cached, debounce, watch } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/dom.js";
-import { pluginSystem } from "../../core/global.js";
+import { getContainer, pluginSystem } from "../../core/global.js";
 import { $$, dataBind, getWrappedMedia } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/index.js";
 import { dataURItoBlob } from "../../modules/uploader/helpers/data-uri-to-blob.js";
@@ -31,6 +31,11 @@ const SELECTED_TAGS = new Set(['img', 'jodit', 'jodit-media']);
 export class imageProcessor extends Plugin {
     afterInit(jodit) {
         jodit.e.on(jodit.ed, 'selectionchange', this.onSelectionChange);
+        // Over the highlight in `styles/reset.less`; the image keeps its own. It goes
+        // in the editing document, so iframe mode has it whatever `iframeStyle` holds
+        getContainer(jodit, 'image-processor', 'style', true).textContent =
+            `.jodit-wysiwyg.${IMAGE_SELECTED}::selection,` +
+                `.jodit-wysiwyg.${IMAGE_SELECTED} *:not(img)::selection{background:transparent}`;
     }
     beforeDestruct(jodit) {
         jodit.e.off(jodit.ed, 'selectionchange', this.onSelectionChange);

package/esm/plugins/image-properties/image-properties.d.ts

@@ -52,6 +52,11 @@ export declare class imageProperties extends Plugin {
      * ```
      */
     protected open(): void | false;
+    /**
+     * Keys typed while the dialog is open must not reach the editor behind it,
+     * so focus the active tab's first field, or else the first field shown
+     */
+    private __focusFirstField;
     private __lock;
     private __unlock;
     /** @override **/

package/esm/plugins/image-properties/image-properties.js

@@ -16,7 +16,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { cache, cached, watch } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/dom.js";
 import { pluginSystem } from "../../core/global.js";
-import { isAbortError, isNumeric, markOwner } from "../../core/helpers/index.js";
+import { isAbortError, isNumeric, markOwner, toArray } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/plugin.js";
 import { Button } from "../../core/ui/button/index.js";
 import "./config.js";
@@ -99,8 +99,12 @@ export class imageProperties extends Plugin {
             dialog.close();
         });
         buttons.remove.onAction(() => {
+            const caret = j.s.createRange();
+            caret.setStartBefore(this.state.sourceImage);
+            caret.collapse(true);
             j.s.removeNode(this.state.sourceImage);
             dialog.close();
+            j.s.selectRange(caret);
         });
         buttons.cancel.onAction(() => {
             dialog.close();
@@ -108,11 +112,20 @@ export class imageProperties extends Plugin {
         dialog.setHeader(j.i18n('Image properties'));
         dialog.setContent(this.form);
         dialog.setFooter([[buttons.cancel, buttons.remove], buttons.check]);
-        j.e.on(dialog, 'afterClose', () => {
-            if (this.state.image.parentNode &&
-                j.o.image.selectImageAfterClose) {
-                j.s.select(this.state.sourceImage);
+        // The dialog fires `afterClose` on its own emitter, not the editor's
+        dialog.e.on(dialog, 'afterClose', () => {
+            const { sourceImage } = this.state;
+            if (j.isInDestruct || !Dom.isOrContains(j.editor, sourceImage)) {
+                return;
             }
+            if (j.o.image.selectImageAfterClose) {
+                j.s.select(sourceImage);
+                return;
+            }
+            const caret = j.s.createRange();
+            caret.setStartAfter(sourceImage);
+            caret.collapse(true);
+            j.s.selectRange(caret);
         });
         dialog.setSize(j.o.image.dialogWidth);
         markOwner(j, dialog.container);
@@ -144,6 +157,7 @@ export class imageProperties extends Plugin {
         this.activeTabState.activeTab = 'Image';
         this.__lock();
         this.dialog.open().setModal(true).setPosition();
+        this.__focusFirstField();
         this.async
             .promise((resolve, reject) => readValuesFromImage(this.j, this.state).then(resolve, reject))
             .catch((e) => {
@@ -154,6 +168,17 @@ export class imageProperties extends Plugin {
             .finally(() => this.__unlock());
         return false;
     }
+    /**
+     * Keys typed while the dialog is open must not reach the editor behind it,
+     * so focus the active tab's first field, or else the first field shown
+     */
+    __focusFirstField() {
+        var _a;
+        const fields = (box) => toArray(box.querySelectorAll('input, select, textarea'));
+        (_a = fields(this.form.getElm('tabsBox'))
+            .concat(fields(this.form.container))
+            .find(field => field.offsetParent != null)) === null || _a === void 0 ? void 0 : _a.focus();
+    }
     __lock() {
         this.dialog.lock();
         this.form.setMod('lock', true);

package/esm/plugins/inline-popup/inline-popup.d.ts

@@ -37,6 +37,17 @@ export declare class inlinePopup extends Plugin {
      */
     private hidePopup;
     protected onOutsideClick(): void;
+    /**
+     * A key that moves the caret off an element closes its popup, and one
+     * that moves the caret into an element with a popup (a link) opens it,
+     * as clicks do
+     */
+    protected onKeyUp(): void;
+    private __followCaret;
+    /**
+     * The element with a popup that holds `node`
+     */
+    private __elementAt;
     /**
      * Can show popup for this type
      */
@@ -53,6 +64,13 @@ export declare class inlinePopup extends Plugin {
      * while the selection is still there. See #1238
      */
     private __reopenSelectionPopup;
+    /**
+     * The alignment controls fire `recalcPositionPopup` once they have moved
+     * the element, and their button then fires `closeAllPopups`. The popup
+     * opens again beside the element, as the selection toolbar does
+     */
+    private __reopenFor;
+    protected onRecalcPositionPopup(): void;
     private __onDocumentMouseDown;
     private __onCloseAllPopups;
     /**
@@ -64,6 +82,7 @@ export declare class inlinePopup extends Plugin {
     private __selectionBound;
     private snapRange;
     private onSelectionStart;
+    private __keyDownElement;
     private onSelectionEnd;
     /**
      * Selection change handler

package/esm/plugins/inline-popup/inline-popup.js

@@ -18,6 +18,7 @@ import { Dom } from "../../core/dom/index.js";
 import { pluginSystem } from "../../core/global.js";
 import { camelCase, getMediaWrapper, getWrappedMedia, isArray, isFunction, isString, keys, position, splitArray, toArray } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/index.js";
+import { isMoved } from "../../core/selection/helpers/index.js";
 import { UIElement } from "../../core/ui/index.js";
 import { Popup } from "../../core/ui/popup/index.js";
 import { makeCollection } from "../../modules/toolbar/factory.js";
@@ -35,7 +36,14 @@ export class inlinePopup extends Plugin {
          * while the selection is still there. See #1238
          */
         this.__reopenSelectionPopup = false;
+        /**
+         * The alignment controls fire `recalcPositionPopup` once they have moved
+         * the element, and their button then fires `closeAllPopups`. The popup
+         * opens again beside the element, as the selection toolbar does
+         */
+        this.__reopenFor = null;
         this.snapRange = null;
+        this.__keyDownElement = null;
         this.elmsList = keys(this.j.o.popup, false).filter(s => !this.isExcludedTarget(s));
     }
     get popup() {
@@ -129,6 +137,38 @@ export class inlinePopup extends Plugin {
     onOutsideClick() {
         this.popup.close();
     }
+    /**
+     * A key that moves the caret off an element closes its popup, and one
+     * that moves the caret into an element with a popup (a link) opens it,
+     * as clicks do
+     */
+    onKeyUp() {
+        this.__followCaret();
+    }
+    __followCaret() {
+        if (!isMoved(this.j, this.snapRange)) {
+            return;
+        }
+        const { range } = this.j.s;
+        const target = this.previousTarget;
+        if (this.popup.isOpened &&
+            this.type !== 'selection' &&
+            target &&
+            !range.intersectsNode(target)) {
+            this.popup.close();
+        }
+        const node = range.startContainer;
+        const element = this.__elementAt(node);
+        if (range.collapsed && element && element !== this.__keyDownElement) {
+            this.onClick(node);
+        }
+    }
+    /**
+     * The element with a popup that holds `node`
+     */
+    __elementAt(node) {
+        return Dom.closest(node, this.elmsList, this.j.editor);
+    }
     /**
      * Can show popup for this type
      */
@@ -183,7 +223,15 @@ export class inlinePopup extends Plugin {
             .on('closeAllPopups', this.__onCloseAllPopups);
         this.addListenersForElements();
     }
+    onRecalcPositionPopup() {
+        if (this.popup.isOpened &&
+            this.type !== 'selection' &&
+            this.previousTarget) {
+            this.__reopenFor = this.previousTarget;
+        }
+    }
     __onDocumentMouseDown(e) {
+        this.__reopenFor = null;
         if (this.popup.isOpened &&
             this.type === 'selection' &&
             e.target &&
@@ -192,6 +240,16 @@ export class inlinePopup extends Plugin {
         }
     }
     __onCloseAllPopups() {
+        const target = this.__reopenFor;
+        if (target) {
+            this.__reopenFor = null;
+            // After the popup's own `closeAllPopups` handler, as below
+            this.j.async.setTimeout(() => {
+                if (this.j.editor.contains(target)) {
+                    this.onClick(target);
+                }
+            }, 1);
+        }
         if (!this.__reopenSelectionPopup) {
             return;
         }
@@ -224,8 +282,13 @@ export class inlinePopup extends Plugin {
         }
         return { left, top, width: rect.width, height: rect.height };
     }
-    onSelectionStart() {
+    onSelectionStart(event) {
+        // A key held down moves the caret on every repeat, with one keyup
+        if (event === null || event === void 0 ? void 0 : event.repeat) {
+            this.__followCaret();
+        }
         this.snapRange = this.j.s.range.cloneRange();
+        this.__keyDownElement = this.__elementAt(this.snapRange.startContainer);
     }
     onSelectionEnd(e) {
         if (e &&
@@ -339,6 +402,12 @@ __decorate([
 __decorate([
     watch(':outsideClick')
 ], inlinePopup.prototype, "onOutsideClick", null);
+__decorate([
+    watch(':keyup')
+], inlinePopup.prototype, "onKeyUp", null);
+__decorate([
+    watch(':recalcPositionPopup')
+], inlinePopup.prototype, "onRecalcPositionPopup", null);
 __decorate([
     autobind
 ], inlinePopup.prototype, "__onDocumentMouseDown", null);

package/esm/plugins/mobile/mobile.js

@@ -78,9 +78,11 @@ function fitToButtons(list, editor) {
     return cleaned;
 }
 /**
- * The width that decides which breakpoint set the toolbar uses. A toolbar
- * rendered into an external container (`toolbar` set to an element or a
- * selector) lays out in that container, so its width is what matters there.
+ * The width that decides which breakpoint set the toolbar uses: the editor's
+ * own width, or its parent's while the editor has none yet (for example
+ * while hidden at init). A toolbar rendered into an external container
+ * (`toolbar` set to an element or a selector) lays out in that container, so
+ * its width is what matters there.
  */
 function adaptiveWidth(editor) {
     var _a;
@@ -91,7 +93,8 @@ function adaptiveWidth(editor) {
             return width;
         }
     }
-    return ((_a = editor.container.parentElement) !== null && _a !== void 0 ? _a : editor.container).offsetWidth;
+    return (editor.container.offsetWidth ||
+        ((_a = editor.container.parentElement) !== null && _a !== void 0 ? _a : editor.container).offsetWidth);
 }
 /**
  * Rebuild toolbar in depends on editor's width

package/esm/plugins/ordered-list/config.js

@@ -8,10 +8,19 @@ import { Icon } from "../../core/ui/icon.js";
 import { Config } from "../../config.js";
 import olIcon from "./icons/ol.svg.js";
 import ulIcon from "./icons/ul.svg.js";
+import { closestOrderedList, openStartDialog } from "./start-dialog.js";
+/**
+ * The `ol` dropdown item that asks for the list's start number
+ */
+const START = 'start';
 const memoExec = (jodit, _, { control }) => {
     var _a;
     const key = `button${control.command}`;
     const value = (_a = (control.args && control.args[0])) !== null && _a !== void 0 ? _a : dataBind(jodit, key);
+    if (value === START) {
+        openStartDialog(jodit);
+        return;
+    }
     dataBind(jodit, key, value);
     jodit.execCommand(control.command, false, value === 'default' ? null : value);
 };
@@ -38,7 +47,9 @@ Config.prototype.controls.ol = {
         'lower-greek': 'Lower Greek',
         'lower-roman': 'Lower Roman',
         'upper-alpha': 'Upper Alpha',
-        'upper-roman': 'Upper Roman'
+        'upper-roman': 'Upper Roman',
+        [START]: 'Start at...'
     },
-    exec: memoExec
+    exec: memoExec,
+    isChildDisabled: (jodit, button) => { var _a; return ((_a = button.control.args) === null || _a === void 0 ? void 0 : _a[0]) === START && !closestOrderedList(jodit); }
 };

package/esm/plugins/ordered-list/start-dialog.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * 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/ordered-list
+ */
+import type { IJodit, Nullable } from "../../types/index";
+/**
+ * The numbered list the selection is in
+ */
+export declare function closestOrderedList(jodit: IJodit): Nullable<HTMLOListElement>;
+/**
+ * Asks for the number of the first item of the list the selection is in,
+ * and sets the list's `start`. The selection is put back when the dialog
+ * closes, however it closes.
+ */
+export declare function openStartDialog(jodit: IJodit): void;

package/esm/plugins/ordered-list/start-dialog.js

@@ -0,0 +1,58 @@
+/*!
+ * 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 { Dom } from "../../core/dom/dom.js";
+import { attr } from "../../core/helpers/utils/attr.js";
+import { Button } from "../../core/ui/button/index.js";
+import { UIBlock, UIForm, UIInput } from "../../core/ui/form/index.js";
+/**
+ * The numbered list the selection is in
+ */
+export function closestOrderedList(jodit) {
+    const current = jodit.s.current();
+    return current ? Dom.closest(current, 'ol', jodit.editor) : null;
+}
+/**
+ * Asks for the number of the first item of the list the selection is in,
+ * and sets the list's `start`. The selection is put back when the dialog
+ * closes, however it closes.
+ */
+export function openStartDialog(jodit) {
+    const list = closestOrderedList(jodit);
+    if (!list) {
+        return;
+    }
+    const dialog = jodit.dlg({ resizable: false, closeOnClickOverlay: true });
+    const input = new UIInput(jodit, {
+        name: 'start',
+        type: 'number',
+        label: 'Number for the first item',
+        value: list.start
+    });
+    const form = new UIForm(jodit, [new UIBlock(jodit, [input])]);
+    form.container.classList.add('jodit-dialog_alert');
+    form.onSubmit(({ start }) => {
+        const value = start === '' ? 1 : parseInt(start, 10);
+        if (isNaN(value)) {
+            input.focus();
+            return false;
+        }
+        dialog.close();
+        attr(list, 'start', value === 1 ? null : value);
+        jodit.synchronizeValues();
+    });
+    jodit.s.save();
+    dialog.e.on(dialog, 'afterClose', () => {
+        jodit.s.focus();
+        jodit.s.restore();
+    });
+    dialog.setFooter([
+        Button(jodit, 'cancel', 'Cancel').onAction(() => dialog.close()),
+        Button(jodit, 'ok', 'Apply', 'primary').onAction(() => form.submit())
+    ]);
+    dialog.open(form, jodit.i18n('Start numbering at'), true, true);
+    input.focus();
+    input.nativeInput.select();
+}