@ckeditor/ckeditor5-html-support 41.4.2 → 42.0.0-alpha.0

package/dist/index.js

@@ -1297,15 +1297,49 @@ var defaultConfig = {
     ]
 };
 
-class DataSchema extends Plugin {
-    /**
-     * @inheritDoc
-     */ static get pluginName() {
+/**
+ * Holds representation of the extended HTML document type definitions to be used by the
+ * editor in HTML support.
+ *
+ * Data schema is represented by data schema definitions.
+ *
+ * To add new definition for block element,
+ * use {@link module:html-support/dataschema~DataSchema#registerBlockElement} method:
+ *
+ * ```ts
+ * dataSchema.registerBlockElement( {
+ * 	view: 'section',
+ * 	model: 'my-section',
+ * 	modelSchema: {
+ * 		inheritAllFrom: '$block'
+ * 	}
+ * } );
+ * ```
+ *
+ * To add new definition for inline element,
+ * use {@link module:html-support/dataschema~DataSchema#registerInlineElement} method:
+ *
+ * ```
+ * dataSchema.registerInlineElement( {
+ * 	view: 'span',
+ * 	model: 'my-span',
+ * 	attributeProperties: {
+ * 		copyOnEnter: true
+ * 	}
+ * } );
+ * ```
+ */ class DataSchema extends Plugin {
+    /**
+	 * A map of registered data schema definitions.
+	 */ _definitions = [];
+    /**
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'DataSchema';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         for (const definition of defaultConfig.block){
             this.registerBlockElement(definition);
         }
@@ -1314,52 +1348,52 @@ class DataSchema extends Plugin {
         }
     }
     /**
-     * Add new data schema definition describing block element.
-     */ registerBlockElement(definition) {
+	 * Add new data schema definition describing block element.
+	 */ registerBlockElement(definition) {
         this._definitions.push({
             ...definition,
             isBlock: true
         });
     }
     /**
-     * Add new data schema definition describing inline element.
-     */ registerInlineElement(definition) {
+	 * Add new data schema definition describing inline element.
+	 */ registerInlineElement(definition) {
         this._definitions.push({
             ...definition,
             isInline: true
         });
     }
     /**
-     * Updates schema definition describing block element with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */ extendBlockElement(definition) {
+	 * Updates schema definition describing block element with new properties.
+	 *
+	 * Creates new scheme if it doesn't exist.
+	 * Array properties are concatenated with original values.
+	 *
+	 * @param definition Definition update.
+	 */ extendBlockElement(definition) {
         this._extendDefinition({
             ...definition,
             isBlock: true
         });
     }
     /**
-     * Updates schema definition describing inline element with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */ extendInlineElement(definition) {
+	 * Updates schema definition describing inline element with new properties.
+	 *
+	 * Creates new scheme if it doesn't exist.
+	 * Array properties are concatenated with original values.
+	 *
+	 * @param definition Definition update.
+	 */ extendInlineElement(definition) {
         this._extendDefinition({
             ...definition,
             isInline: true
         });
     }
     /**
-     * Returns all definitions matching the given view name.
-     *
-     * @param includeReferences Indicates if this method should also include definitions of referenced models.
-     */ getDefinitionsForView(viewName, includeReferences = false) {
+	 * Returns all definitions matching the given view name.
+	 *
+	 * @param includeReferences Indicates if this method should also include definitions of referenced models.
+	 */ getDefinitionsForView(viewName, includeReferences = false) {
         const definitions = new Set();
         for (const definition of this._getMatchingViewDefinitions(viewName)){
             if (includeReferences) {
@@ -1372,20 +1406,20 @@ class DataSchema extends Plugin {
         return definitions;
     }
     /**
-     * Returns definitions matching the given model name.
-     */ getDefinitionsForModel(modelName) {
+	 * Returns definitions matching the given model name.
+	 */ getDefinitionsForModel(modelName) {
         return this._definitions.filter((definition)=>definition.model == modelName);
     }
     /**
-     * Returns definitions matching the given view name.
-     */ _getMatchingViewDefinitions(viewName) {
+	 * Returns definitions matching the given view name.
+	 */ _getMatchingViewDefinitions(viewName) {
         return this._definitions.filter((def)=>def.view && testViewName(viewName, def.view));
     }
     /**
-     * Resolves all definition references registered for the given data schema definition.
-     *
-     * @param modelName Data schema model name.
-     */ *_getReferences(modelName) {
+	 * Resolves all definition references registered for the given data schema definition.
+	 *
+	 * @param modelName Data schema model name.
+	 */ *_getReferences(modelName) {
         const inheritProperties = [
             'inheritAllFrom',
             'inheritTypesFrom',
@@ -1412,13 +1446,13 @@ class DataSchema extends Plugin {
         }
     }
     /**
-     * Updates schema definition with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */ _extendDefinition(definition) {
+	 * Updates schema definition with new properties.
+	 *
+	 * Creates new scheme if it doesn't exist.
+	 * Array properties are concatenated with original values.
+	 *
+	 * @param definition Definition update.
+	 */ _extendDefinition(definition) {
         const currentDefinitions = Array.from(this._definitions.entries()).filter(([, currentDefinition])=>currentDefinition.model == definition.model);
         if (currentDefinitions.length == 0) {
             this._definitions.push(definition);
@@ -1430,12 +1464,6 @@ class DataSchema extends Plugin {
             });
         }
     }
-    constructor(){
-        super(...arguments);
-        /**
-         * A map of registered data schema definitions.
-         */ this._definitions = [];
-    }
 }
 /**
  * Test view name against the given pattern.
@@ -1449,27 +1477,97 @@ class DataSchema extends Plugin {
     return false;
 }
 
-class DataFilter extends Plugin {
+/**
+ * Allows to validate elements and element attributes registered by {@link module:html-support/dataschema~DataSchema}.
+ *
+ * To enable registered element in the editor, use {@link module:html-support/datafilter~DataFilter#allowElement} method:
+ *
+ * ```ts
+ * dataFilter.allowElement( 'section' );
+ * ```
+ *
+ * You can also allow or disallow specific element attributes:
+ *
+ * ```ts
+ * // Allow `data-foo` attribute on `section` element.
+ * dataFilter.allowAttributes( {
+ * 	name: 'section',
+ * 	attributes: {
+ * 		'data-foo': true
+ * 	}
+ * } );
+ *
+ * // Disallow `color` style attribute on 'section' element.
+ * dataFilter.disallowAttributes( {
+ * 	name: 'section',
+ * 	styles: {
+ * 		color: /[\s\S]+/
+ * 	}
+ * } );
+ * ```
+ *
+ * To apply the information about allowed and disallowed attributes in custom integration plugin,
+ * use the {@link module:html-support/datafilter~DataFilter#processViewAttributes `processViewAttributes()`} method.
+ */ class DataFilter extends Plugin {
+    /**
+	 * An instance of the {@link module:html-support/dataschema~DataSchema}.
+	 */ _dataSchema;
+    /**
+	 * {@link module:engine/view/matcher~Matcher Matcher} instance describing rules upon which
+	 * content attributes should be allowed.
+	 */ _allowedAttributes;
+    /**
+	 * {@link module:engine/view/matcher~Matcher Matcher} instance describing rules upon which
+	 * content attributes should be disallowed.
+	 */ _disallowedAttributes;
+    /**
+	 * Allowed element definitions by {@link module:html-support/datafilter~DataFilter#allowElement} method.
+	*/ _allowedElements;
+    /**
+	 * Disallowed element names by {@link module:html-support/datafilter~DataFilter#disallowElement} method.
+	 */ _disallowedElements;
+    /**
+	 * Indicates if {@link module:engine/controller/datacontroller~DataController editor's data controller}
+	 * data has been already initialized.
+	*/ _dataInitialized;
+    /**
+	 * Cached map of coupled attributes. Keys are the feature attributes names
+	 * and values are arrays with coupled GHS attributes names.
+	 */ _coupledAttributes;
+    constructor(editor){
+        super(editor);
+        this._dataSchema = editor.plugins.get('DataSchema');
+        this._allowedAttributes = new Matcher();
+        this._disallowedAttributes = new Matcher();
+        this._allowedElements = new Set();
+        this._disallowedElements = new Set();
+        this._dataInitialized = false;
+        this._coupledAttributes = null;
+        this._registerElementsAfterInit();
+        this._registerElementHandlers();
+        this._registerCoupledAttributesPostFixer();
+        this._registerAssociatedHtmlAttributesPostFixer();
+    }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'DataFilter';
     }
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataSchema,
             Widget
         ];
     }
     /**
-     * Load a configuration of one or many elements, where their attributes should be allowed.
-     *
-     * **Note**: Rules will be applied just before next data pipeline data init or set.
-     *
-     * @param config Configuration of elements that should have their attributes accepted in the editor.
-     */ loadAllowedConfig(config) {
+	 * Load a configuration of one or many elements, where their attributes should be allowed.
+	 *
+	 * **Note**: Rules will be applied just before next data pipeline data init or set.
+	 *
+	 * @param config Configuration of elements that should have their attributes accepted in the editor.
+	 */ loadAllowedConfig(config) {
         for (const pattern of config){
             // MatcherPattern allows omitting `name` to widen the search of elements.
             // Let's keep it consistent and match every element if a `name` has not been provided.
@@ -1480,12 +1578,12 @@ class DataFilter extends Plugin {
         }
     }
     /**
-     * Load a configuration of one or many elements, where their attributes should be disallowed.
-     *
-     * **Note**: Rules will be applied just before next data pipeline data init or set.
-     *
-     * @param config Configuration of elements that should have their attributes rejected from the editor.
-     */ loadDisallowedConfig(config) {
+	 * Load a configuration of one or many elements, where their attributes should be disallowed.
+	 *
+	 * **Note**: Rules will be applied just before next data pipeline data init or set.
+	 *
+	 * @param config Configuration of elements that should have their attributes rejected from the editor.
+	 */ loadDisallowedConfig(config) {
         for (const pattern of config){
             // MatcherPattern allows omitting `name` to widen the search of elements.
             // Let's keep it consistent and match every element if a `name` has not been provided.
@@ -1500,26 +1598,26 @@ class DataFilter extends Plugin {
         }
     }
     /**
-     * Load a configuration of one or many elements, where when empty should be allowed.
-     *
-     * **Note**: It modifies DataSchema so must be loaded before registering filtering rules.
-     *
-     * @param config Configuration of elements that should be preserved even if empty.
-     */ loadAllowedEmptyElementsConfig(config) {
+	 * Load a configuration of one or many elements, where when empty should be allowed.
+	 *
+	 * **Note**: It modifies DataSchema so must be loaded before registering filtering rules.
+	 *
+	 * @param config Configuration of elements that should be preserved even if empty.
+	 */ loadAllowedEmptyElementsConfig(config) {
         for (const elementName of config){
             this.allowEmptyElement(elementName);
         }
     }
     /**
-     * Allow the given element in the editor context.
-     *
-     * This method will only allow elements described by the {@link module:html-support/dataschema~DataSchema} used
-     * to create data filter.
-     *
-     * **Note**: Rules will be applied just before next data pipeline data init or set.
-     *
-     * @param viewName String or regular expression matching view name.
-     */ allowElement(viewName) {
+	 * Allow the given element in the editor context.
+	 *
+	 * This method will only allow elements described by the {@link module:html-support/dataschema~DataSchema} used
+	 * to create data filter.
+	 *
+	 * **Note**: Rules will be applied just before next data pipeline data init or set.
+	 *
+	 * @param viewName String or regular expression matching view name.
+	 */ allowElement(viewName) {
         for (const definition of this._dataSchema.getDefinitionsForView(viewName, true)){
             this._addAllowedElement(definition);
             // Reset cached map to recalculate it on the next usage.
@@ -1527,27 +1625,27 @@ class DataFilter extends Plugin {
         }
     }
     /**
-     * Disallow the given element in the editor context.
-     *
-     * This method will only disallow elements described by the {@link module:html-support/dataschema~DataSchema} used
-     * to create data filter.
-     *
-     * @param viewName String or regular expression matching view name.
-     */ disallowElement(viewName) {
+	 * Disallow the given element in the editor context.
+	 *
+	 * This method will only disallow elements described by the {@link module:html-support/dataschema~DataSchema} used
+	 * to create data filter.
+	 *
+	 * @param viewName String or regular expression matching view name.
+	 */ disallowElement(viewName) {
         for (const definition of this._dataSchema.getDefinitionsForView(viewName, false)){
             this._disallowedElements.add(definition.view);
         }
     }
     /**
-     * Allow the given empty element in the editor context.
-     *
-     * This method will only allow elements described by the {@link module:html-support/dataschema~DataSchema} used
-     * to create data filter.
-     *
-     * **Note**: It modifies DataSchema so must be called before registering filtering rules.
-     *
-     * @param viewName String or regular expression matching view name.
-     */ allowEmptyElement(viewName) {
+	 * Allow the given empty element in the editor context.
+	 *
+	 * This method will only allow elements described by the {@link module:html-support/dataschema~DataSchema} used
+	 * to create data filter.
+	 *
+	 * **Note**: It modifies DataSchema so must be called before registering filtering rules.
+	 *
+	 * @param viewName String or regular expression matching view name.
+	 */ allowEmptyElement(viewName) {
         for (const definition of this._dataSchema.getDefinitionsForView(viewName, true)){
             if (definition.isInline) {
                 this._dataSchema.extendInlineElement({
@@ -1558,44 +1656,44 @@ class DataFilter extends Plugin {
         }
     }
     /**
-     * Allow the given attributes for view element allowed by {@link #allowElement} method.
-     *
-     * @param config Pattern matching all attributes which should be allowed.
-     */ allowAttributes(config) {
+	 * Allow the given attributes for view element allowed by {@link #allowElement} method.
+	 *
+	 * @param config Pattern matching all attributes which should be allowed.
+	 */ allowAttributes(config) {
         this._allowedAttributes.add(config);
     }
     /**
-     * Disallow the given attributes for view element allowed by {@link #allowElement} method.
-     *
-     * @param config Pattern matching all attributes which should be disallowed.
-     */ disallowAttributes(config) {
+	 * Disallow the given attributes for view element allowed by {@link #allowElement} method.
+	 *
+	 * @param config Pattern matching all attributes which should be disallowed.
+	 */ disallowAttributes(config) {
         this._disallowedAttributes.add(config);
     }
     /**
-     * Processes all allowed and disallowed attributes on the view element by consuming them and returning the allowed ones.
-     *
-     * This method applies the configuration set up by {@link #allowAttributes `allowAttributes()`}
-     * and {@link #disallowAttributes `disallowAttributes()`} over the given view element by consuming relevant attributes.
-     * It returns the allowed attributes that were found on the given view element for further processing by integration code.
-     *
-     * ```ts
-     * dispatcher.on( 'element:myElement', ( evt, data, conversionApi ) => {
-     * 	// Get rid of disallowed and extract all allowed attributes from a viewElement.
-     * 	const viewAttributes = dataFilter.processViewAttributes( data.viewItem, conversionApi );
-     * 	// Do something with them, i.e. store inside a model as a dictionary.
-     * 	if ( viewAttributes ) {
-     * 		conversionApi.writer.setAttribute( 'htmlAttributesOfMyElement', viewAttributes, data.modelRange );
-     * 	}
-     * } );
-     * ```
-     *
-     * @see module:engine/conversion/viewconsumable~ViewConsumable#consume
-     *
-     * @returns Object with following properties:
-     * - attributes Set with matched attribute names.
-     * - styles Set with matched style names.
-     * - classes Set with matched class names.
-     */ processViewAttributes(viewElement, conversionApi) {
+	 * Processes all allowed and disallowed attributes on the view element by consuming them and returning the allowed ones.
+	 *
+	 * This method applies the configuration set up by {@link #allowAttributes `allowAttributes()`}
+	 * and {@link #disallowAttributes `disallowAttributes()`} over the given view element by consuming relevant attributes.
+	 * It returns the allowed attributes that were found on the given view element for further processing by integration code.
+	 *
+	 * ```ts
+	 * dispatcher.on( 'element:myElement', ( evt, data, conversionApi ) => {
+	 * 	// Get rid of disallowed and extract all allowed attributes from a viewElement.
+	 * 	const viewAttributes = dataFilter.processViewAttributes( data.viewItem, conversionApi );
+	 * 	// Do something with them, i.e. store inside a model as a dictionary.
+	 * 	if ( viewAttributes ) {
+	 * 		conversionApi.writer.setAttribute( 'htmlAttributesOfMyElement', viewAttributes, data.modelRange );
+	 * 	}
+	 * } );
+	 * ```
+	 *
+	 * @see module:engine/conversion/viewconsumable~ViewConsumable#consume
+	 *
+	 * @returns Object with following properties:
+	 * - attributes Set with matched attribute names.
+	 * - styles Set with matched style names.
+	 * - classes Set with matched class names.
+	 */ processViewAttributes(viewElement, conversionApi) {
         const { consumable } = conversionApi;
         // Make sure that the disabled attributes are handled before the allowed attributes are called.
         // For example, for block images the <figure> converter triggers conversion for <img> first and then for other elements, i.e. <a>.
@@ -1603,8 +1701,8 @@ class DataFilter extends Plugin {
         return prepareGHSAttribute(viewElement, matchAndConsumeAttributes(viewElement, this._allowedAttributes, consumable));
     }
     /**
-     * Adds allowed element definition and fires registration event.
-     */ _addAllowedElement(definition) {
+	 * Adds allowed element definition and fires registration event.
+	 */ _addAllowedElement(definition) {
         if (this._allowedElements.has(definition)) {
             return;
         }
@@ -1634,9 +1732,9 @@ class DataFilter extends Plugin {
         }
     }
     /**
-     * Registers elements allowed by {@link module:html-support/datafilter~DataFilter#allowElement} method
-     * once {@link module:engine/controller/datacontroller~DataController editor's data controller} is initialized.
-    */ _registerElementsAfterInit() {
+	 * Registers elements allowed by {@link module:html-support/datafilter~DataFilter#allowElement} method
+	 * once {@link module:engine/controller/datacontroller~DataController editor's data controller} is initialized.
+	*/ _registerElementsAfterInit() {
         this.editor.data.on('init', ()=>{
             this._dataInitialized = true;
             for (const definition of this._allowedElements){
@@ -1654,8 +1752,8 @@ class DataFilter extends Plugin {
         });
     }
     /**
-     * Registers default element handlers.
-     */ _registerElementHandlers() {
+	 * Registers default element handlers.
+	 */ _registerElementHandlers() {
         this.on('register', (evt, definition)=>{
             const schema = this.editor.model.schema;
             // Object element should be only registered for new features.
@@ -1669,12 +1767,12 @@ class DataFilter extends Plugin {
                 this._registerInlineElement(definition);
             } else {
                 /**
-                 * The definition cannot be handled by the data filter.
-                 *
-                 * Make sure that the registered definition is correct.
-                 *
-                 * @error data-filter-invalid-definition
-                 */ throw new CKEditorError('data-filter-invalid-definition', null, definition);
+				 * The definition cannot be handled by the data filter.
+				 *
+				 * Make sure that the registered definition is correct.
+				 *
+				 * @error data-filter-invalid-definition
+				 */ throw new CKEditorError('data-filter-invalid-definition', null, definition);
             }
             evt.stop();
         }, {
@@ -1682,30 +1780,30 @@ class DataFilter extends Plugin {
         });
     }
     /**
-     * Registers a model post-fixer that is removing coupled GHS attributes of inline elements. Those attributes
-     * are removed if a coupled feature attribute is removed.
-     *
-     * For example, consider following HTML:
-     *
-     * ```html
-     * <a href="foo.html" id="myId">bar</a>
-     * ```
-     *
-     * Which would be upcasted to following text node in the model:
-     *
-     * ```html
-     * <$text linkHref="foo.html" htmlA="{ attributes: { id: 'myId' } }">bar</$text>
-     * ```
-     *
-     * When the user removes the link from that text (using UI), only `linkHref` attribute would be removed:
-     *
-     * ```html
-     * <$text htmlA="{ attributes: { id: 'myId' } }">bar</$text>
-     * ```
-     *
-     * The `htmlA` attribute would stay in the model and would cause GHS to generate an `<a>` element.
-     * This is incorrect from UX point of view, as the user wanted to remove the whole link (not only `href`).
-     */ _registerCoupledAttributesPostFixer() {
+	 * Registers a model post-fixer that is removing coupled GHS attributes of inline elements. Those attributes
+	 * are removed if a coupled feature attribute is removed.
+	 *
+	 * For example, consider following HTML:
+	 *
+	 * ```html
+	 * <a href="foo.html" id="myId">bar</a>
+	 * ```
+	 *
+	 * Which would be upcasted to following text node in the model:
+	 *
+	 * ```html
+	 * <$text linkHref="foo.html" htmlA="{ attributes: { id: 'myId' } }">bar</$text>
+	 * ```
+	 *
+	 * When the user removes the link from that text (using UI), only `linkHref` attribute would be removed:
+	 *
+	 * ```html
+	 * <$text htmlA="{ attributes: { id: 'myId' } }">bar</$text>
+	 * ```
+	 *
+	 * The `htmlA` attribute would stay in the model and would cause GHS to generate an `<a>` element.
+	 * This is incorrect from UX point of view, as the user wanted to remove the whole link (not only `href`).
+	 */ _registerCoupledAttributesPostFixer() {
         const model = this.editor.model;
         const selection = model.document.selection;
         model.document.registerPostFixer((writer)=>{
@@ -1764,34 +1862,34 @@ class DataFilter extends Plugin {
         });
     }
     /**
-     * Removes `html*Attributes` attributes from incompatible elements.
-     *
-     * For example, consider the following HTML:
-     *
-     * ```html
-     * <heading2 htmlH2Attributes="...">foobar[]</heading2>
-     * ```
-     *
-     * Pressing `enter` creates a new `paragraph` element that inherits
-     * the `htmlH2Attributes` attribute from `heading2`.
-     *
-     * ```html
-     * <heading2 htmlH2Attributes="...">foobar</heading2>
-     * <paragraph htmlH2Attributes="...">[]</paragraph>
-     * ```
-     *
-     * This postfixer ensures that this doesn't happen, and that elements can
-     * only have `html*Attributes` associated with them,
-     * e.g.: `htmlPAttributes` for `<p>`, `htmlDivAttributes` for `<div>`, etc.
-     *
-     * With it enabled, pressing `enter` at the end of `<heading2>` will create
-     * a new paragraph without the `htmlH2Attributes` attribute.
-     *
-     * ```html
-     * <heading2 htmlH2Attributes="...">foobar</heading2>
-     * <paragraph>[]</paragraph>
-     * ```
-     */ _registerAssociatedHtmlAttributesPostFixer() {
+	 * Removes `html*Attributes` attributes from incompatible elements.
+	 *
+	 * For example, consider the following HTML:
+	 *
+	 * ```html
+	 * <heading2 htmlH2Attributes="...">foobar[]</heading2>
+	 * ```
+	 *
+	 * Pressing `enter` creates a new `paragraph` element that inherits
+	 * the `htmlH2Attributes` attribute from `heading2`.
+	 *
+	 * ```html
+	 * <heading2 htmlH2Attributes="...">foobar</heading2>
+	 * <paragraph htmlH2Attributes="...">[]</paragraph>
+	 * ```
+	 *
+	 * This postfixer ensures that this doesn't happen, and that elements can
+	 * only have `html*Attributes` associated with them,
+	 * e.g.: `htmlPAttributes` for `<p>`, `htmlDivAttributes` for `<div>`, etc.
+	 *
+	 * With it enabled, pressing `enter` at the end of `<heading2>` will create
+	 * a new paragraph without the `htmlH2Attributes` attribute.
+	 *
+	 * ```html
+	 * <heading2 htmlH2Attributes="...">foobar</heading2>
+	 * <paragraph>[]</paragraph>
+	 * ```
+	 */ _registerAssociatedHtmlAttributesPostFixer() {
         const model = this.editor.model;
         model.document.registerPostFixer((writer)=>{
             const changes = model.document.differ.getChanges();
@@ -1814,9 +1912,9 @@ class DataFilter extends Plugin {
         });
     }
     /**
-     * Collects the map of coupled attributes. The returned map is keyed by the feature attribute name
-     * and coupled GHS attribute names are stored in the value array.
-     */ _getCoupledAttributesMap() {
+	 * Collects the map of coupled attributes. The returned map is keyed by the feature attribute name
+	 * and coupled GHS attribute names are stored in the value array.
+	 */ _getCoupledAttributesMap() {
         if (this._coupledAttributes) {
             return this._coupledAttributes;
         }
@@ -1836,16 +1934,16 @@ class DataFilter extends Plugin {
         return this._coupledAttributes;
     }
     /**
-     * Fires `register` event for the given element definition.
-     */ _fireRegisterEvent(definition) {
+	 * Fires `register` event for the given element definition.
+	 */ _fireRegisterEvent(definition) {
         if (definition.view && this._disallowedElements.has(definition.view)) {
             return;
         }
         this.fire(definition.view ? `register:${definition.view}` : 'register', definition);
     }
     /**
-     * Registers object element and attribute converters for the given data schema definition.
-     */ _registerObjectElement(definition) {
+	 * Registers object element and attribute converters for the given data schema definition.
+	 */ _registerObjectElement(definition) {
         const editor = this.editor;
         const schema = editor.model.schema;
         const conversion = editor.conversion;
@@ -1892,8 +1990,8 @@ class DataFilter extends Plugin {
         conversion.for('dataDowncast').add(modelToViewBlockAttributeConverter(definition));
     }
     /**
-     * Registers block element and attribute converters for the given data schema definition.
-     */ _registerBlockElement(definition) {
+	 * Registers block element and attribute converters for the given data schema definition.
+	 */ _registerBlockElement(definition) {
         const editor = this.editor;
         const schema = editor.model.schema;
         const conversion = editor.conversion;
@@ -1926,10 +2024,10 @@ class DataFilter extends Plugin {
         conversion.for('downcast').add(modelToViewBlockAttributeConverter(definition));
     }
     /**
-     * Registers inline element and attribute converters for the given data schema definition.
-     *
-     * Extends `$text` model schema to allow the given definition model attribute and its properties.
-     */ _registerInlineElement(definition) {
+	 * Registers inline element and attribute converters for the given data schema definition.
+	 *
+	 * Extends `$text` model schema to allow the given definition model attribute and its properties.
+	 */ _registerInlineElement(definition) {
         const editor = this.editor;
         const schema = editor.model.schema;
         const conversion = editor.conversion;
@@ -1978,20 +2076,6 @@ class DataFilter extends Plugin {
             view: emptyInlineModelElementToViewConverter(definition)
         });
     }
-    constructor(editor){
-        super(editor);
-        this._dataSchema = editor.plugins.get('DataSchema');
-        this._allowedAttributes = new Matcher();
-        this._disallowedAttributes = new Matcher();
-        this._allowedElements = new Set();
-        this._disallowedElements = new Set();
-        this._dataInitialized = false;
-        this._coupledAttributes = null;
-        this._registerElementsAfterInit();
-        this._registerElementHandlers();
-        this._registerCoupledAttributesPostFixer();
-        this._registerAssociatedHtmlAttributesPostFixer();
-    }
 }
 /**
  * Matches and consumes matched attributes.
@@ -2155,22 +2239,24 @@ class DataFilter extends Plugin {
     return splitRules;
 }
 
-class CodeBlockElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with {@link module:code-block/codeblock~CodeBlock Code Block} feature.
+ */ class CodeBlockElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'CodeBlockElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         if (!this.editor.plugins.has('CodeBlockEditing')) {
             return;
         }
@@ -2249,22 +2335,38 @@ class CodeBlockElementSupport extends Plugin {
     };
 }
 
-class DualContentModelElementSupport extends Plugin {
-    /**
-     * @inheritDoc
-     */ static get requires() {
+/**
+ * Provides the General HTML Support integration for elements which can behave like sectioning element (e.g. article) or
+ * element accepting only inline content (e.g. paragraph).
+ *
+ * The distinction between this two content models is important for choosing correct schema model and proper content conversion.
+ * As an example, it ensures that:
+ *
+ * * children elements paragraphing is enabled for sectioning elements only,
+ * * element and its content can be correctly handled by editing view (splitting and merging elements),
+ * * model element HTML is semantically correct and easier to work with.
+ *
+ * If element contains any block element, it will be treated as a sectioning element and registered using
+ * {@link module:html-support/dataschema~DataSchemaDefinition#model} and
+ * {@link module:html-support/dataschema~DataSchemaDefinition#modelSchema} in editor schema.
+ * Otherwise, it will be registered under {@link module:html-support/dataschema~DataSchemaBlockElementDefinition#paragraphLikeModel} model
+ * name with model schema accepting only inline content (inheriting from `$block`).
+ */ class DualContentModelElementSupport extends Plugin {
+    /**
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'DualContentModelElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const dataFilter = this.editor.plugins.get(DataFilter);
         dataFilter.on('register', (evt, definition)=>{
             const blockDefinition = definition;
@@ -2312,8 +2414,8 @@ class DualContentModelElementSupport extends Plugin {
         });
     }
     /**
-     * Checks whether the given view element includes any other block element.
-     */ _hasBlockContent(viewElement) {
+	 * Checks whether the given view element includes any other block element.
+	 */ _hasBlockContent(viewElement) {
         const view = this.editor.editing.view;
         const blockElements = view.domConverter.blockElements;
         // Traversing the viewElement subtree looking for block elements.
@@ -2327,8 +2429,8 @@ class DualContentModelElementSupport extends Plugin {
         return false;
     }
     /**
-     * Adds attribute filtering conversion for the given data schema.
-     */ _addAttributeConversion(definition) {
+	 * Adds attribute filtering conversion for the given data schema.
+	 */ _addAttributeConversion(definition) {
         const editor = this.editor;
         const conversion = editor.conversion;
         const dataFilter = editor.plugins.get(DataFilter);
@@ -2340,23 +2442,25 @@ class DualContentModelElementSupport extends Plugin {
     }
 }
 
-class HeadingElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with {@link module:heading/heading~Heading Heading} feature.
+ */ class HeadingElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataSchema,
             Enter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'HeadingElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         if (!editor.plugins.has('HeadingEditing')) {
             return;
@@ -2365,8 +2469,8 @@ class HeadingElementSupport extends Plugin {
         this.registerHeadingElements(editor, options);
     }
     /**
-     * Registers all elements supported by HeadingEditing to enable custom attributes for those elements.
-     */ registerHeadingElements(editor, options) {
+	 * Registers all elements supported by HeadingEditing to enable custom attributes for those elements.
+	 */ registerHeadingElements(editor, options) {
         const dataSchema = editor.plugins.get(DataSchema);
         const headerModels = [];
         for (const option of options){
@@ -2406,22 +2510,24 @@ class HeadingElementSupport extends Plugin {
     }
 }
 
-class ImageElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with the {@link module:image/image~Image Image} feature.
+ */ class ImageElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'ImageElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         // At least one image plugin should be loaded for the integration to work properly.
         if (!editor.plugins.has('ImageInlineEditing') && !editor.plugins.has('ImageBlockEditing')) {
@@ -2589,22 +2695,24 @@ class ImageElementSupport extends Plugin {
     };
 }
 
-class MediaEmbedElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with {@link module:media-embed/mediaembed~MediaEmbed Media Embed} feature.
+ */ class MediaEmbedElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'MediaEmbedElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         // Stop here if MediaEmbed plugin is not provided or the integrator wants to output markup with previews as
         // we do not support filtering previews.
@@ -2696,22 +2804,24 @@ function modelToViewMediaAttributeConverter(mediaElementName) {
     };
 }
 
-class ScriptElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support for `script` elements.
+ */ class ScriptElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'ScriptElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const dataFilter = this.editor.plugins.get(DataFilter);
         dataFilter.on('register:script', (evt, definition)=>{
             const editor = this.editor;
@@ -2745,22 +2855,24 @@ class ScriptElementSupport extends Plugin {
     }
 }
 
-class TableElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with {@link module:table/table~Table Table} feature.
+ */ class TableElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'TableElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         if (!editor.plugins.has('TableEditing')) {
             return;
@@ -2898,22 +3010,24 @@ class TableElementSupport extends Plugin {
     };
 }
 
-class StyleElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support for `style` elements.
+ */ class StyleElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'StyleElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const dataFilter = this.editor.plugins.get(DataFilter);
         dataFilter.on('register:style', (evt, definition)=>{
             const editor = this.editor;
@@ -2947,22 +3061,24 @@ class StyleElementSupport extends Plugin {
     }
 }
 
-class ListElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support integration with the {@link module:list/list~List List} feature.
+ */ class ListElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'ListElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         if (!editor.plugins.has('ListEditing')) {
             return;
@@ -3059,8 +3175,8 @@ class ListElementSupport extends Plugin {
         });
     }
     /**
-     * @inheritDoc
-     */ afterInit() {
+	 * @inheritDoc
+	 */ afterInit() {
         const editor = this.editor;
         if (!editor.commands.get('indentList')) {
             return;
@@ -3119,23 +3235,25 @@ class ListElementSupport extends Plugin {
     return listType === 'numbered' || listType == 'customNumbered' ? 'htmlOlAttributes' : 'htmlUlAttributes';
 }
 
-class CustomElementSupport extends Plugin {
+/**
+ * Provides the General HTML Support for custom elements (not registered in the {@link module:html-support/dataschema~DataSchema}).
+ */ class CustomElementSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter,
             DataSchema
         ];
     }
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'CustomElementSupport';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const dataFilter = this.editor.plugins.get(DataFilter);
         const dataSchema = this.editor.plugins.get(DataSchema);
         dataFilter.on('register:$customElement', (evt, definition)=>{
@@ -3273,15 +3391,20 @@ class CustomElementSupport extends Plugin {
     return true;
 }
 
-class GeneralHtmlSupport extends Plugin {
+/**
+ * The General HTML Support feature.
+ *
+ * This is a "glue" plugin which initializes the {@link module:html-support/datafilter~DataFilter data filter} configuration
+ * and features integration with the General HTML Support.
+ */ class GeneralHtmlSupport extends Plugin {
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'GeneralHtmlSupport';
     }
     /**
-     * @inheritDoc
-     */ static get requires() {
+	 * @inheritDoc
+	 */ static get requires() {
         return [
             DataFilter,
             CodeBlockElementSupport,
@@ -3297,8 +3420,8 @@ class GeneralHtmlSupport extends Plugin {
         ];
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         const dataFilter = editor.plugins.get(DataFilter);
         // Load the allowed empty inline elements' configuration.
@@ -3309,11 +3432,11 @@ class GeneralHtmlSupport extends Plugin {
         dataFilter.loadDisallowedConfig(editor.config.get('htmlSupport.disallow') || []);
     }
     /**
-     * Returns a GHS model attribute name related to a given view element name.
-     *
-     * @internal
-     * @param viewElementName A view element name.
-     */ getGhsAttributeNameForElement(viewElementName) {
+	 * Returns a GHS model attribute name related to a given view element name.
+	 *
+	 * @internal
+	 * @param viewElementName A view element name.
+	 */ getGhsAttributeNameForElement(viewElementName) {
         const dataSchema = this.editor.plugins.get('DataSchema');
         const definitions = Array.from(dataSchema.getDefinitionsForView(viewElementName, false));
         const inlineDefinition = definitions.find((definition)=>definition.isInline && !definitions[0].isObject);
@@ -3323,13 +3446,13 @@ class GeneralHtmlSupport extends Plugin {
         return getHtmlAttributeName(viewElementName);
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it includes the given class name.
-     *
-     * @internal
-     * @param viewElementName A view element name.
-     * @param className The css class to add.
-     * @param selectable The selection or element to update.
-     */ addModelHtmlClass(viewElementName, className, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it includes the given class name.
+	 *
+	 * @internal
+	 * @param viewElementName A view element name.
+	 * @param className The css class to add.
+	 * @param selectable The selection or element to update.
+	 */ addModelHtmlClass(viewElementName, className, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3343,13 +3466,13 @@ class GeneralHtmlSupport extends Plugin {
         });
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it does not include the given class name.
-     *
-     * @internal
-     * @param viewElementName A view element name.
-     * @param className The css class to remove.
-     * @param selectable The selection or element to update.
-     */ removeModelHtmlClass(viewElementName, className, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it does not include the given class name.
+	 *
+	 * @internal
+	 * @param viewElementName A view element name.
+	 * @param className The css class to remove.
+	 * @param selectable The selection or element to update.
+	 */ removeModelHtmlClass(viewElementName, className, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3363,12 +3486,12 @@ class GeneralHtmlSupport extends Plugin {
         });
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it includes the given attribute.
-     *
-     * @param viewElementName A view element name.
-     * @param attributes The object with attributes to set.
-     * @param selectable The selection or element to update.
-     */ setModelHtmlAttributes(viewElementName, attributes, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it includes the given attribute.
+	 *
+	 * @param viewElementName A view element name.
+	 * @param attributes The object with attributes to set.
+	 * @param selectable The selection or element to update.
+	 */ setModelHtmlAttributes(viewElementName, attributes, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3382,12 +3505,12 @@ class GeneralHtmlSupport extends Plugin {
         });
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it does not include the given attribute.
-     *
-     * @param viewElementName A view element name.
-     * @param attributeName The attribute name (or names) to remove.
-     * @param selectable The selection or element to update.
-     */ removeModelHtmlAttributes(viewElementName, attributeName, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it does not include the given attribute.
+	 *
+	 * @param viewElementName A view element name.
+	 * @param attributeName The attribute name (or names) to remove.
+	 * @param selectable The selection or element to update.
+	 */ removeModelHtmlAttributes(viewElementName, attributeName, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3401,12 +3524,12 @@ class GeneralHtmlSupport extends Plugin {
         });
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it includes a given style.
-     *
-     * @param viewElementName A view element name.
-     * @param styles The object with styles to set.
-     * @param selectable The selection or element to update.
-     */ setModelHtmlStyles(viewElementName, styles, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it includes a given style.
+	 *
+	 * @param viewElementName A view element name.
+	 * @param styles The object with styles to set.
+	 * @param selectable The selection or element to update.
+	 */ setModelHtmlStyles(viewElementName, styles, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3420,12 +3543,12 @@ class GeneralHtmlSupport extends Plugin {
         });
     }
     /**
-     * Updates GHS model attribute for a specified view element name, so it does not include a given style.
-     *
-     * @param viewElementName A view element name.
-     * @param properties The style (or styles list) to remove.
-     * @param selectable The selection or element to update.
-     */ removeModelHtmlStyles(viewElementName, properties, selectable) {
+	 * Updates GHS model attribute for a specified view element name, so it does not include a given style.
+	 *
+	 * @param viewElementName A view element name.
+	 * @param properties The style (or styles list) to remove.
+	 * @param selectable The selection or element to update.
+	 */ removeModelHtmlStyles(viewElementName, properties, selectable) {
         const model = this.editor.model;
         const ghsAttributeName = this.getGhsAttributeNameForElement(viewElementName);
         model.change((writer)=>{
@@ -3473,15 +3596,19 @@ class GeneralHtmlSupport extends Plugin {
     }
 }
 
-class HtmlComment extends Plugin {
+/**
+ * The HTML comment feature. It preserves the HTML comments (`<!-- -->`) in the editor data.
+ *
+ * For a detailed overview, check the {@glink features/html/html-comments HTML comment feature documentation}.
+ */ class HtmlComment extends Plugin {
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'HtmlComment';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         const loadedCommentsContent = new Map();
         editor.data.processor.skipComments = false;
@@ -3591,12 +3718,12 @@ class HtmlComment extends Plugin {
         });
     }
     /**
-     * Creates an HTML comment on the specified position and returns its ID.
-     *
-     * *Note*: If two comments are created at the same position, the second comment will be inserted before the first one.
-     *
-     * @returns Comment ID. This ID can be later used to e.g. remove the comment from the content.
-     */ createHtmlComment(position, content) {
+	 * Creates an HTML comment on the specified position and returns its ID.
+	 *
+	 * *Note*: If two comments are created at the same position, the second comment will be inserted before the first one.
+	 *
+	 * @returns Comment ID. This ID can be later used to e.g. remove the comment from the content.
+	 */ createHtmlComment(position, content) {
         const id = uid();
         const editor = this.editor;
         const model = editor.model;
@@ -3614,16 +3741,16 @@ class HtmlComment extends Plugin {
         });
     }
     /**
-     * Removes an HTML comment with the given comment ID.
-     *
-     * It does nothing and returns `false` if the comment with the given ID does not exist.
-     * Otherwise it removes the comment and returns `true`.
-     *
-     * Note that a comment can be removed also by removing the content around the comment.
-     *
-     * @param commentID The ID of the comment to be removed.
-     * @returns `true` when the comment with the given ID was removed, `false` otherwise.
-     */ removeHtmlComment(commentID) {
+	 * Removes an HTML comment with the given comment ID.
+	 *
+	 * It does nothing and returns `false` if the comment with the given ID does not exist.
+	 * Otherwise it removes the comment and returns `true`.
+	 *
+	 * Note that a comment can be removed also by removing the content around the comment.
+	 *
+	 * @param commentID The ID of the comment to be removed.
+	 * @returns `true` when the comment with the given ID was removed, `false` otherwise.
+	 */ removeHtmlComment(commentID) {
         const editor = this.editor;
         const marker = editor.model.markers.get(commentID);
         if (!marker) {
@@ -3635,10 +3762,10 @@ class HtmlComment extends Plugin {
         return true;
     }
     /**
-     * Gets the HTML comment data for the comment with a given ID.
-     *
-     * Returns `null` if the comment does not exist.
-     */ getHtmlCommentData(commentID) {
+	 * Gets the HTML comment data for the comment with a given ID.
+	 *
+	 * Returns `null` if the comment does not exist.
+	 */ getHtmlCommentData(commentID) {
         const editor = this.editor;
         const marker = editor.model.markers.get(commentID);
         if (!marker) {
@@ -3657,14 +3784,14 @@ class HtmlComment extends Plugin {
         };
     }
     /**
-     * Gets all HTML comments in the given range.
-     *
-     * By default, it includes comments at the range boundaries.
-     *
-     * @param range
-     * @param options.skipBoundaries When set to `true` the range boundaries will be skipped.
-     * @returns HTML comment IDs
-     */ getHtmlCommentsInRange(range, { skipBoundaries = false } = {}) {
+	 * Gets all HTML comments in the given range.
+	 *
+	 * By default, it includes comments at the range boundaries.
+	 *
+	 * @param range
+	 * @param options.skipBoundaries When set to `true` the range boundaries will be skipped.
+	 * @returns HTML comment IDs
+	 */ getHtmlCommentsInRange(range, { skipBoundaries = false } = {}) {
         const includeBoundaries = !skipBoundaries;
         // Unfortunately, MarkerCollection#getMarkersAtPosition() filters out collapsed markers.
         return Array.from(this.editor.model.markers.getMarkersGroup('$comment')).filter((marker)=>isCommentMarkerInRange(marker, range)).map((marker)=>marker.name);
@@ -3675,10 +3802,13 @@ class HtmlComment extends Plugin {
     }
 }
 
-class HtmlPageDataProcessor extends HtmlDataProcessor {
+/**
+ * The full page HTML data processor class.
+ * This data processor implementation uses HTML as input and output data.
+ */ class HtmlPageDataProcessor extends HtmlDataProcessor {
     /**
-     * @inheritDoc
-     */ toView(data) {
+	 * @inheritDoc
+	 */ toView(data) {
         // Ignore content that is not a full page source.
         if (!data.match(/<(?:html|body|head|meta)(?:\s[^>]*)?>/i)) {
             return super.toView(data);
@@ -3712,8 +3842,8 @@ class HtmlPageDataProcessor extends HtmlDataProcessor {
         return viewFragment;
     }
     /**
-     * @inheritDoc
-     */ toData(viewFragment) {
+	 * @inheritDoc
+	 */ toData(viewFragment) {
         let data = super.toData(viewFragment);
         const page = viewFragment.getCustomProperty('$fullPageDocument');
         const docType = viewFragment.getCustomProperty('$fullPageDocType');
@@ -3731,15 +3861,17 @@ class HtmlPageDataProcessor extends HtmlDataProcessor {
     }
 }
 
-class FullPage extends Plugin {
+/**
+ * The full page editing feature. It preserves the whole HTML page in the editor data.
+ */ class FullPage extends Plugin {
     /**
-     * @inheritDoc
-     */ static get pluginName() {
+	 * @inheritDoc
+	 */ static get pluginName() {
         return 'FullPage';
     }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         const editor = this.editor;
         const properties = [
             '$fullPageDocument',