jodit 4.12.22 → 4.12.24

package/esm/plugins/color/color.js

@@ -15,28 +15,28 @@ export function color(editor) {
         group: 'color'
     });
     const callback = (command, second, third) => {
+        var _a;
         const colorHEX = normalizeColor(third);
-        switch (command) {
-            case 'background':
-                editor.s.commitStyle({
-                    attributes: {
-                        style: {
-                            backgroundColor: !colorHEX
-                                ? ''
-                                : colorHEX
-                        }
-                    }
-                });
-                break;
-            case 'forecolor':
-                editor.s.commitStyle({
-                    attributes: {
-                        style: {
-                            color: !colorHEX ? '' : colorHEX
-                        }
-                    }
-                });
-                break;
+        const value = !colorHEX ? '' : colorHEX;
+        const style = command === 'background'
+            ? { backgroundColor: value }
+            : { color: value };
+        // Cells selected with the `select-cells` plugin drop or collapse the
+        // native range, so `commitStyle` would paint a pending caret format
+        // outside the table instead of the selection the user sees. Apply the
+        // style to the content of every selected cell instead. See #1250
+        const selectedCells = editor
+            .getInstance('Table', editor.o)
+            .getAllSelectedCells();
+        if (selectedCells.length && editor.s.isCollapsed()) {
+            selectedCells.forEach(cell => {
+                editor.s.select(cell, true);
+                editor.s.commitStyle({ attributes: { style } });
+            });
+            (_a = editor.s.sel) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+        }
+        else {
+            editor.s.commitStyle({ attributes: { style } });
         }
         editor.synchronizeValues();
         return false;

package/esm/plugins/font/config.js

@@ -117,5 +117,24 @@ Config.prototype.controls.font = {
                 .replace(/[^a-z0-9-]+/g, ',');
         }
     },
+    // When no font is explicitly set, the computed font-family equals the
+    // editor's own default (e.g. `-apple-system, …`). Return '' so the
+    // button shows the `Default` list entry instead of that raw stack.
+    // See #1370
+    value: (editor) => {
+        const current = editor.s.current();
+        if (!current) {
+            return;
+        }
+        const box = Dom.closest(current, Dom.isElement, editor.editor);
+        if (!box) {
+            return;
+        }
+        const value = css(box, 'font-family').toString();
+        if (value === css(editor.editor, 'font-family').toString()) {
+            return '';
+        }
+        return value;
+    },
     tooltip: 'Font family'
 };

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

@@ -50,6 +50,13 @@ export declare class inlinePopup extends Plugin {
     private __reopenSelectionPopup;
     private __onDocumentMouseDown;
     private __onCloseAllPopups;
+    /**
+     * The selection rect comes from the editor document — in iframe mode its
+     * coordinates are iframe-local, while the popup lives in the host
+     * document, so the iframe offset must be added. See
+     * https://github.com/xdan/jodit/issues/1058
+     */
+    private __selectionBound;
     private snapRange;
     private onSelectionStart;
     private onSelectionEnd;

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

@@ -176,10 +176,26 @@ export class inlinePopup extends Plugin {
         this.j.async.setTimeout(() => {
             const sel = this.j.s.sel;
             if (sel && !sel.isCollapsed) {
-                this.showPopup(() => this.j.s.range.getBoundingClientRect(), 'selection');
+                this.showPopup(() => this.__selectionBound(), 'selection');
             }
         }, 1);
     }
+    /**
+     * The selection rect comes from the editor document — in iframe mode its
+     * coordinates are iframe-local, while the popup lives in the host
+     * document, so the iframe offset must be added. See
+     * https://github.com/xdan/jodit/issues/1058
+     */
+    __selectionBound() {
+        const rect = this.j.s.range.getBoundingClientRect();
+        let { left, top } = rect;
+        if (this.j.iframe) {
+            const offset = position(this.j.iframe, this.j, true);
+            left += offset.left;
+            top += offset.top;
+        }
+        return { left, top, width: rect.width, height: rect.height };
+    }
     onSelectionStart() {
         this.snapRange = this.j.s.range.cloneRange();
     }
@@ -219,7 +235,7 @@ export class inlinePopup extends Plugin {
         if (!node) {
             return;
         }
-        this.showPopup(() => range.getBoundingClientRect(), type);
+        this.showPopup(() => this.__selectionBound(), type);
     }
     /**
      * In not collapsed selection - only one image

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

@@ -39,6 +39,12 @@ declare module 'jodit/config' {
              * Default value for the `Open in new tab` checkbox when inserting a new link.
              */
             openInNewTabCheckboxDefaultChecked: boolean;
+            /**
+             * Show an `aria-label` text input in the link dialog so an
+             * accessible name can be set on the `<a>` (useful when several
+             * links share the same visible text, e.g. "here"). Default: false.
+             */
+            ariaLabelInput: boolean;
             /**
              * Use an input text to ask the classname or a select or not ask
              */

package/esm/plugins/link/config.js

@@ -17,6 +17,7 @@ Config.prototype.link = {
     noFollowCheckbox: true,
     openInNewTabCheckbox: true,
     openInNewTabCheckboxDefaultChecked: false,
+    ariaLabelInput: false,
     modeClassName: 'input',
     selectMultipleClassName: true,
     preventReadOnlyNavigation: true,

package/esm/plugins/link/link.js

@@ -121,7 +121,7 @@ export class link extends Plugin {
         const currentElement = current;
         const isImageContent = Dom.isImage(currentElement);
         let { content_input } = elements;
-        const { className_input } = elements, { className_select } = elements;
+        const { className_input } = elements, { className_select } = elements, { aria_label_input } = elements;
         if (!content_input) {
             content_input = jodit.c.element('input', {
                 type: 'hidden',
@@ -147,6 +147,9 @@ export class link extends Plugin {
         if (!isImageContent && current) {
             content_input.value = getSelectionText();
         }
+        if (aria_label_input) {
+            aria_label_input.value = link ? attr(link, 'aria-label') || '' : '';
+        }
         if (link) {
             url_input.value = attr(link, 'href') || '';
             if (modeClassName) {
@@ -237,6 +240,10 @@ export class link extends Plugin {
                     }
                     attr(a, 'rel', relParts.length ? relParts.join(' ') : null);
                 }
+                if (aria_label_input) {
+                    const ariaLabel = aria_label_input.value.trim();
+                    attr(a, 'aria-label', ariaLabel || null);
+                }
                 jodit.e.fire('applyLink', jodit, a, form);
             });
             jodit.synchronizeValues();

package/esm/plugins/link/template.js

@@ -6,7 +6,7 @@
 import { UIButton } from "../../core/ui/button/index.js";
 import { UIBlock, UICheckbox, UIForm, UIInput, UISelect } from "../../core/ui/form/index.js";
 export const formTemplate = (editor) => {
-    const { openInNewTabCheckbox, noFollowCheckbox, modeClassName, selectSizeClassName, selectMultipleClassName, selectOptionsClassName } = editor.o.link;
+    const { openInNewTabCheckbox, noFollowCheckbox, ariaLabelInput, modeClassName, selectSizeClassName, selectMultipleClassName, selectOptionsClassName } = editor.o.link;
     return new UIForm(editor, [
         new UIBlock(editor, [
             new UIInput(editor, {
@@ -18,6 +18,15 @@ export const formTemplate = (editor) => {
                 required: true
             })
         ]),
+        ariaLabelInput
+            ? new UIBlock(editor, [
+                new UIInput(editor, {
+                    name: 'ariaLabel',
+                    ref: 'aria_label_input',
+                    label: 'Aria label'
+                })
+            ])
+            : null,
         new UIBlock(editor, [
             new UIInput(editor, {
                 name: 'content',

package/esm/plugins/paste/config.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 { CLIPBOARD_ID, INSERT_AS_HTML, INSERT_AS_TEXT, INSERT_ONLY_TEXT, IS_PROD, TEXT_PLAIN } from "../../core/constants.js";
+import { CLIPBOARD_ID, INSERT_AS_HTML, INSERT_AS_TEXT, INSERT_ONLY_TEXT, IS_PROD, TEXT_HTML, TEXT_PLAIN } from "../../core/constants.js";
 import { Config } from "../../config.js";
 import { pasteInsertHtml } from "./helpers.js";
 Config.prototype.askBeforePasteHTML = true;
@@ -21,6 +21,7 @@ const psKey = 'pasteStorage';
 Config.prototype.controls.paste = {
     tooltip: 'Paste from clipboard',
     async exec(editor, _, { control }) {
+        var _a;
         if (control.name === psKey) {
             editor.execCommand('showPasteStorage');
             return;
@@ -31,7 +32,15 @@ Config.prototype.controls.paste = {
             try {
                 const items = await navigator.clipboard.read();
                 if (items && items.length) {
-                    const textBlob = await items[0].getType(TEXT_PLAIN);
+                    const item = items[0];
+                    // Prefer the HTML flavor so the button behaves like the
+                    // Ctrl+V shortcut (which receives text/html from the
+                    // native paste event). See
+                    // https://github.com/xdan/jodit/issues/1061
+                    const type = ((_a = item.types) === null || _a === void 0 ? void 0 : _a.includes(TEXT_HTML))
+                        ? TEXT_HTML
+                        : TEXT_PLAIN;
+                    const textBlob = await item.getType(type);
                     text = await new Response(textBlob).text();
                 }
                 error = false;

package/esm/plugins/search/ui/search.js

@@ -101,20 +101,30 @@ let UISearch = class UISearch extends UIElement {
             .on(this.queryInput, 'input', () => {
             this.setMod('empty-query', !trim(this.queryInput.value).length);
         })
-            .on(this.queryInput, 'keydown', this.j.async.debounce(async (e) => {
-            switch (e.key) {
-                case consts.KEY_ENTER:
+            .on(this.queryInput, 'keydown', (() => {
+            const debounced = this.j.async.debounce(async (e) => {
+                switch (e.key) {
+                    case consts.KEY_ENTER:
+                        if (await jodit.e.fire('searchNext')) {
+                            this.close();
+                        }
+                        break;
+                    default:
+                        jodit.e.fire(this, 'needUpdateCounters');
+                        break;
+                }
+            }, this.j.defaultTimeout);
+            return (e) => {
+                // Must be canceled synchronously — inside the debounced
+                // handler the browser has already submitted the parent
+                // form. See https://github.com/xdan/jodit/issues/918
+                if (e.key === consts.KEY_ENTER) {
                     e.preventDefault();
                     e.stopImmediatePropagation();
-                    if (await jodit.e.fire('searchNext')) {
-                        this.close();
-                    }
-                    break;
-                default:
-                    jodit.e.fire(this, 'needUpdateCounters');
-                    break;
-            }
-        }, this.j.defaultTimeout));
+                }
+                debounced(e);
+            };
+        })());
     }
     onEditorKeyDown(e) {
         if (!this.isOpened) {

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

@@ -29,7 +29,7 @@ export declare class selectCells extends Plugin {
     /**
      * Mouse click inside the table
      */
-    protected onStartSelection(cell: HTMLTableCellElement): void | false;
+    protected onStartSelection(cell: HTMLTableCellElement, event?: MouseEvent): void | false;
     protected onOutsideClick(): void;
     protected onChange(): void;
     /**

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

@@ -79,15 +79,42 @@ export class selectCells extends Plugin {
     /**
      * Mouse click inside the table
      */
-    onStartSelection(cell) {
+    onStartSelection(cell, event) {
+        var _a;
         if (this.j.o.readonly) {
             return;
         }
+        const table = Dom.closest(cell, 'table', this.j.editor);
+        // Ctrl/Cmd + click toggles a single cell into the existing selection
+        // instead of resetting it — non-contiguous multi-cell selection.
+        // See https://github.com/xdan/jodit/issues/1163
+        if (((event === null || event === void 0 ? void 0 : event.ctrlKey) || (event === null || event === void 0 ? void 0 : event.metaKey)) &&
+            cell !== this.j.editor &&
+            table &&
+            Dom.isCell(cell)) {
+            if (this.__tableModule.getAllSelectedCells().includes(cell)) {
+                this.__tableModule.removeSelection(cell);
+            }
+            else {
+                if (!cell.firstChild) {
+                    cell.appendChild(this.j.createInside.element('br'));
+                }
+                this.__tableModule.addSelection(cell);
+            }
+            this.__selectedCell = cell;
+            (_a = this.j.s.sel) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+            if (this.__tableModule.getAllSelectedCells().length) {
+                this.j.e.fire('showPopup', table, () => position(cell, this.j), 'cells');
+            }
+            else {
+                this.j.e.fire('hidePopup', 'cells');
+            }
+            return false;
+        }
         this.unselectCells();
         if (cell === this.j.editor) {
             return;
         }
-        const table = Dom.closest(cell, 'table', this.j.editor);
         if (!cell || !table) {
             return;
         }
@@ -120,14 +147,16 @@ export class selectCells extends Plugin {
      * Mouse move inside the table
      */
     __onMove(table, e) {
-        var _a;
+        var _a, _b;
         if (this.j.o.readonly && !this.j.isLocked) {
             return;
         }
         if (this.j.isLockedNotBy(key)) {
             return;
         }
-        const node = this.j.ed.elementFromPoint(e.clientX, e.clientY);
+        // Inside Shadow DOM `document.elementFromPoint` returns the shadow
+        // host, so the lookup must start from the shadow root
+        const node = ((_a = this.j.o.shadowRoot) !== null && _a !== void 0 ? _a : this.j.ed).elementFromPoint(e.clientX, e.clientY);
         if (!node) {
             return;
         }
@@ -150,7 +179,7 @@ export class selectCells extends Plugin {
         }
         const cellsCount = this.__tableModule.getAllSelectedCells().length;
         if (cellsCount > 1) {
-            (_a = this.j.s.sel) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+            (_b = this.j.s.sel) === null || _b === void 0 ? void 0 : _b.removeAllRanges();
         }
         this.j.e.fire('hidePopup');
         e.stopPropagation();
@@ -184,13 +213,15 @@ export class selectCells extends Plugin {
      * Stop a selection process
      */
     __onStopSelection(table, e) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this.__selectedCell) {
             return;
         }
         this.__isSelectionMode = false;
         this.j.unlock();
-        const node = this.j.ed.elementFromPoint(e.clientX, e.clientY);
+        // Inside Shadow DOM `document.elementFromPoint` returns the shadow
+        // host, so the lookup must start from the shadow root
+        const node = ((_a = this.j.o.shadowRoot) !== null && _a !== void 0 ? _a : this.j.ed).elementFromPoint(e.clientX, e.clientY);
         if (!node) {
             return;
         }
@@ -206,7 +237,7 @@ export class selectCells extends Plugin {
             cell,
             this.__selectedCell
         ]), box = this.__tableModule.formalMatrix(table);
-        const max = (_a = box[bound[1][0]]) === null || _a === void 0 ? void 0 : _a[bound[1][1]], min = (_b = box[bound[0][0]]) === null || _b === void 0 ? void 0 : _b[bound[0][1]];
+        const max = (_b = box[bound[1][0]]) === null || _b === void 0 ? void 0 : _b[bound[1][1]], min = (_c = box[bound[0][0]]) === null || _c === void 0 ? void 0 : _c[bound[0][1]];
         // `getSelectedBound` keeps its `Infinity` sentinel when none of the
         // selected cells belong to this table's matrix — e.g. after a
         // drag-and-drop that moved/removed the cells, leaving a stale anchor and

package/esm/types/uploader.d.ts

@@ -80,6 +80,29 @@ export interface IUploaderOptions<T> {
     getDisplayName(this: T, baseurl: string, filename: string): string;
     pathVariableName: string;
     withCredentials: boolean;
+    /**
+     * Called with the list of files right before they are uploaded (or read as
+     * base64). Return `false` to abort the whole upload — useful for client
+     * side validation (size, type, count). Throwing an Error also aborts and
+     * routes the message through the uploader error handler.
+     *
+     * ```javascript
+     * Jodit.make('#editor', {
+     * 	uploader: {
+     * 		url: '...',
+     * 		beforeUpload(files) {
+     * 			for (const file of files) {
+     * 				if (file.size > 2 * 1024 * 1024) {
+     * 					this.jodit.message.error('Max 2MB');
+     * 					return false;
+     * 				}
+     * 			}
+     * 		}
+     * 	}
+     * });
+     * ```
+     */
+    beforeUpload?: (this: T, files: File[]) => boolean | void;
     prepareData: (this: T, formData: FormData) => any;
     buildData?: (this: T, formData: any) => BuildDataResult;
     queryBuild?: (obj: string | IDictionary<string | object> | FormData, prefix?: string) => string | FormData;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jodit",
-	"version": "4.12.22",
+	"version": "4.12.24",
 	"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

@@ -956,6 +956,21 @@ interface Config {
             backspaceWord: string[];
             backspaceSentence: string[];
         };
+        /**
+         * Disable specific Backspace/Delete cleanup cases by their stable
+         * key, so the plugin no longer applies that particular behavior.
+         * Available keys: `remove-unbreakable`, `remove-not-editable`,
+         * `remove-char`, `table-cell`, `remove-empty-parent`,
+         * `remove-empty-neighbor`, `join-two-lists`, `join-neighbors`,
+         * `unwrap-first-list-item`.
+         *
+         * ```javascript
+         * Jodit.make('#editor', {
+         * 	 delete: { disableCases: new Set(['remove-empty-parent']) }
+         * });
+         * ```
+         */
+        disableCases?: Set<string>;
     };
 }
 interface Config {
@@ -973,6 +988,15 @@ interface Config {
          * Remove empty elements
          */
         removeEmptyElements: boolean;
+        /**
+         * Return an empty string from `editor.value` (and the synced source
+         * element) when the editor holds only a single empty block — e.g.
+         * `<p><br></p>` left after the user deletes all the content.
+         * `contenteditable` keeps that caret container in the DOM, so by
+         * default the value getter returns it as-is; enable this to collapse
+         * it to `''` for form submission.
+         */
+        collapseEmptyValueToEmptyString: boolean;
         /**
          * Replace old tags to new eg. <i> to <em>, <b> to <strong>
          */
@@ -1371,6 +1395,12 @@ interface Config {
          * Default value for the `Open in new tab` checkbox when inserting a new link.
          */
         openInNewTabCheckboxDefaultChecked: boolean;
+        /**
+         * Show an `aria-label` text input in the link dialog so an
+         * accessible name can be set on the `<a>` (useful when several
+         * links share the same visible text, e.g. "here"). Default: false.
+         */
+        ariaLabelInput: boolean;
         /**
          * Use an input text to ask the classname or a select or not ask
          */

package/types/core/helpers/checker/is-html-from-word.d.ts

@@ -7,6 +7,6 @@
  * @module helpers/checker
  */
 /**
- * Detect if string is HTML from MS Word or Excel
+ * Detect if string is HTML from MS Word, Excel or LibreOffice/OpenOffice
  */
 export declare function isHtmlFromWord(data: string): boolean;

package/types/modules/toolbar/button/content.d.ts

@@ -15,6 +15,12 @@ export declare class ToolbarContent<T extends IViewBased = IViewBased> extends U
     className(): string;
     /** @override */
     update(): void;
+    /**
+     * The content is arbitrary HTML — propagate the disabled state to the
+     * nested form controls (e.g. the file input of the Upload button),
+     * otherwise they stay interactive.
+     */
+    protected onChangeDisabled(): void;
     /** @override */
     protected createContainer(): HTMLElement;
     constructor(jodit: T, control: IControlTypeContent, target?: Nullable<HTMLElement>);

package/types/plugins/backspace/cases/index.d.ts

@@ -3,9 +3,25 @@
  * 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 { checkRemoveChar } from "./check-remove-char";
-import { checkRemoveContentNotEditable } from "./check-remove-content-not-editable";
+/**
+ * @module plugins/backspace
+ */
+import type { IJodit } from "../../../types/index";
+import type { DeleteMode } from "../interface";
+type CaseFn = (jodit: IJodit, fakeNode: any, backspace: boolean, mode: DeleteMode) => void | boolean;
+/**
+ * Ordered delete/backspace cases with stable keys. The first one returning
+ * `true` wins. The keys are stable across minified builds (function names are
+ * mangled by terser) so they can be referenced by `delete.disableCases`.
+ * @private
+ */
+export declare const casesMap: ReadonlyArray<readonly [
+    string,
+    CaseFn
+]>;
 /**
  * @private
+ * @deprecated Use `casesMap` to also get the stable case keys.
  */
-export declare const cases: (typeof checkRemoveContentNotEditable | typeof checkRemoveChar)[];
+export declare const cases: CaseFn[];
+export {};

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

@@ -17,6 +17,21 @@ declare module 'jodit/config' {
                 backspaceWord: string[];
                 backspaceSentence: string[];
             };
+            /**
+             * Disable specific Backspace/Delete cleanup cases by their stable
+             * key, so the plugin no longer applies that particular behavior.
+             * Available keys: `remove-unbreakable`, `remove-not-editable`,
+             * `remove-char`, `table-cell`, `remove-empty-parent`,
+             * `remove-empty-neighbor`, `join-two-lists`, `join-neighbors`,
+             * `unwrap-first-list-item`.
+             *
+             * ```javascript
+             * Jodit.make('#editor', {
+             * 	 delete: { disableCases: new Set(['remove-empty-parent']) }
+             * });
+             * ```
+             */
+            disableCases?: Set<string>;
         };
     }
 }

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

@@ -34,6 +34,14 @@ export declare class cleanHtml extends Plugin {
     protected onBeforeSetNativeEditorValue(data: {
         value: string;
     }): boolean;
+    /**
+     * Collapse a value that holds only a single empty block (e.g.
+     * `<p><br></p>` left after deleting all content) to an empty string —
+     * opt-in via `cleanHTML.collapseEmptyValueToEmptyString`. See #1149
+     */
+    protected onAfterGetValueFromEditor(data: {
+        value: string;
+    }): void;
     protected onSafeHTML(sandBox: HTMLElement): void;
     /** @override */
     protected beforeDestruct(): void;

package/types/plugins/clean-html/config.d.ts

@@ -23,6 +23,15 @@ declare module 'jodit/config' {
              * Remove empty elements
              */
             removeEmptyElements: boolean;
+            /**
+             * Return an empty string from `editor.value` (and the synced source
+             * element) when the editor holds only a single empty block — e.g.
+             * `<p><br></p>` left after the user deletes all the content.
+             * `contenteditable` keeps that caret container in the DOM, so by
+             * default the value getter returns it as-is; enable this to collapse
+             * it to `''` for form submission.
+             */
+            collapseEmptyValueToEmptyString: boolean;
             /**
              * Replace old tags to new eg. <i> to <em>, <b> to <strong>
              */

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

@@ -50,6 +50,13 @@ export declare class inlinePopup extends Plugin {
     private __reopenSelectionPopup;
     private __onDocumentMouseDown;
     private __onCloseAllPopups;
+    /**
+     * The selection rect comes from the editor document — in iframe mode its
+     * coordinates are iframe-local, while the popup lives in the host
+     * document, so the iframe offset must be added. See
+     * https://github.com/xdan/jodit/issues/1058
+     */
+    private __selectionBound;
     private snapRange;
     private onSelectionStart;
     private onSelectionEnd;

package/types/plugins/link/config.d.ts

@@ -39,6 +39,12 @@ declare module 'jodit/config' {
              * Default value for the `Open in new tab` checkbox when inserting a new link.
              */
             openInNewTabCheckboxDefaultChecked: boolean;
+            /**
+             * Show an `aria-label` text input in the link dialog so an
+             * accessible name can be set on the `<a>` (useful when several
+             * links share the same visible text, e.g. "here"). Default: false.
+             */
+            ariaLabelInput: boolean;
             /**
              * Use an input text to ask the classname or a select or not ask
              */

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

@@ -29,7 +29,7 @@ export declare class selectCells extends Plugin {
     /**
      * Mouse click inside the table
      */
-    protected onStartSelection(cell: HTMLTableCellElement): void | false;
+    protected onStartSelection(cell: HTMLTableCellElement, event?: MouseEvent): void | false;
     protected onOutsideClick(): void;
     protected onChange(): void;
     /**