jodit 4.18.4 → 4.18.6

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/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();
+}

package/esm/plugins/placeholder/placeholder.js

@@ -33,6 +33,10 @@ export function isEditorEmpty(root) {
         return true;
     }
     const first = root.firstChild;
+    // Firefox pads an empty editable body with a bare <br>
+    if (Dom.isTag(first, 'br') && !Dom.next(first, Boolean, root)) {
+        return true;
+    }
     if (INSEPARABLE_TAGS.has((_a = first.nodeName) === null || _a === void 0 ? void 0 : _a.toLowerCase()) ||
         /^(TABLE)$/i.test(first.nodeName)) {
         return false;
@@ -69,7 +73,7 @@ export class placeholder extends Plugin {
                 .on('changePlace.placeholder', this.addNativeListeners)
                 .on('change.placeholder focus.placeholder keyup.placeholder mouseup.placeholder keydown.placeholder ' +
                 'mousedown.placeholder afterSetMode.placeholder changePlace.placeholder ' +
-                'internalChange.placeholder afterCommand.placeholder', this.toggle)
+                'internalChange.placeholder afterCommand.placeholder resize.placeholder', this.toggle)
                 .on(window, 'load', this.toggle);
             this.addNativeListeners();
             this.toggle();
@@ -115,12 +119,14 @@ export class placeholder extends Plugin {
             marginTop = parseInt(style2.getPropertyValue('margin-top'), 10);
             marginLeft = parseInt(style2.getPropertyValue('margin-left'), 10);
             css(this.placeholderElm, {
+                fontFamily: style2.getPropertyValue('font-family'),
                 fontSize: parseInt(style2.getPropertyValue('font-size'), 10),
                 lineHeight: style2.getPropertyValue('line-height')
             });
         }
         else {
             css(this.placeholderElm, {
+                fontFamily: style.getPropertyValue('font-family'),
                 fontSize: parseInt(style.getPropertyValue('font-size'), 10),
                 lineHeight: style.getPropertyValue('line-height')
             });

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

@@ -46,6 +46,16 @@ export declare class resizer extends Plugin {
     private pointerX;
     private pointerY;
     private onResize;
+    private __keyDownRange;
+    private __keyDownTable;
+    private onEditorKeyDown;
+    private __caretTable;
+    /**
+     * Hide the frame once a key has moved the caret off its element, and
+     * frame a table the caret has moved into, as clicks do
+     */
+    protected onEditorKeyUp(): void;
+    private __followCaret;
     private isAltMode;
     private onKeyDown;
     private onKeyUp;

package/esm/plugins/resizer/resizer.js

@@ -17,10 +17,13 @@ import * as consts from "../../core/constants.js";
 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 { eventEmitter, getContainer, pluginSystem } from "../../core/global.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 { isMoved } from "../../core/selection/helpers/index.js";
+import { UIElement } from "../../core/ui/index.js";
+import { Popup } from "../../core/ui/popup/index.js";
 import "./config.js";
 const keyBInd = '__jodit-resizer_binded';
 /**
@@ -45,6 +48,17 @@ function heightFollowsWidth(element) {
         !attr(element, 'height') &&
         !cssInline(element, 'height'));
 }
+const IFRAME_WRAPPER = '[data-jodit_iframe_wrapper]';
+/**
+ * A click on an embed lands on its wrapper, so it selects the embed, until the
+ * wrapper is active. While the editor is locked, as during resizing, the
+ * wrapper takes the mouse again.
+ */
+const EMBED_WRAPPER_STYLE = `${IFRAME_WRAPPER}{position:relative;display:block;user-select:none}` +
+    `${IFRAME_WRAPPER} iframe{position:relative}` +
+    `${IFRAME_WRAPPER}::after{position:absolute;z-index:1;display:block;background:transparent;content:'';cursor:pointer;inset:0}` +
+    `${IFRAME_WRAPPER}[data-jodit-wrapper_active=true] iframe{z-index:2}` +
+    `.jodit_lock ${IFRAME_WRAPPER}[data-jodit-wrapper_active=true] iframe{z-index:1}`;
 /**
  * The module creates a supporting frame for resizing of the elements img and table
  */
@@ -72,6 +86,8 @@ export class resizer extends Plugin {
         this.sizeViewer = this.rect.getElementsByTagName('span')[0];
         this.pointerX = 0;
         this.pointerY = 0;
+        this.__keyDownRange = null;
+        this.__keyDownTable = null;
         this.isAltMode = false;
         this.onClickElement = (element) => {
             if (this.isResizeMode) {
@@ -123,6 +139,9 @@ export class resizer extends Plugin {
     }
     /** @override */
     afterInit(editor) {
+        // It goes in the editing document, so iframe mode has it whatever `iframeStyle` holds
+        getContainer(editor, 'resizer', 'style', true).textContent =
+            EMBED_WRAPPER_STYLE;
         $$('div', this.rect).forEach((resizeHandle) => {
             editor.e.on(resizeHandle, 'mousedown.resizer touchstart.resizer', this.onStartResizing.bind(this, resizeHandle));
         });
@@ -134,6 +153,9 @@ export class resizer extends Plugin {
             }
         })
             .on('afterInit changePlace', this.addEventListeners.bind(this))
+            // Handlers without a namespace run first, ahead of those that
+            // move the caret, as table-keyboard-navigation's do
+            .on('keydown', this.onEditorKeyDown, { top: true })
             .on('afterGetValueFromEditor.resizer', (data) => {
             const rgx = /<jodit[^>]+data-jodit_iframe_wrapper[^>]+>(.*?<iframe[^>]*>.*?<\/iframe>.*?)<\/jodit>/gi;
             if (rgx.test(data.value)) {
@@ -308,6 +330,43 @@ export class resizer extends Plugin {
             e.stopImmediatePropagation();
         }
     }
+    onEditorKeyDown(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.__keyDownRange = this.j.s.range.cloneRange();
+        this.__keyDownTable = this.__caretTable();
+    }
+    __caretTable() {
+        return Dom.closest(this.j.s.range.startContainer, 'table', this.j.editor);
+    }
+    /**
+     * Hide the frame once a key has moved the caret off its element, and
+     * frame a table the caret has moved into, as clicks do
+     */
+    onEditorKeyUp() {
+        this.__followCaret();
+    }
+    __followCaret() {
+        const before = this.__keyDownRange;
+        this.__keyDownRange = null;
+        if (!isMoved(this.j, before)) {
+            return;
+        }
+        if (this.isShown &&
+            this.element &&
+            !this.j.s.range.intersectsNode(this.element)) {
+            this.hide();
+        }
+        const table = this.__caretTable();
+        if (table &&
+            table !== this.__keyDownTable &&
+            this.j.o.allowResizeTags.has('table')) {
+            this.__bind(table);
+            this.onClickElement(table);
+        }
+    }
     onKeyDown(e) {
         this.isAltMode = e.key === KEY_ALT;
         if (!this.isAltMode && this.isResizeMode) {
@@ -329,6 +388,12 @@ export class resizer extends Plugin {
             return;
         }
         if (!this.isResizeMode) {
+            // A click in the element's popup, or in a list it opens, works on
+            // the element, so it keeps its frame
+            if ((e === null || e === void 0 ? void 0 : e.target) &&
+                UIElement.closestElement(e.target, Popup)) {
+                return;
+            }
             return this.hide();
         }
         e.stopImmediatePropagation();
@@ -512,7 +577,10 @@ export class resizer extends Plugin {
         this.hide();
         Dom.safeRemove(this.layer);
         eventEmitter.off('hideHelpers', this.hide);
-        jodit.e.off(this.j.ow, '.resizer').off('.resizer');
+        jodit.e
+            .off(this.j.ow, '.resizer')
+            .off('.resizer')
+            .off('keydown', this.onEditorKeyDown);
     }
 }
 __decorate([
@@ -530,6 +598,12 @@ __decorate([
 __decorate([
     autobind
 ], resizer.prototype, "onResize", null);
+__decorate([
+    autobind
+], resizer.prototype, "onEditorKeyDown", null);
+__decorate([
+    watch(':keyup')
+], resizer.prototype, "onEditorKeyUp", null);
 __decorate([
     autobind
 ], resizer.prototype, "onKeyDown", null);

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

@@ -18,6 +18,29 @@ export declare class selectCells extends Plugin {
      */
     private get __tableModule();
     protected afterInit(jodit: IJodit): void;
+    /**
+     * The cell with the caret, and the selection, when a key went down
+     */
+    private __keyDownCell;
+    private __keyDownRange;
+    private __onKeyDown;
+    /**
+     * A link's popup replaces the cell's while the caret is in the link
+     */
+    private __keyDownInLink;
+    private __isInLink;
+    /**
+     * Where the selection starts rather than `s.current()`, which finds the
+     * first cell when the caret is just before the table
+     */
+    private __caretCell;
+    /**
+     * A key that moves the caret into a cell, from another cell or from
+     * outside the table, marks that cell and opens its popup, as a click on
+     * it does. One that moves the caret out of the table unmarks the cells
+     */
+    protected onKeyUp(): void;
+    private __followCaret;
     /**
      * First selected cell
      */

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

@@ -19,6 +19,7 @@ import { Dom } from "../../core/dom/dom.js";
 import { pluginSystem } from "../../core/global.js";
 import { $$, alignElement, position, toArray } from "../../core/helpers/index.js";
 import { Plugin } from "../../core/plugin/index.js";
+import { isMoved } from "../../core/selection/helpers/index.js";
 import { Table } from "../../modules/table/table.js";
 import "./config.js";
 const key = 'table_processor_observer';
@@ -26,6 +27,15 @@ const MOUSE_MOVE_LABEL = 'onMoveTableSelectCell';
 export class selectCells extends Plugin {
     constructor() {
         super(...arguments);
+        /**
+         * The cell with the caret, and the selection, when a key went down
+         */
+        this.__keyDownCell = null;
+        this.__keyDownRange = null;
+        /**
+         * A link's popup replaces the cell's while the caret is in the link
+         */
+        this.__keyDownInLink = false;
         /**
          * First selected cell
          */
@@ -46,6 +56,9 @@ export class selectCells extends Plugin {
             return;
         }
         jodit.e
+            // Handlers without a namespace run first, ahead of those that
+            // move the caret, as table-keyboard-navigation's do
+            .on('keydown', this.__onKeyDown, { top: true })
             .on('keydown.select-cells', (event) => {
             if (event.key === KEY_TAB) {
                 this.unselectCells();
@@ -76,6 +89,61 @@ export class selectCells extends Plugin {
             }
         });
     }
+    __onKeyDown(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.__keyDownCell = this.__caretCell();
+        this.__keyDownRange = this.j.s.range.cloneRange();
+        this.__keyDownInLink = this.__isInLink();
+    }
+    __isInLink() {
+        return Boolean(Dom.closest(this.j.s.range.startContainer, 'a', this.j.editor));
+    }
+    /**
+     * Where the selection starts rather than `s.current()`, which finds the
+     * first cell when the caret is just before the table
+     */
+    __caretCell() {
+        return Dom.closest(this.j.s.range.startContainer, Dom.isCell, this.j.editor);
+    }
+    /**
+     * A key that moves the caret into a cell, from another cell or from
+     * outside the table, marks that cell and opens its popup, as a click on
+     * it does. One that moves the caret out of the table unmarks the cells
+     */
+    onKeyUp() {
+        this.__followCaret();
+    }
+    __followCaret() {
+        const before = this.__keyDownRange;
+        this.__keyDownRange = null;
+        if (this.j.o.readonly || !isMoved(this.j, before)) {
+            return;
+        }
+        const cell = this.__caretCell();
+        const hasLeftLink = this.__keyDownInLink && !this.__isInLink();
+        if (cell === this.__keyDownCell && !(cell && hasLeftLink)) {
+            return;
+        }
+        const hadMarked = this.__tableModule.getAllSelectedCells().length > 0;
+        this.unselectCells();
+        if (!cell) {
+            if (hadMarked) {
+                this.j.e.fire('hidePopup', 'cells');
+            }
+            return;
+        }
+        const table = Dom.closest(cell, 'table', this.j.editor);
+        if (!table) {
+            return;
+        }
+        // As after a click, the first change to the cell keeps the mark
+        this.__selectedCell = cell;
+        this.__tableModule.addSelection(cell);
+        this.j.e.fire('showPopup', table, () => position(cell, this.j), 'cells');
+    }
     /**
      * Mouse click inside the table
      */
@@ -418,10 +486,16 @@ export class selectCells extends Plugin {
     /** @override */
     beforeDestruct(jodit) {
         this.__onRemoveSelection();
-        jodit.e.off('.select-cells');
+        jodit.e.off('.select-cells').off('keydown', this.__onKeyDown);
     }
 }
 selectCells.requires = ['select'];
+__decorate([
+    autobind
+], selectCells.prototype, "__onKeyDown", null);
+__decorate([
+    watch(':keyup')
+], selectCells.prototype, "onKeyUp", null);
 __decorate([
     autobind
 ], selectCells.prototype, "onStartSelection", null);

package/esm/plugins/table-keyboard-navigation/table-keyboard-navigation.js

@@ -36,7 +36,9 @@ export function tableKeyboardNavigation(editor) {
             case consts.KEY_TAB:
             case consts.KEY_LEFT: {
                 next = getNextCell();
-                if (!next) {
+                // Left in the first cell leaves the table, as Up in the
+                // top row does
+                if (!next && key === consts.KEY_TAB) {
                     tableModule.appendRow(table, !isPrev
                         ? false
                         : Dom.first(table, node => Dom.isTag(node, 'tr')), !isPrev);
@@ -65,7 +67,6 @@ export function tableKeyboardNavigation(editor) {
         if (!next) {
             return;
         }
-        editor.e.fire('hidePopup hideResizer');
         if (!next.firstChild) {
             const first = editor.createInside.element('br');
             Dom.append(next, first);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jodit",
-	"version": "4.18.4",
+	"version": "4.18.6",
 	"description": "Jodit is an awesome and useful wysiwyg editor with filebrowser",
 	"main": "esm/index.js",
 	"types": "types/index.d.ts",

package/types/config.d.ts

@@ -1404,6 +1404,9 @@ interface 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/types/core/helpers/html/word-lists.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * 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
+ */
+/**
+ * A Word list paragraph, read before its `mso-list` style is lost
+ */
+export interface WordListItem {
+    paragraph: HTMLElement;
+    list: string;
+    level: number;
+    tag: 'ul' | 'ol';
+    listStyleType: string | null;
+    start: number;
+}
+/**
+ * Finds Word's list paragraphs (`<p style="mso-list:l0 level1 lfo1">`), reads
+ * their list, level and type from the `mso-list:Ignore` marker, and removes the
+ * marker. Call it before anything strips the `mso-list` styles, then pass the
+ * result to {@link wrapWordListItems}
+ */
+export declare function readWordListItems(root: HTMLElement): WordListItem[];
+/**
+ * Turns the paragraphs found by {@link readWordListItems} into `<ul>`/`<ol>`
+ * lists, nesting them by level. Each paragraph becomes an `<li>` without Word's
+ * hanging indent
+ */
+export declare function wrapWordListItems(items: WordListItem[]): void;

package/types/core/selection/helpers/index.d.ts

@@ -4,6 +4,7 @@
  * Copyright (c) 2013-2026 Valerii Chupurnov. All rights reserved. https://xdsoft.net
  */
 export * from "./composed-ranges";
+export * from "./is-moved";
 export * from "./move-node-inside-start";
 export * from "./move-the-node-along-the-edge-outward";
 /**

package/types/core/selection/helpers/is-moved.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * 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 selection
+ */
+import type { IJodit, Nullable } from "../../../types/index";
+/**
+ * Whether the selection, `before` as it was when a key went down, has since
+ * moved to somewhere else in the editor
+ * @private
+ */
+export declare function isMoved(jodit: IJodit, before: Nullable<Range>): boolean;

package/types/langs/ar.d.ts

@@ -220,5 +220,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;