@ckeditor/ckeditor5-paragraph 40.0.0 → 40.1.0

package/LICENSE.md

@@ -2,7 +2,7 @@ Software License Agreement
 ==========================
 
 **CKEditor&nbsp;5 paragraph feature** – https://github.com/ckeditor/ckeditor5-paragraph <br>
-Copyright (c) 2003-2023, [CKSource Holding sp. z o.o.](https://cksource.com) All rights reserved.
+Copyright (c) 2003–2023, [CKSource Holding sp. z o.o.](https://cksource.com) All rights reserved.
 
 Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html).
 
@@ -14,4 +14,4 @@ Where not otherwise indicated, all CKEditor content is authored by CKSource engi
 Trademarks
 ----------
 
-**CKEditor** is a trademark of [CKSource Holding sp. z o.o.](https://cksource.com) All other brand and product names are trademarks, registered trademarks or service marks of their respective holders.
+**CKEditor** is a trademark of [CKSource Holding sp. z o.o.](https://cksource.com) All other brand and product names are trademarks, registered trademarks, or service marks of their respective holders.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-paragraph",
-  "version": "40.0.0",
+  "version": "40.1.0",
   "description": "Paragraph feature for CKEditor 5.",
   "keywords": [
     "ckeditor",
@@ -12,9 +12,9 @@
   ],
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-core": "40.0.0",
-    "@ckeditor/ckeditor5-ui": "40.0.0",
-    "@ckeditor/ckeditor5-utils": "40.0.0"
+    "@ckeditor/ckeditor5-core": "40.1.0",
+    "@ckeditor/ckeditor5-ui": "40.1.0",
+    "@ckeditor/ckeditor5-utils": "40.1.0"
   },
   "author": "CKSource (http://cksource.com/)",
   "license": "GPL-2.0-or-later",

package/src/augmentation.d.ts

@@ -1,14 +1,14 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import type { Paragraph, ParagraphCommand, InsertParagraphCommand } from './index';
-declare module '@ckeditor/ckeditor5-core' {
-    interface CommandsMap {
-        insertParagraph: InsertParagraphCommand;
-        paragraph: ParagraphCommand;
-    }
-    interface PluginsMap {
-        [Paragraph.pluginName]: Paragraph;
-    }
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type { Paragraph, ParagraphCommand, InsertParagraphCommand } from './index';
+declare module '@ckeditor/ckeditor5-core' {
+    interface CommandsMap {
+        insertParagraph: InsertParagraphCommand;
+        paragraph: ParagraphCommand;
+    }
+    interface PluginsMap {
+        [Paragraph.pluginName]: Paragraph;
+    }
+}

package/src/augmentation.js

@@ -1,5 +1,5 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-export {};
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+export {};

package/src/index.d.ts

@@ -1,12 +1,12 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph
- */
-export { default as Paragraph } from './paragraph';
-export { default as ParagraphButtonUI } from './paragraphbuttonui';
-export type { default as ParagraphCommand } from './paragraphcommand';
-export type { default as InsertParagraphCommand } from './insertparagraphcommand';
-import './augmentation';
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph
+ */
+export { default as Paragraph } from './paragraph';
+export { default as ParagraphButtonUI } from './paragraphbuttonui';
+export type { default as ParagraphCommand } from './paragraphcommand';
+export type { default as InsertParagraphCommand } from './insertparagraphcommand';
+import './augmentation';

package/src/index.js

@@ -1,10 +1,10 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph
- */
-export { default as Paragraph } from './paragraph';
-export { default as ParagraphButtonUI } from './paragraphbuttonui';
-import './augmentation';
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph
+ */
+export { default as Paragraph } from './paragraph';
+export { default as ParagraphButtonUI } from './paragraphbuttonui';
+import './augmentation';

package/src/insertparagraphcommand.d.ts

@@ -1,45 +1,45 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/insertparagraphcommand
- */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
-import type { Position } from '@ckeditor/ckeditor5-engine';
-/**
- * The insert paragraph command. It inserts a new paragraph at a specific
- * {@link module:engine/model/position~Position document position}.
- *
- * ```ts
- * // Insert a new paragraph before an element in the document.
- * editor.execute( 'insertParagraph', {
- *   position: editor.model.createPositionBefore( element )
- * } );
- * ```
- *
- * If a paragraph is disallowed in the context of the specific position, the command
- * will attempt to split position ancestors to find a place where it is possible
- * to insert a paragraph.
- *
- * **Note**: This command moves the selection to the inserted paragraph.
- */
-export default class InsertParagraphCommand extends Command {
-    constructor(editor: Editor);
-    /**
-     * Executes the command.
-     *
-     * @param options Options for the executed command.
-     * @param options.position The model position at which the new paragraph will be inserted.
-     * @param options.attributes Attributes keys and values to set on a inserted paragraph.
-     * @fires execute
-     */
-    execute(options: {
-        position: Position;
-        attributes: Record<string, unknown>;
-    }): void;
-    /**
-     * Returns the best position to insert a new paragraph.
-     */
-    private _findPositionToInsertParagraph;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/insertparagraphcommand
+ */
+import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import type { Position } from '@ckeditor/ckeditor5-engine';
+/**
+ * The insert paragraph command. It inserts a new paragraph at a specific
+ * {@link module:engine/model/position~Position document position}.
+ *
+ * ```ts
+ * // Insert a new paragraph before an element in the document.
+ * editor.execute( 'insertParagraph', {
+ *   position: editor.model.createPositionBefore( element )
+ * } );
+ * ```
+ *
+ * If a paragraph is disallowed in the context of the specific position, the command
+ * will attempt to split position ancestors to find a place where it is possible
+ * to insert a paragraph.
+ *
+ * **Note**: This command moves the selection to the inserted paragraph.
+ */
+export default class InsertParagraphCommand extends Command {
+    constructor(editor: Editor);
+    /**
+     * Executes the command.
+     *
+     * @param options Options for the executed command.
+     * @param options.position The model position at which the new paragraph will be inserted.
+     * @param options.attributes Attributes keys and values to set on a inserted paragraph.
+     * @fires execute
+     */
+    execute(options: {
+        position: Position;
+        attributes?: Record<string, unknown>;
+    }): void;
+    /**
+     * Returns the best position to insert a new paragraph.
+     */
+    private _findPositionToInsertParagraph;
+}

package/src/insertparagraphcommand.js

@@ -1,90 +1,90 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/insertparagraphcommand
- */
-import { Command } from '@ckeditor/ckeditor5-core';
-/**
- * The insert paragraph command. It inserts a new paragraph at a specific
- * {@link module:engine/model/position~Position document position}.
- *
- * ```ts
- * // Insert a new paragraph before an element in the document.
- * editor.execute( 'insertParagraph', {
- *   position: editor.model.createPositionBefore( element )
- * } );
- * ```
- *
- * If a paragraph is disallowed in the context of the specific position, the command
- * will attempt to split position ancestors to find a place where it is possible
- * to insert a paragraph.
- *
- * **Note**: This command moves the selection to the inserted paragraph.
- */
-export default class InsertParagraphCommand extends Command {
-    constructor(editor) {
-        super(editor);
-        // Since this command passes position in execution block instead of selection, it should be checked directly.
-        this._isEnabledBasedOnSelection = false;
-    }
-    /**
-     * Executes the command.
-     *
-     * @param options Options for the executed command.
-     * @param options.position The model position at which the new paragraph will be inserted.
-     * @param options.attributes Attributes keys and values to set on a inserted paragraph.
-     * @fires execute
-     */
-    execute(options) {
-        const model = this.editor.model;
-        const attributes = options.attributes;
-        let position = options.position;
-        // Don't execute command if position is in non-editable place.
-        if (!model.canEditAt(position)) {
-            return;
-        }
-        model.change(writer => {
-            position = this._findPositionToInsertParagraph(position, writer);
-            if (!position) {
-                return;
-            }
-            const paragraph = writer.createElement('paragraph');
-            if (attributes) {
-                model.schema.setAllowedAttributes(paragraph, attributes, writer);
-            }
-            model.insertContent(paragraph, position);
-            writer.setSelection(paragraph, 'in');
-        });
-    }
-    /**
-     * Returns the best position to insert a new paragraph.
-     */
-    _findPositionToInsertParagraph(position, writer) {
-        const model = this.editor.model;
-        if (model.schema.checkChild(position, 'paragraph')) {
-            return position;
-        }
-        const allowedParent = model.schema.findAllowedParent(position, 'paragraph');
-        // It could be there's no ancestor limit that would allow paragraph.
-        // In theory, "paragraph" could be disallowed even in the "$root".
-        if (!allowedParent) {
-            return null;
-        }
-        const positionParent = position.parent;
-        const isTextAllowed = model.schema.checkChild(positionParent, '$text');
-        // At empty $block or at the end of $block.
-        // <paragraph>[]</paragraph> ---> <paragraph></paragraph><paragraph>[]</paragraph>
-        // <paragraph>foo[]</paragraph> ---> <paragraph>foo</paragraph><paragraph>[]</paragraph>
-        if (positionParent.isEmpty || isTextAllowed && position.isAtEnd) {
-            return model.createPositionAfter(positionParent);
-        }
-        // At the start of $block with text.
-        // <paragraph>[]foo</paragraph> ---> <paragraph>[]</paragraph><paragraph>foo</paragraph>
-        if (!positionParent.isEmpty && isTextAllowed && position.isAtStart) {
-            return model.createPositionBefore(positionParent);
-        }
-        return writer.split(position, allowedParent).position;
-    }
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/insertparagraphcommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+/**
+ * The insert paragraph command. It inserts a new paragraph at a specific
+ * {@link module:engine/model/position~Position document position}.
+ *
+ * ```ts
+ * // Insert a new paragraph before an element in the document.
+ * editor.execute( 'insertParagraph', {
+ *   position: editor.model.createPositionBefore( element )
+ * } );
+ * ```
+ *
+ * If a paragraph is disallowed in the context of the specific position, the command
+ * will attempt to split position ancestors to find a place where it is possible
+ * to insert a paragraph.
+ *
+ * **Note**: This command moves the selection to the inserted paragraph.
+ */
+export default class InsertParagraphCommand extends Command {
+    constructor(editor) {
+        super(editor);
+        // Since this command passes position in execution block instead of selection, it should be checked directly.
+        this._isEnabledBasedOnSelection = false;
+    }
+    /**
+     * Executes the command.
+     *
+     * @param options Options for the executed command.
+     * @param options.position The model position at which the new paragraph will be inserted.
+     * @param options.attributes Attributes keys and values to set on a inserted paragraph.
+     * @fires execute
+     */
+    execute(options) {
+        const model = this.editor.model;
+        const attributes = options.attributes;
+        let position = options.position;
+        // Don't execute command if position is in non-editable place.
+        if (!model.canEditAt(position)) {
+            return;
+        }
+        model.change(writer => {
+            position = this._findPositionToInsertParagraph(position, writer);
+            if (!position) {
+                return;
+            }
+            const paragraph = writer.createElement('paragraph');
+            if (attributes) {
+                model.schema.setAllowedAttributes(paragraph, attributes, writer);
+            }
+            model.insertContent(paragraph, position);
+            writer.setSelection(paragraph, 'in');
+        });
+    }
+    /**
+     * Returns the best position to insert a new paragraph.
+     */
+    _findPositionToInsertParagraph(position, writer) {
+        const model = this.editor.model;
+        if (model.schema.checkChild(position, 'paragraph')) {
+            return position;
+        }
+        const allowedParent = model.schema.findAllowedParent(position, 'paragraph');
+        // It could be there's no ancestor limit that would allow paragraph.
+        // In theory, "paragraph" could be disallowed even in the "$root".
+        if (!allowedParent) {
+            return null;
+        }
+        const positionParent = position.parent;
+        const isTextAllowed = model.schema.checkChild(positionParent, '$text');
+        // At empty $block or at the end of $block.
+        // <paragraph>[]</paragraph> ---> <paragraph></paragraph><paragraph>[]</paragraph>
+        // <paragraph>foo[]</paragraph> ---> <paragraph>foo</paragraph><paragraph>[]</paragraph>
+        if (positionParent.isEmpty || isTextAllowed && position.isAtEnd) {
+            return model.createPositionAfter(positionParent);
+        }
+        // At the start of $block with text.
+        // <paragraph>[]foo</paragraph> ---> <paragraph>[]</paragraph><paragraph>foo</paragraph>
+        if (!positionParent.isEmpty && isTextAllowed && position.isAtStart) {
+            return model.createPositionBefore(positionParent);
+        }
+        return writer.split(position, allowedParent).position;
+    }
+}

package/src/paragraph.d.ts

@@ -1,61 +1,61 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-/**
- * The paragraph feature for the editor.
- *
- * It introduces the `<paragraph>` element in the model which renders as a `<p>` element in the DOM and data.
- *
- * It also brings two editors commands:
- *
- * * The {@link module:paragraph/paragraphcommand~ParagraphCommand `'paragraph'`} command that converts all
- * blocks in the model selection into paragraphs.
- * * The {@link module:paragraph/insertparagraphcommand~InsertParagraphCommand `'insertParagraph'`} command
- * that inserts a new paragraph at a specified location in the model.
- */
-export default class Paragraph extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName(): "Paragraph";
-    /**
-     * @inheritDoc
-     */
-    init(): void;
-    /**
-     * A list of element names which should be treated by the autoparagraphing algorithms as
-     * paragraph-like. This means that e.g. the following content:
-     *
-     * ```html
-     * <h1>Foo</h1>
-     * <table>
-     *   <tr>
-     *     <td>X</td>
-     *     <td>
-     *       <ul>
-     *         <li>Y</li>
-     *         <li>Z</li>
-     *       </ul>
-     *     </td>
-     *   </tr>
-     * </table>
-     * ```
-     *
-     * contains five paragraph-like elements: `<h1>`, two `<td>`s and two `<li>`s.
-     * Hence, if none of the features is going to convert those elements the above content will be automatically handled
-     * by the paragraph feature and converted to:
-     *
-     * ```html
-     * <p>Foo</p>
-     * <p>X</p>
-     * <p>Y</p>
-     * <p>Z</p>
-     * ```
-     *
-     * Note: The `<td>` containing two `<li>` elements was ignored as the innermost paragraph-like elements
-     * have a priority upon conversion.
-     */
-    static paragraphLikeElements: Set<string>;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * The paragraph feature for the editor.
+ *
+ * It introduces the `<paragraph>` element in the model which renders as a `<p>` element in the DOM and data.
+ *
+ * It also brings two editors commands:
+ *
+ * * The {@link module:paragraph/paragraphcommand~ParagraphCommand `'paragraph'`} command that converts all
+ * blocks in the model selection into paragraphs.
+ * * The {@link module:paragraph/insertparagraphcommand~InsertParagraphCommand `'insertParagraph'`} command
+ * that inserts a new paragraph at a specified location in the model.
+ */
+export default class Paragraph extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "Paragraph";
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * A list of element names which should be treated by the autoparagraphing algorithms as
+     * paragraph-like. This means that e.g. the following content:
+     *
+     * ```html
+     * <h1>Foo</h1>
+     * <table>
+     *   <tr>
+     *     <td>X</td>
+     *     <td>
+     *       <ul>
+     *         <li>Y</li>
+     *         <li>Z</li>
+     *       </ul>
+     *     </td>
+     *   </tr>
+     * </table>
+     * ```
+     *
+     * contains five paragraph-like elements: `<h1>`, two `<td>`s and two `<li>`s.
+     * Hence, if none of the features is going to convert those elements the above content will be automatically handled
+     * by the paragraph feature and converted to:
+     *
+     * ```html
+     * <p>Foo</p>
+     * <p>X</p>
+     * <p>Y</p>
+     * <p>Z</p>
+     * ```
+     *
+     * Note: The `<td>` containing two `<li>` elements was ignored as the innermost paragraph-like elements
+     * have a priority upon conversion.
+     */
+    static paragraphLikeElements: Set<string>;
+}

package/src/paragraph.js

@@ -1,106 +1,106 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/paragraph
- */
-import ParagraphCommand from './paragraphcommand';
-import InsertParagraphCommand from './insertparagraphcommand';
-import { Plugin } from '@ckeditor/ckeditor5-core';
-/**
- * The paragraph feature for the editor.
- *
- * It introduces the `<paragraph>` element in the model which renders as a `<p>` element in the DOM and data.
- *
- * It also brings two editors commands:
- *
- * * The {@link module:paragraph/paragraphcommand~ParagraphCommand `'paragraph'`} command that converts all
- * blocks in the model selection into paragraphs.
- * * The {@link module:paragraph/insertparagraphcommand~InsertParagraphCommand `'insertParagraph'`} command
- * that inserts a new paragraph at a specified location in the model.
- */
-export default class Paragraph extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'Paragraph';
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const model = editor.model;
-        editor.commands.add('paragraph', new ParagraphCommand(editor));
-        editor.commands.add('insertParagraph', new InsertParagraphCommand(editor));
-        // Schema.
-        model.schema.register('paragraph', { inheritAllFrom: '$block' });
-        editor.conversion.elementToElement({ model: 'paragraph', view: 'p' });
-        // Conversion for paragraph-like elements which has not been converted by any plugin.
-        editor.conversion.for('upcast').elementToElement({
-            model: (viewElement, { writer }) => {
-                if (!Paragraph.paragraphLikeElements.has(viewElement.name)) {
-                    return null;
-                }
-                // Do not auto-paragraph empty elements.
-                if (viewElement.isEmpty) {
-                    return null;
-                }
-                return writer.createElement('paragraph');
-            },
-            view: /.+/,
-            converterPriority: 'low'
-        });
-    }
-}
-/**
- * A list of element names which should be treated by the autoparagraphing algorithms as
- * paragraph-like. This means that e.g. the following content:
- *
- * ```html
- * <h1>Foo</h1>
- * <table>
- *   <tr>
- *     <td>X</td>
- *     <td>
- *       <ul>
- *         <li>Y</li>
- *         <li>Z</li>
- *       </ul>
- *     </td>
- *   </tr>
- * </table>
- * ```
- *
- * contains five paragraph-like elements: `<h1>`, two `<td>`s and two `<li>`s.
- * Hence, if none of the features is going to convert those elements the above content will be automatically handled
- * by the paragraph feature and converted to:
- *
- * ```html
- * <p>Foo</p>
- * <p>X</p>
- * <p>Y</p>
- * <p>Z</p>
- * ```
- *
- * Note: The `<td>` containing two `<li>` elements was ignored as the innermost paragraph-like elements
- * have a priority upon conversion.
- */
-Paragraph.paragraphLikeElements = new Set([
-    'blockquote',
-    'dd',
-    'div',
-    'dt',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'li',
-    'p',
-    'td',
-    'th'
-]);
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/paragraph
+ */
+import ParagraphCommand from './paragraphcommand';
+import InsertParagraphCommand from './insertparagraphcommand';
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * The paragraph feature for the editor.
+ *
+ * It introduces the `<paragraph>` element in the model which renders as a `<p>` element in the DOM and data.
+ *
+ * It also brings two editors commands:
+ *
+ * * The {@link module:paragraph/paragraphcommand~ParagraphCommand `'paragraph'`} command that converts all
+ * blocks in the model selection into paragraphs.
+ * * The {@link module:paragraph/insertparagraphcommand~InsertParagraphCommand `'insertParagraph'`} command
+ * that inserts a new paragraph at a specified location in the model.
+ */
+export default class Paragraph extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'Paragraph';
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        const model = editor.model;
+        editor.commands.add('paragraph', new ParagraphCommand(editor));
+        editor.commands.add('insertParagraph', new InsertParagraphCommand(editor));
+        // Schema.
+        model.schema.register('paragraph', { inheritAllFrom: '$block' });
+        editor.conversion.elementToElement({ model: 'paragraph', view: 'p' });
+        // Conversion for paragraph-like elements which has not been converted by any plugin.
+        editor.conversion.for('upcast').elementToElement({
+            model: (viewElement, { writer }) => {
+                if (!Paragraph.paragraphLikeElements.has(viewElement.name)) {
+                    return null;
+                }
+                // Do not auto-paragraph empty elements.
+                if (viewElement.isEmpty) {
+                    return null;
+                }
+                return writer.createElement('paragraph');
+            },
+            view: /.+/,
+            converterPriority: 'low'
+        });
+    }
+}
+/**
+ * A list of element names which should be treated by the autoparagraphing algorithms as
+ * paragraph-like. This means that e.g. the following content:
+ *
+ * ```html
+ * <h1>Foo</h1>
+ * <table>
+ *   <tr>
+ *     <td>X</td>
+ *     <td>
+ *       <ul>
+ *         <li>Y</li>
+ *         <li>Z</li>
+ *       </ul>
+ *     </td>
+ *   </tr>
+ * </table>
+ * ```
+ *
+ * contains five paragraph-like elements: `<h1>`, two `<td>`s and two `<li>`s.
+ * Hence, if none of the features is going to convert those elements the above content will be automatically handled
+ * by the paragraph feature and converted to:
+ *
+ * ```html
+ * <p>Foo</p>
+ * <p>X</p>
+ * <p>Y</p>
+ * <p>Z</p>
+ * ```
+ *
+ * Note: The `<td>` containing two `<li>` elements was ignored as the innermost paragraph-like elements
+ * have a priority upon conversion.
+ */
+Paragraph.paragraphLikeElements = new Set([
+    'blockquote',
+    'dd',
+    'div',
+    'dt',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'li',
+    'p',
+    'td',
+    'th'
+]);

package/src/paragraphbuttonui.d.ts

@@ -1,36 +1,36 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/paragraphbuttonui
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import Paragraph from './paragraph';
-/**
- * This plugin defines the `'paragraph'` button. It can be used together with
- * {@link module:heading/headingbuttonsui~HeadingButtonsUI} to replace the standard heading dropdown.
- *
- * This plugin is not loaded automatically by the {@link module:paragraph/paragraph~Paragraph} plugin. It must
- * be added manually.
- *
- * ```ts
- * ClassicEditor
- *   .create( {
- *     plugins: [ ..., Heading, Paragraph, HeadingButtonsUI, ParagraphButtonUI ]
- *     toolbar: [ 'paragraph', 'heading1', 'heading2', 'heading3' ]
- *   } )
- *   .then( ... )
- *   .catch( ... );
- * ```
- */
-export default class ParagraphButtonUI extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires(): readonly [typeof Paragraph];
-    /**
-     * @inheritDoc
-     */
-    init(): void;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/paragraphbuttonui
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import Paragraph from './paragraph';
+/**
+ * This plugin defines the `'paragraph'` button. It can be used together with
+ * {@link module:heading/headingbuttonsui~HeadingButtonsUI} to replace the standard heading dropdown.
+ *
+ * This plugin is not loaded automatically by the {@link module:paragraph/paragraph~Paragraph} plugin. It must
+ * be added manually.
+ *
+ * ```ts
+ * ClassicEditor
+ *   .create( {
+ *     plugins: [ ..., Heading, Paragraph, HeadingButtonsUI, ParagraphButtonUI ]
+ *     toolbar: [ 'paragraph', 'heading1', 'heading2', 'heading3' ]
+ *   } )
+ *   .then( ... )
+ *   .catch( ... );
+ * ```
+ */
+export default class ParagraphButtonUI extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof Paragraph];
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}

package/src/paragraphbuttonui.js

@@ -1,57 +1,57 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/paragraphbuttonui
- */
-import { Plugin, icons } from '@ckeditor/ckeditor5-core';
-import { ButtonView } from '@ckeditor/ckeditor5-ui';
-import Paragraph from './paragraph';
-const icon = icons.paragraph;
-/**
- * This plugin defines the `'paragraph'` button. It can be used together with
- * {@link module:heading/headingbuttonsui~HeadingButtonsUI} to replace the standard heading dropdown.
- *
- * This plugin is not loaded automatically by the {@link module:paragraph/paragraph~Paragraph} plugin. It must
- * be added manually.
- *
- * ```ts
- * ClassicEditor
- *   .create( {
- *     plugins: [ ..., Heading, Paragraph, HeadingButtonsUI, ParagraphButtonUI ]
- *     toolbar: [ 'paragraph', 'heading1', 'heading2', 'heading3' ]
- *   } )
- *   .then( ... )
- *   .catch( ... );
- * ```
- */
-export default class ParagraphButtonUI extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [Paragraph];
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const t = editor.t;
-        editor.ui.componentFactory.add('paragraph', locale => {
-            const view = new ButtonView(locale);
-            const command = editor.commands.get('paragraph');
-            view.label = t('Paragraph');
-            view.icon = icon;
-            view.tooltip = true;
-            view.isToggleable = true;
-            view.bind('isEnabled').to(command);
-            view.bind('isOn').to(command, 'value');
-            view.on('execute', () => {
-                editor.execute('paragraph');
-            });
-            return view;
-        });
-    }
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/paragraphbuttonui
+ */
+import { Plugin, icons } from '@ckeditor/ckeditor5-core';
+import { ButtonView } from '@ckeditor/ckeditor5-ui';
+import Paragraph from './paragraph';
+const icon = icons.paragraph;
+/**
+ * This plugin defines the `'paragraph'` button. It can be used together with
+ * {@link module:heading/headingbuttonsui~HeadingButtonsUI} to replace the standard heading dropdown.
+ *
+ * This plugin is not loaded automatically by the {@link module:paragraph/paragraph~Paragraph} plugin. It must
+ * be added manually.
+ *
+ * ```ts
+ * ClassicEditor
+ *   .create( {
+ *     plugins: [ ..., Heading, Paragraph, HeadingButtonsUI, ParagraphButtonUI ]
+ *     toolbar: [ 'paragraph', 'heading1', 'heading2', 'heading3' ]
+ *   } )
+ *   .then( ... )
+ *   .catch( ... );
+ * ```
+ */
+export default class ParagraphButtonUI extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [Paragraph];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        const t = editor.t;
+        editor.ui.componentFactory.add('paragraph', locale => {
+            const view = new ButtonView(locale);
+            const command = editor.commands.get('paragraph');
+            view.label = t('Paragraph');
+            view.icon = icon;
+            view.tooltip = true;
+            view.isToggleable = true;
+            view.bind('isEnabled').to(command);
+            view.bind('isOn').to(command, 'value');
+            view.on('execute', () => {
+                editor.execute('paragraph');
+            });
+            return view;
+        });
+    }
+}

package/src/paragraphcommand.d.ts

@@ -1,38 +1,38 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/paragraphcommand
- */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
-import type { Selection, DocumentSelection } from '@ckeditor/ckeditor5-engine';
-/**
- * The paragraph command.
- */
-export default class ParagraphCommand extends Command {
-    constructor(editor: Editor);
-    /**
-     * The value of the command. Indicates whether the selection start is placed in a paragraph.
-     *
-     * @readonly
-     * @observable
-     */
-    value: boolean;
-    /**
-     * @inheritDoc
-     */
-    refresh(): void;
-    /**
-     * Executes the command. All the blocks (see {@link module:engine/model/schema~Schema}) in the selection
-     * will be turned to paragraphs.
-     *
-     * @fires execute
-     * @param options Options for the executed command.
-     * @param options.selection The selection that the command should be applied to. By default,
-     * if not provided, the command is applied to the {@link module:engine/model/document~Document#selection}.
-     */
-    execute(options?: {
-        selection?: Selection | DocumentSelection;
-    }): void;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/paragraphcommand
+ */
+import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import type { Selection, DocumentSelection } from '@ckeditor/ckeditor5-engine';
+/**
+ * The paragraph command.
+ */
+export default class ParagraphCommand extends Command {
+    constructor(editor: Editor);
+    /**
+     * The value of the command. Indicates whether the selection start is placed in a paragraph.
+     *
+     * @readonly
+     * @observable
+     */
+    value: boolean;
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Executes the command. All the blocks (see {@link module:engine/model/schema~Schema}) in the selection
+     * will be turned to paragraphs.
+     *
+     * @fires execute
+     * @param options Options for the executed command.
+     * @param options.selection The selection that the command should be applied to. By default,
+     * if not provided, the command is applied to the {@link module:engine/model/document~Document#selection}.
+     */
+    execute(options?: {
+        selection?: Selection | DocumentSelection;
+    }): void;
+}

package/src/paragraphcommand.js

@@ -1,64 +1,64 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module paragraph/paragraphcommand
- */
-import { Command } from '@ckeditor/ckeditor5-core';
-import { first } from '@ckeditor/ckeditor5-utils';
-/**
- * The paragraph command.
- */
-export default class ParagraphCommand extends Command {
-    constructor(editor) {
-        super(editor);
-        // Since this command may pass selection in execution block, it should be checked directly.
-        this._isEnabledBasedOnSelection = false;
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const model = this.editor.model;
-        const document = model.document;
-        const block = first(document.selection.getSelectedBlocks());
-        this.value = !!block && block.is('element', 'paragraph');
-        this.isEnabled = !!block && checkCanBecomeParagraph(block, model.schema);
-    }
-    /**
-     * Executes the command. All the blocks (see {@link module:engine/model/schema~Schema}) in the selection
-     * will be turned to paragraphs.
-     *
-     * @fires execute
-     * @param options Options for the executed command.
-     * @param options.selection The selection that the command should be applied to. By default,
-     * if not provided, the command is applied to the {@link module:engine/model/document~Document#selection}.
-     */
-    execute(options = {}) {
-        const model = this.editor.model;
-        const document = model.document;
-        const selection = options.selection || document.selection;
-        // Don't execute command if selection is in non-editable place.
-        if (!model.canEditAt(selection)) {
-            return;
-        }
-        model.change(writer => {
-            const blocks = selection.getSelectedBlocks();
-            for (const block of blocks) {
-                if (!block.is('element', 'paragraph') && checkCanBecomeParagraph(block, model.schema)) {
-                    writer.rename(block, 'paragraph');
-                }
-            }
-        });
-    }
-}
-/**
- * Checks whether the given block can be replaced by a paragraph.
- *
- * @param block A block to be tested.
- * @param schema The schema of the document.
- */
-function checkCanBecomeParagraph(block, schema) {
-    return schema.checkChild(block.parent, 'paragraph') && !schema.isObject(block);
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module paragraph/paragraphcommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+import { first } from '@ckeditor/ckeditor5-utils';
+/**
+ * The paragraph command.
+ */
+export default class ParagraphCommand extends Command {
+    constructor(editor) {
+        super(editor);
+        // Since this command may pass selection in execution block, it should be checked directly.
+        this._isEnabledBasedOnSelection = false;
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const model = this.editor.model;
+        const document = model.document;
+        const block = first(document.selection.getSelectedBlocks());
+        this.value = !!block && block.is('element', 'paragraph');
+        this.isEnabled = !!block && checkCanBecomeParagraph(block, model.schema);
+    }
+    /**
+     * Executes the command. All the blocks (see {@link module:engine/model/schema~Schema}) in the selection
+     * will be turned to paragraphs.
+     *
+     * @fires execute
+     * @param options Options for the executed command.
+     * @param options.selection The selection that the command should be applied to. By default,
+     * if not provided, the command is applied to the {@link module:engine/model/document~Document#selection}.
+     */
+    execute(options = {}) {
+        const model = this.editor.model;
+        const document = model.document;
+        const selection = options.selection || document.selection;
+        // Don't execute command if selection is in non-editable place.
+        if (!model.canEditAt(selection)) {
+            return;
+        }
+        model.change(writer => {
+            const blocks = selection.getSelectedBlocks();
+            for (const block of blocks) {
+                if (!block.is('element', 'paragraph') && checkCanBecomeParagraph(block, model.schema)) {
+                    writer.rename(block, 'paragraph');
+                }
+            }
+        });
+    }
+}
+/**
+ * Checks whether the given block can be replaced by a paragraph.
+ *
+ * @param block A block to be tested.
+ * @param schema The schema of the document.
+ */
+function checkCanBecomeParagraph(block, schema) {
+    return schema.checkChild(block.parent, 'paragraph') && !schema.isObject(block);
+}