Error codes | CKEditor 5 Documentation

`accessibility-unknown-keystroke-info-category`

Cannot add keystrokes in an unknown category. Use addKeystrokeInfoCategory to add a new category or make sure the specified category exists.

Parameters

categoryId: string: The id of the unknown keystroke category.
keystrokes: AddKeystrokeInfosData#keystrokes: Keystroke definitions about to be added.

`accessibility-unknown-keystroke-info-group`

Cannot add keystrokes to an unknown group.

Use addKeystrokeInfoGroup to add a new group or make sure the specified group exists.

Parameters

groupId: string: The id of the unknown keystroke group.
categoryId: string: The id of category the unknown group should belong to.
keystrokes: AddKeystrokeInfosData#keystrokes: Keystroke definitions about to be added.

`addcommentthreadcommand-incorrect-ranges`

Cannot add comment thread. Selection is empty and no valid ranges provided.

`addcommentthreadcommand-user-not-found`

Cannot add comment thread. User is not defined.

`ai-applying-suggestion-failed`

An error thrown when applying an AI-generated suggestion to the document fails (e.g. an engine invariant violation while replaying operations).

`ai-aws-adapter-not-supported`

The AWSTextAdapter is no longer supported. The Amazon Bedrock adapter has been removed. Please contact CKEditor support at https://support.ckeditor.com for more information about available AI adapters.

`ai-chat-content-too-large`

The content is too large to be used as chat context.

`ai-chat-context-file-too-large`

The file is too large to be used as chat context.

`ai-chat-context-file-too-many-pages`

The file has too many pages to be used as chat context.

`ai-chat-context-form-data-size-limits-exceeded`

The form data size limits have been exceeded for chat context.

`ai-chat-context-invalid-data`

An error thrown when a URL resource has invalid data type (not a string).

Parameters

resourceId: string: The ID of the resource.
sourceId: string: The ID of the source provider.
expectedType: string: The expected data type.
actualType: string: The actual data type.

`ai-chat-context-unsupported-file-type`

The file type is not supported for chat context.

`ai-chat-context-unsupported-type`

An error thrown when an unsupported resource type is used. Only URL and FILE types are supported.

Parameters

resourceId: string: The ID of the resource.
sourceId: string: The ID of the source provider.
resourceType: string: The unsupported resource type.

`ai-chat-controller-no-active-conversation`

User message was sent before the conversation was started.

`ai-chat-conversation-already-started`

An error thrown when trying to start a conversation that is already started.

`ai-chat-conversation-init-failed`

An error thrown when the conversation fails to initialize (e.g. due to a network error).

`ai-chat-conversation-init-from-id-failed`

An error thrown when the conversation fails to initialize from ID (e.g. due to a network error).

`ai-chat-conversation-not-found`

An error thrown when the conversation conversation with given ID was not found.

`ai-chat-conversation-set-model-not-available`

An error thrown when trying to set model that is not available.

`ai-chat-conversation-set-model-null`

An error thrown when trying to set model to null.

`ai-chat-conversation-start-failed`

An error thrown when the conversation fails to start (e.g. due to a network error).

`ai-chat-conversation-start-no-model-selected`

An error thrown when trying to start a conversation but no model is selected.

`ai-chat-default-model-id-unrecognized`

Model with given ID configured via ai.models.defaultModelId is not available. Falling back to the first available model.

Parameters

defaultModelId: string: The ID of the model configured via ai.models.defaultModelId that was not found.
fallBackModelId: string: The ID of the fall back model

`ai-chat-document-upload-failed`

An error thrown when the documents fail to upload as AI chat context (e.g. due to a network error).

`ai-chat-document-upload-reply-mismatch`

The document upload endpoint returned a reply that does not match the uploaded documents (different length or a missing id). This indicates a backend contract violation.

`ai-chat-documents-missing-description`

When a chat conversation uploads more than one document in a single message (multi-root or multi-editor), each root should declare a description in its root configuration. Routing AI replies back to the source root works without it (it uses channelId and rootName), but the AI chat service uses descriptions to semantically distinguish roots — so when a user scopes a request to a specific area ("edit the title", "summarize the introduction"), the model can route the change to the intended root. Without descriptions, such area-scoped requests may target the wrong root.

`ai-chat-feed-view-item-not-a-reply-item`

Item with the given ID cannot be updated because it is not a reply item.

`ai-chat-feed-view-item-not-a-suggestion-item`

Item with the given ID cannot be updated because it is not a suggestion item.

`ai-chat-feed-view-item-not-a-suggestion-or-reply-item`

Item with the given ID cannot be updated because it is not a suggestion or reply item.

`ai-chat-feed-view-item-not-found`

Item with the given ID does not exist.

`ai-chat-feed-view-scroll-to-suggestion-invalid-item`

Item with the given ID cannot be scrolled to because it is not a suggestion item.

`ai-chat-feed-view-scroll-to-suggestion-part-view-not-found`

Part view with the given index does not exist.

`ai-chat-file-upload-failed`

An error thrown when the file fails to upload as AI chat context (e.g. due to a network error).

`ai-chat-handle-user-conversation-not-initialized`

An error thrown when trying to handle user message but conversation is not initialized.

`ai-chat-handle-user-interaction-already-in-progress`

An error thrown when trying to handle user message but interaction is already in progress.

`ai-chat-interaction-error`

An error thrown when error is received from the AI endpoint.

`ai-chat-invalid-request`

The chat request data is invalid.

`ai-chat-model-already-set`

The model has already been set and cannot be changed.

`ai-chat-model-id-unrecognized`

Model with given ID is not available. Falling back to the default model.

Parameters

modelId: string: The ID of the model that was not found.
fallBackModelId: string: The ID of the fall back model.

`ai-chat-model-not-found`

The requested model was not found.

`ai-chat-models-unable-to-retrieve`

An error thrown when the list of available AI models cannot be retrieved while resolving the conversation's selected model (e.g. due to a network error).

`ai-chat-resource-load-failed`

An error thrown when a resource fails to load data (e.g. due to a network error).

Parameters

resourceId: string: The ID of the resource that failed to load.
sourceId: string: The ID of the source provider.

`ai-chat-resource-no-data`

An error thrown when a resource has no data available.

Parameters

resourceId: string: The ID of the resource.
sourceId: string: The ID of the source provider.

`ai-chat-shortcuts-ai-tabs-not-found`

The AI Chat Shortcuts feature was unable to switch the user interface because the AI Tabs plugin was not found.

Please make sure the AI Tabs feature is enabled before running shortcuts that interact with it.

`ai-chat-shortcuts-invalid-config`

The AI Chat Shortcuts configuration is invalid. Please make sure the shortcut has all necessary properties.

See AIChatShortcutChatDefinition to learn more about configuring chat shortcuts.

Parameters

shortcut: object: The chat shortcut configuration that is invalid.

`ai-chat-shortcuts-review-mode-not-found`

The AI Chat Shortcuts feature was unable to run the shortcut because the AI Review Mode feature was not found.

Please make sure the AI Review mode feature is enabled before running shortcuts that interact with it.

`ai-chat-shortcuts-translate-not-found`

The AI Chat Shortcuts feature was unable to run the shortcut because the AI Translate feature was not found.

Please make sure the AI Translate feature is enabled before running shortcuts that interact with it.

`ai-chat-source-not-found`

An error thrown when a source provider is not found.

Parameters

sourceId: string: The ID of the source provider.

`ai-chat-source-resources-load-failed`

An error thrown when resources fail to load from a source provider.

Parameters

sourceId: string: The ID of the source provider.

`ai-chat-unsafe-content-detected`

Unsafe content was detected in the chat request.

`ai-chat-unsupported-content-type`

The content type is not supported for chat operations.

`ai-chat-url-upload-failed`

An error thrown when the URL fails to upload (e.g. due to a network error).

Parameters

url: string: The URL that failed to upload.

`ai-commands-config-order-collision`

The same order value has been set for two (or more) definitions in the AI Assistant feature configuration.

Learn more about command definitions and group definitions used in the feature configuration

Parameters

conflictingDefinitions: Array<never>: Definitions that have the same order value.

`ai-document-root-missing-title`

Each editor root should declare a title (or, for backward compatibility, a label) in its root configuration (or in the options passed to MultiRootEditor#addRoot()). Routing AI replies back to the source root works without it (it uses channelId and rootName), but the AI chat service uses these names to semantically distinguish roots — so when a user scopes a request to a specific area ("edit the title", "summarize the introduction"), the model can route the change to the intended root. Without a name, such area-scoped requests may target the wrong root.

`ai-documentposition-createfrompath-path-cannot-be-empty`

The path cannot be empty when creating document position from path.

`ai-documentposition-index-out-of-bounds`

The index is out of bounds for the document position.

`ai-documentprocessinggateway-empty-reply`

The AI service's reply contained no documents at all. See ai-documentprocessinggateway-empty-root-content for the case where the reply has an entry for every processed root but one of them came back with empty content.

`ai-documentprocessinggateway-empty-root-content`

The AI service's reply included an entry with empty content for one of the processed roots. Verify that the AI service is configured correctly for the model and prompt used.

Parameters

channelId: string: The channel ID of the root whose reply content was empty.
rootName: string: The name of the root whose reply content was empty.

`ai-documentprocessinggateway-empty-roots`

AIDocumentProcessingGateway.processDocument() was called with roots: []. Pass at least one { channelId, rootName } entry, or omit the roots option entirely to process every root across every editor in the context.

`ai-documentprocessinggateway-missing-document`

Thrown when AIDocumentProcessingGateway.processDocument() encounters no document.

Empty string ('') is accepted.

`ai-documentprocessinggateway-missing-prompt`

Thrown when AIDocumentProcessingGateway.processDocument() is called without a prompt.

`ai-documentprocessinggateway-reply-count-mismatch`

The AI service's reply contained a different number of documents than the number of document content parts sent in the request. Each request document part should produce exactly one reply entry, in the same order — a mismatch means the reply cannot be reliably mapped back to the roots that were processed.

Parameters

expected: number: The number of document content parts sent in the request.
received: number: The number of documents returned in the reply.

`ai-documentprocessinggateway-root-not-found`

AIDocumentProcessingGateway.processDocument() was called with a roots entry that does not match any root in the current context. Verify that its channelId matches the collaboration.channelId of one of the editor instances and that its rootName matches an existing, non-$graveyard root within that editor.

Parameters

channelId: string: The channel ID that was provided.
rootName: string: The root name that was provided.

`ai-documentprocessinggateway-run-failed`

Thrown when AIDocumentProcessingGateway.processDocument() fails on the underlying request.

When the AI service rejected the request, the backend's structured response is exposed under error.data.backendData (for example, an issues list describing which fields failed validation).

Parameters

error: Error: The error that was thrown during the run.
backendData: object: The structured data returned by the AI service backend. Present only when

`ai-gateway-apply-empty-roots`

Thrown when AIGateway.apply() is called with an explicitly empty options.roots array.

`ai-gateway-apply-invalid-status`

Thrown when AIGateway.apply() is called with an AIRunSingleRootResult whose status is not 'completed'. Inspect result.status (and result.error) before applying.

Parameters

status: string: The current status of the run result.

`ai-gateway-apply-root-not-found`

Thrown when an entry in AIGateway.apply()'s options.roots filter does not match any per-root sub-result in result.results.

Parameters

channelId: string: The channelId of the unmatched filter entry.
rootName: string: The rootName of the unmatched filter entry.

`ai-gateway-merge-failed`

Thrown when mergeChangesIntoContent fails to merge AI-produced changes into the document snapshot.

Parameters

id: string: The id of the change that failed to merge.
content: string: The content of the change that failed to merge.
error: Error: The error that was thrown during the merge.

`ai-get-editor-from-context-no-editor`

No editor found in the context.

`ai-interaction-invalid-event-type`

There was a problem processing the response chunk. The event type is invalid.

Parameters

chunk: object: The chunk that was received from the AI endpoint.
event: string: The event type that was received from the AI endpoint.

`ai-invalid-content-type`

The content type provided is invalid.

`ai-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`ai-missing-channel-id`

The collaboration channelId configuration is required to use AI features.

`ai-missing-token`

The authentication config.cloudServices.tokenUrl configuration is required for handling AI connection.

`ai-models-unable-to-retrieve`

The editor was unable to retrieve the list of available AI models. This can happen due to a network error.

`ai-no-track-changes`

Tried to insert AI-proposed changes as suggestions but track changes plugin is not loaded on the target editor.

Parameters

channelId: string: collaboration.channelId of the editor missing the TrackChanges plugin.
rootName: string: Name of the root the run entry targeted on that editor.

`ai-quick-actions-models-unable-to-retrieve`

The editor was unable to retrieve the list of available AI models. This can happen due to a network error. Some quick actions may be unavailable or work improperly.

`ai-quick-actions-plugin-not-found`

Thrown when trying to execute an AI Quick Action but the required plugin is not available. This error indicates that the required plugin is not installed or not loaded.

`ai-quick-actions-unavailable-model`

A quick action is using an outdated or unavailable model in its configuration. The quick action has been disabled. Please update the model to a supported version.

Parameters

actionId: string: The ID of the quick action with the outdated model.
modelId: string: The outdated model identifier.

`ai-rate-limits-exceeded`

Rate limits for the AI service have been exceeded.

`ai-reply-get-content-parts-group-not-found`

The change group with the given index does not exist.

`ai-request-aborted`

Request to the AI API was aborted.

`ai-request-failed`

Failed to fetch response from the AI API.

`ai-response-parser-unable-to-set-up-parser`

The Markdown to HTML converter was unable to set up the parser.

`ai-review-mode-check-run-chunk-error`

An error specific to one chunk occurred during the AI review mode check run.

`ai-review-mode-check-run-failed`

The current check run has failed.

`ai-review-mode-check-run-general-error`

A general error occurred during the AI review mode check run.

`ai-review-mode-command-unavailable-due-to-missing-model`

A review command is unavailable because the required AI model is not available.

This can happen, for example, due to a network error that prevents fetching the list of available models or if the model is no longer available. The command will not be visible in the UI and cannot be executed.

See AIModelsConfig documentation for more details on AI models configuration.

`ai-review-mode-models-unable-to-retrieve`

The editor was unable to retrieve the list of available AI models for review mode for a custom command. This can happen, for example, due to a network error.

If this error occurs, review custom command will not be available.

`ai-review-mode-no-current-check-run`

The current check run was not started or has been removed.

`ai-review-mode-non-existent-commands-used`

Non-existent command IDs were used to configure AI Review commands list.

See availableCommands documentation.

`ai-review-mode-source-check-not-found`

The source check with the given ID was not loaded or has been removed.

`ai-reviewcoreediting-check-run-failed`

Thrown when a review-core check run (started via AIReviewCoreEditing.runCheck()) fails at runtime. This wraps transport, parsing, and merge failures that happen after the request has been dispatched. Callers can inspect error.data.apiId and error.data.args to identify which check was running.

When the AI service rejected the request, the backend's structured response is exposed under error.data.backendData (for example, an issues list describing which fields failed validation).

Parameters

apiId: string: The apiId of the check that failed (e.g. translate).
args: object: The args that were passed to the check run.
error: Error: The error that was thrown during the run.
backendData: object: The structured data returned by the AI service backend. Present only when

`ai-reviewcoreediting-empty-roots`

Thrown when AIReviewCoreEditing.runCheck() is called with roots: []. Pass at least one { channelId, rootName } entry, or omit the roots option entirely to run against every root across every editor in the context.

`ai-reviewcoreediting-root-not-found`

Thrown when AIReviewCoreEditing.runCheck() is called with a roots option that contains an entry that does not match any root in the current context. Verify that each entry's channelId matches the collaboration.channelId of one of the editor instances and that its rootName matches an existing, non-$graveyard root within that editor.

Parameters

channelId: string: The channel ID that was provided.
rootName: string: The root name that was provided.

`ai-reviewgateway-missing-custom-command-model`

Thrown when AIReviewGateway.runCustomReview() is called and no model can be resolved — neither options.model nor the command's default model is available.

Parameters

checkId: string: The command ID that was passed.

`ai-reviewgateway-missing-custom-command-prompt`

Thrown when AIReviewGateway.runCustomReview() is called without a prompt.

Parameters

checkId: string: The command ID that was passed.

`ai-reviewgateway-not-a-custom-command`

Thrown when AIReviewGateway.runCustomReview() resolves the built-in custom command and finds that the resolved command is not the built-in custom command. Extras configured via ai.review.extraCommands are not custom and must be invoked through AIReviewGateway.runReview().

Parameters

checkId: string: The command ID that was resolved.

`ai-reviewgateway-not-a-system-command`

Thrown when AIReviewGateway.runReview() is called with a commandId that points at the built-in custom command. Use AIReviewGateway.runCustomReview() for it instead.

Parameters

checkId: string: The command ID that was passed.

`ai-reviewgateway-review-command-run-failed`

Thrown in older versions when AIReviewGateway failed on running a review command. As of v48.4.0 runtime failures surface via AIRunResult#error with the shared ai-reviewcoreediting-check-run-failed code instead. Kept here so the console-log link from older editors still resolves against latest docs.

Parameters

checkId: string: The command ID for which the command run failed.
error: Error: The error that was thrown during the command run.

`ai-reviewgateway-unknown-command`

Thrown when AIReviewGateway.runReview() is called with a commandId that is not registered in the current editor configuration.

Parameters

checkId: string: The unknown command ID that was passed.

`ai-reviewmode-missing-custom-command-model`

Thrown when AIReviewMode.startCustomReview() is called and no model can be resolved — neither options.model nor the built-in custom command's default model is available.

`ai-reviewmode-missing-custom-command-prompt`

Thrown when AIReviewMode.startCustomReview() is called without a prompt.

`ai-reviewmode-not-a-system-command`

Thrown when AIReviewMode.startReview() is called with a commandId that points at the built-in custom command. Use AIReviewMode.startCustomReview() for it instead.

Parameters

commandId: string: The command ID that was passed.

`ai-reviewmode-review-already-running`

Thrown when AIReviewMode.startReview() or AIReviewMode.startCustomReview() is called while another review check run is already in progress. Wait for the current run to finish (or abort it) before starting a new one.

`ai-reviewmode-review-tab-not-active`

Thrown when AIReviewMode.startReview() is called while the review tab is not the active tab in AITabs. The integrator must activate the 'reviewMode' tab (e.g. via editor.plugins.get( 'AITabs' ).view.activateTab( 'reviewMode' )) before calling startReview().

`ai-reviewmode-review-vetoed`

Thrown when AIReviewMode.startReview() or AIReviewMode.startCustomReview() is called and activating the review tab is vetoed by a listener (for example another AI tab has an unresolved run and the user declines the confirmation dialog asking to leave it).

`ai-reviewmode-unknown-command`

Thrown when AIReviewMode.startReview() is called with a commandId that is not registered in the current editor configuration.

Parameters

commandId: string: The unknown command ID that was passed.

`ai-service-url-invalid-version`

The configured config.ai.serviceUrl must end with /v1 version.

Parameters

serviceUrl: string: The configured service URL that failed validation.

`ai-tabs-configuration-not-found`

Configuration for the AI tabs container was not found.

Please make sure that config.ai.container is set.

AI tabs were configured in the 'sidebar' mode but the config.ai.container.element was not set.

Please make sure that config.ai.container.element refers to an existing element in the DOM.

`ai-tabs-unsupported-ui-side`

Target side is not supported.

`ai-tabs-unsupported-ui-type`

Target UI type is not supported.

`ai-translate-translation-already-running`

Thrown when AITranslate.startTranslate() is called while another translation run is already in progress. Wait for the current run to finish before starting a new one.

`ai-translate-translation-vetoed`

Thrown when AITranslate.startTranslate() is called and activating the translate tab is vetoed by a listener (for example another AI tab has an unresolved run and the user declines the confirmation dialog asking to leave it).

`ai-translate-unknown-language`

Thrown when AITranslate.startTranslate() is called with a languageId that is not present in the list of available languages. Use AITranslate.getAvailableLanguages() for valid language ids.

Parameters

languageId: string: The unknown language ID that was passed.

`ai-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get full access at https://ckeditor.com/contact/.

`ai-usage-limits-exceeded`

Usage limits for the AI service have been exceeded.

`aiadapter-text-adapter-not-set`

AI text adapter plugin has not been added to the editor. Use one of the provided adapter plugins (e.g. OpenAITextAdapter if you connect to OpenAI or Azure OpenAI service) or create a custom adapter.

`aitextadapter-send-request-failed`

Sending a request to the AI service API failed.

`alignment-config-classname-already-defined`

The same className in one of the alignment.options was already declared.

Parameters

option: object

First option that declares given className.

configuredOptions: object

Contents of alignment.options.

`alignment-config-classnames-are-missing`

The className property has to be defined for all options once at least one option declares className.

Parameters

configuredOptions: object: Contents of alignment.options.

`alignment-config-name-already-defined`

The same name in one of the alignment.options was already declared. Each name representing one alignment option can be set exactly once.

Parameters

option: object: First option that declares given name.
configuredOptions: object: Contents of alignment.options.

`alignment-config-name-not-recognized`

The name in one of the alignment.options is not recognized. The available options are: 'left', 'right', 'center' and 'justify'.

Parameters

option: object: Options with unknown value of the name property.

`annotation-invalid-target`

An error thrown when the target type is invalid.

The target should be either:

a DOM element or an array of DOM elements,
or a rect instance,
or null,
or a callback that returns one of the above.

`annotationcollection-duplicated-item`

The annotation already exists in the collection. It cannot be added more than once.

`annotationcollection-not-existing-item`

The annotation does not exist in the collection and cannot be removed.

`annotationsuis-annotation-mismatch`

An annotation should always belong only to one annotations UI instance. Check filters that were passed to activate methods.

`annotationsuis-missing-ui`

UI with a given name has been not registered.

`annotationsuis-missing-ui`

UI with a given name has been not registered.

`annotationsuis-missing-ui`

UI with a given name has been not registered.

`annotationsuis-register-already-registered`

UI with a given name already registered.

`annotationsuis-register-invalid-interface`

The annotations UI plugin should implement AnnotationsUI interface.

`attachtoform-missing-elementapi-interface`

The editor passed to attachToForm() must implement the ElementApi interface.

`attribute-element-get-elements-with-same-id-no-id`

Cannot get elements with the same id for an attribute element without id.

`attribute-operation-attribute-exists`

The attribute with given key already exists for the given node.

Parameters

root: ModelItem: The item element.
key: string: The key of the attribute.

`attribute-operation-range-not-flat`

The range to change is not flat.

`attribute-operation-wrong-old-value`

Changed node has different attribute value than operation's old attribute value.

Parameters

root: ModelItem: The item element.
key: string: The key of the attribute.
value: never: The value.

`batch-constructor-deprecated-string-type`

The string value for a type property of the Batch constructor has been deprecated and will be removed in the near future. Please refer to the Batch constructor API documentation for more information.

`batch-type-deprecated`

The Batch#type property has been deprecated and will be removed in the near future. Use Batch#isLocal, Batch#isUndoable, Batch#isUndo and Batch#isTyping instead.

`cannot-change-view-tree`

Thrown when there is an attempt to make changes to the view tree when it is in incorrect state. This may cause some unexpected behaviour and inconsistency between the DOM and the view. This may be caused by:

calling change or forceRender during rendering process,
calling change or forceRender inside of post-fixer function.

`case-change-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`case-change-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get full access at https://ckeditor.com/contact/.

`ckbox-access-default-workspace-error`

The user is not authorized to access the workspace defined in theckbox.defaultUploadWorkspaceId configuration.

`ckbox-fetch-category-http-error`

Fetching a list of available categories with which an uploaded file can be associated failed.

`ckbox-image-edit-unavailable-with-trusted-types`

The CKBox image editor is not available, because the application enforces Trusted Types with the require-trusted-types-for 'script' CSP directive. The image editor writes HTML in a way that this directive rejects, and the editor cannot change how it does that. Choosing assets in CKBox still works.

The editor disables its own Edit image button. The Edit button in the CKBox dialog is part of CKBox, so it stays available, but the image editor that it opens cannot load the image either.

For a detailed overview, check the Content Security Policy guide.

`ckbox-image-not-processed`

Image has not been processed yet.

`ckbox-image-processing-failed`

The image processing failed.

`ckbox-plugin-image-feature-missing`

The CKBox feature requires one of the following plugins to be loaded to work correctly:

ImageBlock,
ImageInline,
Image (loads both ImageBlock and ImageInline)

Please make sure your editor configuration is correct.

Parameters

editor: Editor: The editor instance.

`ckbox-plugin-missing-token-url`

The config.ckbox.tokenUrl or the config.cloudServices.tokenUrl configuration is required for the CKBox plugin.

ClassicEditor.create( {
	attachTo: document.createElement( 'div' ),
	ckbox: {
		tokenUrl: "YOUR_TOKEN_URL"
		// ...
	}
	// ...
} );

`ckeditor-duplicated-modules`

This error is thrown when, due to a mistake in the way CKEditor 5 was installed, imported, or initialized, some of its modules were evaluated and executed twice. Duplicate modules inevitably lead to runtime errors and increased bundle size.

Check dependency versions

First, make sure that you use the latest version of all CKEditor 5 dependencies. Depending on the installation method, you should check the versions of the ckeditor5, ckeditor5-premium-features, or @ckeditor/ckeditor5-<NAME> packages. If you cannot update to the latest version, ensure that all the CKEditor 5 packages are in the same version.

If you use third-party plugins, make sure to update them, too. If they are incompatible with the version of CKEditor 5 you use, you may need to downgrade the CKEditor 5 packages (which we do not recommend). Ask the plugin's author to upgrade the dependencies, or fork their project and update it yourself.

Check imports

The next step is to look at how you import CKEditor 5 into your project.

The new installation methods are designed to prevent module duplication, so if you are not using them yet, you should consider updating your project. However, several legacy installation methods are still supported for backward compatibility, and mixing them may result in module duplication.

These are the most common import methods of the CKEditor 5 packages.

New installation methods (NIM) – Imports from the ckeditor5 and ckeditor5-premium-features packages.
Optimized build for the new installation methods – Imports from the @ckeditor/ckeditor5-<NAME>/dist/index.js.
Predefined builds (no longer supported) – Imports from the @ckeditor/ckeditor5-build-<NAME> packages.
Default imports (legacy) – Imports from the @ckeditor/ckeditor5-<NAME> packages (default export).
src (legacy) – Imports from the @ckeditor/ckeditor5-<NAME>/src/*.
DLL builds (legacy) – Imports from the ckeditor5/build/<NAME> and @ckeditor/ckeditor5-<NAME>/build/*.

The best way to avoid duplicate modules is to avoid mixing these installation methods. For example, if you use imports specific to the optimized build, you should use them for all CKEditor 5 packages. In addition, since the DLL builds already include the core of the editor, they cannot be used with other types of imports.

Here is a matrix showing which installation methods are compatible with each other:

	NIM	Optimized build	Predefined builds	Default imports	`src`	DLL builds
NIM	✅	✅	❌	❌	❌	❌
Optimized builds	✅	✅	❌	❌	❌	❌
Predefined build	❌	❌	✅	❌	❌	❌
Default imports	❌	❌	❌	✅	✅	❌
`src`	❌	❌	❌	✅	✅	❌
DLL builds	❌	❌	❌	❌	❌	✅

If you use any third-party plugins, make sure the way you import them is compatible with the way you import CKEditor 5.

New installation methods and optimized builds

If you use the new installation methods, you should only import { code } from the ckeditor5 and ckeditor5-premium-features packages. Do not import { code } from the @ckeditor/ckeditor5-<NAME> packages unless you follow the Optimizing build size guide and the imports from the @ckeditor/ckeditor5-<NAME> packages end with /dist/index.js.

If you use a CDN, ensure that some files are not included twice in your project.

Examples of valid and invalid import paths:

import { ClassicEditor, Highlight } from 'ckeditor5'; // ✅
import { Highlight } from '@ckeditor/ckeditor5-highlight/dist/index.js'; // ✅
import { Highlight } from '@ckeditor/ckeditor5-highlight/src/highlight.js'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight'; // ❌
import '@ckeditor/ckeditor5-highlight/build/highlight.js'; // ❌

(Deprecated) Predefined builds

As of April, 2025 predefined build are no longer supported. Please refer to the Quick Start guide to choose one of the modern installation and integration methods available.

If you use the predefined builds, you cannot import any additional plugins. These builds already include the editor's core and selected plugins and importing additional ones will cause some modules to be bundled and loaded twice.

Examples of valid and invalid import paths:

import { ClassicEditor } from '@ckeditor/ckeditor5-build-classic'; // ✅
import { Highlight } from 'ckeditor5'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight/dist/index.js'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight/src/highlight'; // ❌
import '@ckeditor/ckeditor5-highlight/build/highlight'; // ❌

If you are missing some features from the list of plugins, you should switch to the new installation methods which do not have this limitation.

(Legacy) Default imports and `src` imports

If you use the legacy customized installation method, you should only import code from the @ckeditor/ckeditor5-<NAME> packages. While you can import code from the @ckeditor/ckeditor5-<NAME>/src/* files, it is not recommended as it can make migration to the new installation methods more difficult.

If you use this installation method, you should not import { code } from the ckeditor5 or ckeditor5-premium-features packages.

Examples of valid and invalid import paths:

import { ClassicEditor } from '@ckeditor/ckeditor5-editor-classic'; // ✅
import { Highlight } from '@ckeditor/ckeditor5-highlight'; // ✅
import { Highlight } from '@ckeditor/ckeditor5-highlight/src/highlight.js'; // ✅ (not recommended)
import { Highlight } from 'ckeditor5'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight/dist/index.js'; // ❌
import '@ckeditor/ckeditor5-highlight/build/highlight'; // ❌

(Legacy) DLL builds

If you are using the legacy DLL builds, you should not import any non-DLL modules.

Examples of valid and invalid import paths:

import 'ckeditor5/build/ckeditor5-dll.js';// ✅
import '@ckeditor/ckeditor5-editor-classic/build/editor-classic.js';// ✅
import '@ckeditor/ckeditor5-highlight/build/highlight.js';// ✅
import { Highlight } from 'ckeditor5'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight/dist/index.js'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight'; // ❌
import { Highlight } from '@ckeditor/ckeditor5-highlight/src/highlight.js'; // ❌

Reinstall `node_modules`

Usually, npm and other package managers deduplicate all packages - for example, ckeditor5 is only installed once in node_modules/. However, it is known to fail to do so occasionally.

To rule out this possibility, you can try the following:

Remove the node_modules directory.
Remove the package-lock.json, yarn.lock, or pnpm-lock.yaml files (depending on the package manager used).
Run npm install to reinstall all packages.
Run npm ls to check how many times packages like @ckeditor/ckeditor5-core are installed. If they are installed more than once, verify which package causes that.

`ckfinder-missing-image-plugin`

CKFinder requires at least one plugin providing support for images loaded in the editor. Please make sure either:

Image (which loads both types of images),
or ImageBlock,
or ImageInline.

is loaded in your editor configuration.

`ckfinder-unknown-openermethod`

The ckfinder.openerMethod must be one of: "popup" or "modal".

`cloudservices-init`

An internal WebSocketGateway error.

This error might occur because of the incorrectly configured webSocketUrl * config.cloudServices.webSocketUrl} or because of the service handling the WebSocket connections being unavailable.

The original error is passed in the error.data.originalError property.

`cloudservices-reconnection-error`

An internal reconnection error.

`cloudservices-token-not-registered`

The provided tokenUrl was not registered by registerTokenUrl.

`cloudservicescommentsadapter-connect-already-connected`

Cannot connect to the same channelId more than once.

`cloudservicescommentsadapter-disconnect-not-exist`

Missing service with the given channelId.

`cloudservicescommentsadapter-service-not-exist`

Missing service of a given channelId.

`collaboration-missing-channelid`

Unique collaboration.channelId configuration is required for defining name for data stores. Note that application instances with the same channelId will share data each other.

`collection-add-invalid-id`

This item's ID should be a string.

`collection-add-item-already-exists`

This item already exists in the collection.

`collection-add-item-invalid-index`

The index passed to Collection#addMany() is invalid. It must be a number between 0 and the collection's length.

`collection-bind-to-rebind`

The collection cannot be bound more than once.

`collection-get-invalid-arg`

An index or ID must be given.

`collection-remove-404`

Item not found.

`color-picker-unavailable-with-trusted-types`

The color picker is not available, because the application enforces Trusted Types with the require-trusted-types-for 'script' CSP directive. The color picker cannot be rendered under that directive, so the editor turns it off.

The color palettes and the document colors are not affected. To turn the color picker off yourself, and stop this warning, set the colorPicker option of the feature to false.

For a detailed overview, check the Content Security Policy guide.

`commandcollection-command-not-found`

Command does not exist.

Parameters

commandName: string: Name of the command.

`commentsrepository-active-missing-comment-thread`

Cannot set a non-existent comment thread as an active. Check if comment thread of the given id is added to the repository.

`commentsrepository-active-not-attached`

Cannot set a not attached comment thread as an active. Comment thread has to be attached to the target element to set it as active.

`commentsrepository-adapter-already-set`

Cannot set adapter more than once.

`commentsrepository-add-comment-internal-error`

Adding comment threw an error.

`commentsrepository-add-comment-thread-internal-error`

Adding comment thread threw an error.

`commentsrepository-add-comment-to-missing-comment-thread`

Cannot add comment to a non-existent comment thread.

`commentsrepository-add-comment-user-not-exists`

Comment author is not defined in Users plugin.

`commentsrepository-attach-missing-comment-thread`

Cannot attach a non-existent comment thread.

`commentsrepository-duplicated-comment-thread-id`

Comment thread with a given id is already added to the repository.

`commentsrepository-fetch-comment-thread`

Fetching a comment thread failed.

`commentsrepository-get-comment-invalid-id`

Comment id has to be a string.

`commentsrepository-invalid-comment-authorid`

Comment author id has to be a string.

`commentsrepository-invalid-comment-content`

Comment content has to be a string.

`commentsrepository-invalid-comment-thread-id`

Comment thread id has to be a string.

`commentsrepository-invalid-commentid`

Comment id has to be a string.

`commentsrepository-missing-comment-thread`

Comment thread with a given id is not existing.

`commentsrepository-missing-target`

Target is required to open new comment thread.

`commentsrepository-missing-thread-and-adapter-method`

Comment thread with a given id is not added to the editor nor adapter.getCommentThread() is defined. See the Comments integration guide.

`commentsrepository-remove-comment-internal-error`

Removing comment resulted in an error.

`commentsrepository-remove-comment-missing-comment-thread`

Cannot remove comment from a non-existent comment thread.

`commentsrepository-remove-comment-thread-internal-error`

Removing comment resulted in an error.

`commentsrepository-remove-missing-comment`

Cannot remove a non-existent Comment.

`commentsrepository-remove-missing-comment-thread`

Cannot remove a non-existent comment thread.

`commentsrepository-reopen-comment-thread`

Comment thread with a given id is not resolved.

`commentsrepository-reopen-comment-thread-internal-error`

Reopening comment thread resulted in an error.

`commentsrepository-resolve-comment-thread-internal-error`

Resolving comment thread resulted in an error.

`commentsrepository-resolved-comment-thread`

Comment thread with a given id has been already resolved.

`commentsrepository-update-comment-internal-error`

Updating comment resulted in an error.

`commentsrepository-update-comment-invalid-content`

Comment content has to be a string.

`commentsrepository-update-comment-missing-comment-thread`

Cannot update a comment of a non-existent comment thread.

`commentsrepository-update-comment-thread-internal-error`

Updating comment thread resulted in an error.

`commentsrepository-update-missing-comment`

Cannot update a non-existent Comment.

`componentfactory-item-missing`

The required component is not registered in the component factory. Please make sure the provided name is correct and the component has been correctly added to the factory.

Parameters

name: string: The name of the missing component.

`context-addeditor-private-context`

Cannot add multiple editors to the context which is created by the editor.

`context-initplugins-constructor-only`

Only a constructor function is allowed as a context plugin.

`context-initplugins-invalid-plugin`

Only a plugin marked as a context plugin is allowed to be used with a context.

`contextualballoon-add-view-exist`

Trying to add configuration of the same view more than once.

`contextualballoon-remove-view-not-exist`

Trying to remove the configuration of the view not defined in the stack.

`contextualballoon-showstack-stack-not-exist`

Trying to show a stack that does not exist.

`conversion-add-alias-dispatcher-not-registered`

Trying to register an alias for a dispatcher that nas not been registered.

`conversion-attribute-to-attribute-on-text`

This error occurs when a text node's attribute is to be downcasted by an Attribute to Attribute converter. In most cases it is caused by converters misconfiguration when only "generic" converter is defined:

editor.conversion.for( 'downcast' ).attributeToAttribute( {
	model: 'attribute-name',
	view: 'attribute-name'
} ) );

and given attribute is used on text node, for example:

model.change( writer => {
	writer.insertText( 'Foo', { 'attribute-name': 'bar' }, parent, 0 );
} );

In such cases, to convert the same attribute for both ModelElement and Text nodes, text specific Attribute to Element converter with higher priority must also be defined:

editor.conversion.for( 'downcast' ).attributeToElement( {
	model: {
		key: 'attribute-name',
		name: '$text'
	},
	view: ( value, { writer } ) => {
		return writer.createAttributeElement( 'span', { 'attribute-name': value } );
	},
	converterPriority: 'high'
} ) );

Parameters

data: object: The conversion data.

`conversion-element-to-structure-disallowed-text`

This error occurs when a model element is downcasted via elementToStructure helper but the element was allowed to host $text by the model schema.

For instance, this may be the result of myElement allowing the content of $block in its schema definition:

// Element definition in schema.
schema.register( 'myElement', {
	allowContentOf: '$block',

	// ...
} );

// ...

// Conversion of myElement with the use of elementToStructure().
editor.conversion.for( 'downcast' ).elementToStructure( {
	model: 'myElement',
	view: ( modelElement, { writer } ) => {
		// ...
	}
} );

In such case, elementToElement() helper can be used instead to get around this problem:

editor.conversion.for( 'downcast' ).elementToElement( {
	model: 'myElement',
	view: ( modelElement, { writer } ) => {
		// ...
	}
} );

Parameters

elementName: string: The name of the element the structure is to be created for.

`conversion-for-unknown-group`

Trying to add a converter to an unknown dispatchers group.

`conversion-group-exists`

Trying to register a group name that has already been registered.

`conversion-model-consumable-not-consumed`

Some of the model items were not consumed while downcasting the model to view.

This might be the effect of:

A missing converter for some model elements. Make sure that you registered downcast converters for all model elements.
A custom converter that does not consume converted items. Make sure that you consumed all model elements that you converted from the model to the view.
A custom converter that called event.stop(). When providing a custom converter, keep in mind that you should not stop the event. If you stop it then the default converter at the lowest priority will not trigger the conversion of this node's attributes and child nodes.

Parameters

items: Array<ModelItem>: Items that were not consumed.

`conversion-slot-filter-incomplete`

Filters provided to writer.createSlot() are incomplete and exclude at least one children element (one of the children elements would not be assigned to any of the slots).

Parameters

element: ModelElement: The element of which children would not be properly

`conversion-slot-filter-overlap`

Filters provided to writer.createSlot() overlap (at least two filters accept the same child element).

Parameters

element: ModelElement: The element of which children would not be properly

`conversion-slot-mode-unknown`

Unknown slot mode was provided to writer.createSlot() in the downcast converter.

Parameters

modeOrFilter: never: The specified mode or filter.

`css-full-page-provide-sanitize-function`

When using the Full page with the config.htmlSupport.fullPage.allowRenderStylesFromHead set to true, it is strongly recommended to define a sanitize function that will clean up the CSS which is present in the <head> in editors content in order to avoid XSS vulnerability.

For a detailed overview, check the Full page HTML feature documentation.

`data-filter-invalid-definition`

The definition cannot be handled by the data filter.

Make sure that the registered definition is correct.

`datacontroller-get-detached-root`

Retrieving document data for a detached root.

This usually indicates an error as a detached root should be considered "removed" and should not be included in the document data.

`datacontroller-get-non-existent-root`

Cannot get data from a non-existing root. This error is thrown when DataController#get() method is called with a non-existent root name. For example, if there is an editor instance with only main root, calling get like:

data.get( { rootName: 'root2' } );

will throw this error.

`datacontroller-init-document-not-empty`

Cannot set initial data to a non-empty ModelDocument. Initial data should be set once, during the Editor initialization, when the version is equal 0.

`datacontroller-init-non-existent-root`

Cannot init data on a non-existent root. This error is thrown when DataController#init() method is called with non-existent root name. For example, if there is an editor instance with only main root, calling init like:

data.init( { main: '<p>Foo</p>', root2: '<p>Bar</p>' } );

will throw this error.

`datacontroller-set-non-existent-root`

Cannot set data on a non-existent root. This error is thrown when the DataController#set() method is called with non-existent root name. For example, if there is an editor instance with only the default main root, calling set like:

data.set( { main: '<p>Foo</p>', root2: '<p>Bar</p>' } );

will throw this error.

`decompress-compressor-not-found`

The compressor could not decompress the data as the compressor for one of entries in the types array has not been found.

`detach-operation-on-document-node`

Cannot detach document node.

`document-outline-container-not-provided`

A DOM element to inject the document outline is not provided. Please set the config.documentOutline.container configuration option.

Parameters

editor: Editor: Editor instance related to error.

`document-outline-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`document-outline-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`document-selection-gravity-wrong-restore`

Restoring gravity for an unknown UID is not possible. Make sure you are using a correct UID obtained from the overrideSelectionGravity to restore.

Parameters

uid: string: The unique identifier returned by

`document-selection-wrong-position`

Range from document selection starts or ends at incorrect position.

Parameters

range: ModelRange: The invalid range.

`documentcompare-apply-failed`

Applying the patch operations to the document failed. The patch might be applied partially and the document may be in a broken state.

`documentcompare-apply-session-mismatch`

The patch is applied for a different document or editing session than the one it was captured in. The snapshot it was produced from is stale (for example the collaboration session was flushed, or the editor was re-initialized), so the patch changes cannot be merged with the current document.

`documentcompare-applypatch-invalid-patch`

The patch failed validation and cannot be applied. The patch operations were trial-applied to a copy of the current document which failed. The patch operations are incorrect and structurally invalid against the current document. The patch cannot be applied on the document.

`documentcompare-applypatch-unsupported-operation`

The patch contains a root operation, which is not produced and is not supported by DocumentCompare.

`documentcompare-no-track-changes`

Track changes feature is required to apply operations as suggestions.

`domconverter-invalid-attribute-detected`

Invalid attribute name was ignored during rendering.

`domconverter-transparent-rendering-unsupported-in-editing-pipeline`

The dataPipeline:transparentRendering flag is supported only in the data pipeline.

`domconverter-unsafe-attribute-detected`

The ViewDomConverter detected an interactive attribute in the editing pipeline. For the best editing experience, the attribute was renamed to data-ck-unsafe-attribute-[original attribute name].

If you are the author of the plugin that generated this attribute and you want it to be preserved in the editing pipeline, you can configure this when creating the element using ViewDowncastWriter during the model–view conversion. Methods such as createContainerElement, createAttributeElement, or createEmptyElement accept an option that will disable filtering of specific attributes:

const paragraph = writer.createContainerElement( 'p',
	{
		class: 'clickable-paragraph',
		onclick: 'alert( "Paragraph clicked!" )'
	},
	{
		// Make sure the "onclick" attribute will pass through.
		renderUnsafeAttributes: [ 'onclick' ]
	}
);

Parameters

domElement: HTMLElement: The DOM element the attribute was set on.
key: string: The original name of the attribute
value: string: The value of the original attribute

`domconverter-unsafe-script-element-detected`

While rendering the editor content, the ViewDomConverter detected a <script> element that may disrupt the editing experience. To avoid this, the <script> element was replaced with <span data-ck-unsafe-element="script"></span>.

`domconverter-unsafe-style-element-detected`

While rendering the editor content, the ViewDomConverter detected a <style> element that may affect the editing experience. To avoid this, the <style> element was replaced with <span data-ck-unsafe-element="style"></span>.

`easy-image-image-feature-missing`

The Easy Image feature requires one of the following plugins to be loaded to work correctly:

ImageBlock,
ImageInline,
Image (loads both ImageBlock and ImageInline)

Please make sure your editor configuration is correct.

Parameters

editor: Editor: The editor instance.

`editingcontroller-reconvertmarker-marker-not-exist`

The marker with the provided name does not exist and cannot be reconverted.

Parameters

markerName: string: The name of the reconverted marker.

`editor-config-invalid-type`

Editor configuration must be an object.

A common cause of this error is passing an Editor class (for example ClassicEditor) in the config.plugins array. In such case, the editor constructor is called with an Editor or Context instance instead of the configuration object.

`editor-config-sanitizehtml-not-supported`

Configuration property config.sanitizeHtml was removed in CKEditor version 43.1.0 and is no longer supported.

Please use config.htmlEmbed.sanitizeHtml and/or config.mergeFields.sanitizeHtml instead.

`editor-create-attachto-ignored`

The config.attachTo option is only available for the ClassicEditor because it replaces the given DOM element with its own UI. Other editor types (e.g. inline, balloon, decoupled) render inside the root element directly, so config.attachTo is not applicable.

Remove the attachTo option from the editor configuration and use config.root.element (or config.roots.<rootName>.element for the multi-root editor) to specify the DOM element instead.

`editor-create-attachto-overspecified`

The element to attach the editor to is specified both as the first argument of ClassicEditor.create() and in config.attachTo.

Passing the element as the first argument is deprecated. Remove it and use config.attachTo instead.

`editor-create-initial-data`

The config.initialData option cannot be used together with the initial data passed as the first parameter of Editor.create().

`editor-create-initial-data-overspecified`

The initial data is specified both as the first argument of the editor create() method (e.g. InlineEditor.create() or MultiRootEditor.create()) and in the deprecated config.initialData.

Passing initial data as the first argument is deprecated. Remove it and use config.root.initialData (or config.roots.<rootName>.initialData for the multi-root editor) instead.

`editor-create-legacy-initial-data-overspecified`

The initial data is specified both in config.root.initialData (or config.roots.<rootName>.initialData for the multi-root editor) and in the deprecated config.initialData.

The config.initialData option is deprecated. Remove it and use config.root.initialData (or config.roots.<rootName>.initialData for the multi-root editor) instead.

`editor-create-multi-root-with-main`

The config.root option is designed for single-root editors and cannot be used with the multi-root editor.

To configure a multi-root editor, define each root individually using config.roots:

MultiRootEditor.create( {
	roots: {
		header: { initialData: '<p>Header</p>' },
		content: { initialData: '<p>Content</p>' }
	}
} );

`editor-create-root-element-not-supported`

The ClassicEditor cannot use an existing DOM element as config.root.element because the classic editor replaces the source element with its own UI rather than editing inline within it. The passed element is ignored along with its content, so any markup inside it will not be used as the editor's initial data. Use config.attachTo to specify the DOM element the editor should replace, or pass the initial data via config.root.initialData.

A tag name string (e.g. 'h1') or a view root element definition are still accepted - they describe the editable root element the classic editor creates inside its UI box.

`editor-create-root-element-overspecified`

The root element is specified both as the first argument of the editor create() method (e.g. InlineEditor.create() or MultiRootEditor.create()) and in config.root.element (or config.roots.<rootName>.element for the multi-root editor).

Passing the element as the first argument is deprecated. Remove it and use config.root.element (or config.roots.<rootName>.element for the multi-root editor) instead.

`editor-create-root-initial-data-overspecified`

The initial data is specified both as the first argument of the editor create() method (e.g. InlineEditor.create() or MultiRootEditor.create()) and in config.root.initialData (or config.roots.<rootName>.initialData for the multi-root editor).

Passing initial data as the first argument is deprecated. Remove it and use config.root.initialData (or config.roots.<rootName>.initialData for the multi-root editor) instead.

`editor-create-roots-not-plain-object`

The config.roots option must be a plain object (an object literal or Object.create( null )). Objects with a custom prototype (e.g. created via Object.create( someProto )) or class instances are not accepted, because internal configuration processing relies on a known prototype chain to detect nested configuration objects.

Replace the value with a plain object before passing it to the editor:

// Wrong
MultiRootEditor.create( {
	roots: Object.assign( Object.create( {} ), { intro: { ... } } )
} );

// Right
MultiRootEditor.create( {
	roots: { intro: { ... } }
} );

`editor-create-roots-with-main`

Both config.root and config.roots.main are set, but they both configure the same default editing root, which creates an ambiguity. Use one or the other:

config.root for a single-root editor.
config.roots when defining multiple roots.

`editor-initial-data-replaced-with-revision-data`

The editor initial data and initial roots attributes were replaced with the most recent revision data, as the editor data was different from revision data.

This means that the editor data was either outdated (possible due to an error, e.g. the document data has not been saved after last changes during the previous editing session) or the data was post-processed after it was obtained from the editor.

Note, that changes in whitespaces are also considered a difference. The same applies to a mismatch in the root's modelElement between the editor configuration and the revision data.

`editor-isreadonly-has-no-setter`

The Editor#isReadOnly property is read-only since version 34.0.0 and can be set only using Editor#enableReadOnlyMode( lockId ) and Editor#disableReadOnlyMode( lockId ).

Usage before version 34.0.0:

editor.isReadOnly = true;
editor.isReadOnly = false;

Usage since version 34.0.0:

editor.enableReadOnlyMode( 'my-feature-id' );
editor.disableReadOnlyMode( 'my-feature-id' );

`editor-missing-sourceelement`

Cannot update the source element of a detached editor.

The updateSourceElement() method cannot be called if you did not pass an element to Editor.create().

`editor-read-only-lock-id-invalid`

The lock ID is missing or it is not a string or symbol.

Parameters

lockId: never: Lock ID.

`editor-root-element-is-not-limit`

The model root element must be a limit element. The element name specified in config.root.modelElement (or config.roots.<rootName>.modelElement) must be registered in the schema with isLimit set to true.

Parameters

rootName: any: The name of the root that uses a non-limit element.
elementName: any: The name of the model element used for the root.

`editor-root-element-styles-overspecified`

Both the styles object and the attributes.style string were provided in config.root.element. Provide one or the other - the object form takes precedence.

`editor-source-element-already-used`

A DOM element used to create the editor (e.g. InlineEditor.create()) has already been used to create another editor instance. Make sure each editor is created with a unique DOM element.

Parameters

element: HTMLElement: DOM element that caused the collision.

`editor-source-element-not-attached`

Cannot initialize the editor because the provided source element is not attached to the DOM and cannot be replaced.

`editor-ui-deprecated-editable-elements`

The EditorUI#_editableElements property has been deprecated and will be removed in the near future. Please use setEditableElement() and getEditableElement() methods instead.

Parameters

editorUI: EditorUI: Editor UI instance the deprecated property belongs to.

`editor-ui-deprecated-viewport-offset-config`

The EditorConfig#toolbar.viewportTopOffset property has been deprecated and will be removed in the near future. Please use EditorConfig#ui.viewportOffset instead.

`editor-usage-data-path-already-set`

The error thrown when trying to set the usage data path that was already set. Make sure that you are not setting the same path multiple times.

Parameters

path: string: The path that was already set.

`editor-wrong-element`

This error is thrown when trying to pass a <textarea> element to a create() function of an editor class.

The only editor type which can be initialized on <textarea> elements is the classic editor. This editor hides the passed element and inserts its own UI next to it. Other types of editors reuse the passed element as their root editable element and therefore <textarea> is not appropriate for them. Use a <div> or another text container instead:

<div id="editor">
	<p>Initial content.</p>
</div>

`editor-wrong-element`

The DOM tag name specified in config.root.element cannot be used as an editor's editable root. The <textarea> and <input> elements are form fields and cannot contain other HTML elements, so the editor cannot render rich-text content inside them.

To fix the error, use a tag that can contain other elements - for example 'div', 'section', 'article', or a heading like 'h1'. You can also omit the name field to use the default 'div'.

`editor-wrong-element-name`

The value supplied as the editable root tag name in config.root.element or config.roots.<rootName>.element is not a valid HTML tag name.

Valid HTML tag names start with a letter and contain only letters, digits, hyphens, or underscores (e.g. 'div', 'h1', 'my-element'; uppercase variants such as 'DIV' and 'H1' are also accepted). Whitespace, angle brackets, slashes, empty strings, and non-string values are not allowed.

`editorannotations-invalid-source-callback`

Function required.

`email-configuration-missing-export-inline-styles-plugin`

Warning shown when the ExportInlineStyles plugin is missing. While it is not required for the email integration to work, it is recommended to enable it to ensure that exported content has inlined styles. This is important as email clients do not work with external stylesheets, and most styling may be lost.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-missing-plain-table-output-plugin`

The PlainTableOutput plugin is required to use tables in the email integration. Without it, tables will not be rendered correctly and may not be displayed correctly in some email clients as the <figure> elements is not supported by most email clients.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-missing-source-editing-plugin`

The SourceEditing or SourceEditingEnhanced plugin is missing in the email integration. While it is not required for the email integration to work, it is recommended to enable it to ensure that the source code view is available for users. This is important for email developers who need to work with the source code directly.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-missing-table-layout-plugin`

The TableLayout plugin is required to use tables in the email integration. Tables in the editor may look and act than in email clients. This is why we have two separate plugins to handle different implementations of this feature.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-unsupported-color-format`

The color format specified in the editor configuration (such as for color pickers or other UI components) is not supported in email clients. Please use rgb or hex format instead.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-unsupported-color-value`

The specified color value uses a format not supported in email clients. This affects various color settings like fonts, backgrounds, borders, etc. Please use rgb() or #RRGGBB format instead.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-unsupported-list-item-marker-formatting`

It is recommended to avoid using list item marker formatting as it will not work in email clients. It is possible to disable this feature with the enableListItemMarkerFormatting: false switch in the list settings.

This warning is emitted by the email configuration helper While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-unsupported-plugin`

The plugin is not supported in email editing mode as it may not work correctly in email clients. The HTML output the plugin creates may not be recognized by email clients, rendering the elements incorrectly or not at all. It is encouraged to remove the plugin from the editor configuration to maintain compatibility.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`email-configuration-unsupported-reversed-list`

It is recommended to avoid using reversed lists as they may not work correctly in some email clients. It is possible to disable this feature with the reversed: true switch in the list properties settings.

This warning is emitted by the email configuration helper. While it is possible to disable these warnings using the email.warnings.suppress option, it is strongly discouraged.

`emoji-config-marker-already-used`

The marker in the emoji config is already used by other plugin configuration.

Parameters

marker: string: Used marker.

`emoji-repository-cdn-use`

It was detected that your installation uses a commercial license key, and the default CKEditor CDN for Emoji plugin data.

To avoid this, you can use the emoji.definitionsUrl configuration option to provide a URL to your own emoji repository.

If you want to suppress this warning, while using the default CDN, set this configuration option to cdn.

`emoji-repository-empty`

Unable to identify the available emoji to display.

See the troubleshooting section in the Emoji feature guide for more details.

`emoji-repository-load-failed`

Unable to load the emoji repository from the URL.

If the URL works properly and there is no disruption of communication, please check your Content Security Policy (CSP) setting and make sure the URL connection is allowed by the editor.

`emoji-repository-redundant-version`

Both emoji.definitionsUrl and emoji.version configuration options are set. Only the emoji.definitionsUrl option will be used.

The emoji.version option will be ignored and should be removed from the configuration.

`enableViewPlaceholder-deprecated-text-option`

The "text" option in the enableViewPlaceholder() function is deprecated and will be removed soon.

See the #view-element-placeholder section in the Update to v39.x section in the updating from older versions guide for more information on how to apply this change.

`error-saving-suggestion-data-suggestion-discarded`

An unexpected error happened when the suggestion data was being saved in the database. In order to avoid mismatch between document data and the suggestions database, the suggestion in the document has been automatically discarded.

`export-word-v1-api-is-deprecated`

You are using v1 API interface in the exportWord.converterOptions. Please update your config with a new version of Export Word API. See migration guide: https://docx-converter.cke-cs.com/v2/convert/docs#section/Export-to-Word/Migrating-from-v1

`filerepository-no-upload-adapter`

You need to enable an upload adapter in order to be able to upload files.

This warning shows up when FileRepository is being used without defining an upload adapter.

If you see this warning when using one of the now deprecated CKEditor 5 builds it means that you did not configure any of the upload adapters available by default in those builds.

Predefined builds are a deprecated solution and we strongly advise migrating to new installation methods.

See the comprehensive "Image upload overview" to learn which upload adapters are available in the builds and how to configure them.

Otherwise, if you see this warning, there is a chance that you enabled a feature like ImageUpload, or ImageUploadUI but you did not enable any upload adapter. You can choose one of the existing upload adapters listed in the "Image upload overview".

You can also implement your own image upload adapter.

`filerepository-read-wrong-status`

You cannot call read if the status is different than idle.

`filerepository-upload-wrong-status`

You cannot call upload if the status is different than idle.

`fileuploader-decoding-image-data-error`

Problem with decoding Base64 image data.

`fileuploader-missing-api-address`

Api address must be provided as the third argument.

`fileuploader-missing-file`

File must be provided as the first argument.

`fileuploader-missing-token`

Token must be provided as the second argument.

`fileuploader-uploading-data-failed`

Uploading file failed.

`focustracker-add-element-already-exist`

This element is already tracked by FocusTracker.

`focustracker-add-view-missing-element`

The View added to the FocusTracker does not have an element. Make sure the view is render before adding it to the focus tracker.

`font-size-invalid-definition`

Provided value as an option for FontSize seems to invalid.

See valid examples described in the plugin configuration.

`font-size-invalid-use-of-named-presets`

If config.fontSize.supportAllValues is true, you need to use numerical values as font size options.

See valid examples described in the plugin configuration.

Parameters

presets: Array<string>: Invalid values.

`footnotes-insertfootnotecommand-invalid-footnote-id`

Insert footnote command executed with invalid footnote id.

A valid footnote id is a non-empty string without spaces, that does not start with a digit.

`format-painter-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`format-painter-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`get-root-attributes-missing-root`

The requested root does not exist. Please ensure that the provided root name is correct and that the root has been properly initialized in the document.

`html-embed-provide-sanitize-function`

When using the HTML embed feature with the config.htmlEmbed.showPreviews set to true, it is strongly recommended to define a sanitize function that will clean up the input HTML in order to avoid XSS vulnerability.

For a detailed overview, check the HTML embed feature documentation.

`image-block-plugin-required`

The ImageBlock plugin must be enabled to allow inserting block images. See type to learn more.

`image-inline-plugin-required`

The ImageInline plugin must be enabled to allow inserting inline images. See type to learn more.

`image-insert-integration-exists`

There are two insert-image integrations registered with the same name.

Make sure that you do not load multiple asset manager plugins.

`image-insert-integrations-not-registered`

The image insert feature requires integrations to be registered by separate features.

The insertImage toolbar button requires integrations to be registered by other features. For example ImageUpload, ImageInsert, ImageInsertViaUrl, CKBox

`image-insert-integrations-not-specified`

The insert image feature requires a list of integrations to be provided in the editor configuration.

The default list of integrations is upload, assetManager, url. Those integrations are included in the insert image dropdown if the given feature plugin is loaded. You should omit the integrations configuration key to use the default set or provide a selected list of integrations that should be used.

`image-insert-unknown-integration`

The specified insert image integration name is unknown or the providing plugin is not loaded in the editor.

`image-style-configuration-definition-invalid`

The image style definition provided in the configuration is invalid.

Please make sure the definition implements properly one of the following:

Parameters

info: object: The information about the invalid definition.

`image-style-missing-dependency`

In order to work correctly, each image style option requires specific model elements (also: types of images) to be supported by the editor.

Model element names to which the image style option can be applied are defined in the modelElements property of the style option definition.

Explore the warning in the console to find out precisely which option is not supported and which editor plugins are missing. Make sure these plugins are loaded in your editor to get this image style option working.

Parameters

style: string: The name of the unsupported option.
missingPlugins: Array<string>: The names of the plugins one of which has to be loaded for the particular option.

`imageresizebuttons-missing-icon`

When configuring config.image.resizeOptions for standalone buttons, a valid icon token must be set for each option.

See all valid options described in the plugin configuration.

Parameters

option: ImageResizeOption: Invalid image resize option.

`import-word-plugin-conversion-failed`

An error occurred while importing the Word file. Check the response from the Cloud Services in the browser's network tab in the developer tools to find out the reason.

`import-word-plugin-import-cancelled`

The import procedure has been cancelled. The position, where the content of the Word file should be inserted, no longer exists, because the document structure has changed. Choose the position again and try to import the Word file again.

`inlineannotations-attach-already-attached`

Cannot attach the same annotation twice.

`inlineannotations-detach-not-attached`

Cannot detach a UI if it is not attached.

`inlineannotations-not-allowed-with-context`

The InlineAnnotations plugin is not allowed as a Context plugin. It can be used as an editor plugin only.

`insert-bookmark-command-executed-with-invalid-name`

Insert bookmark command can be executed only with a valid name.

A valid bookmark name must be a non-empty string and must not contain any spaces.

`insert-operation-position-invalid`

Insertion position is invalid.

`insertcontent-invalid-insertion-position`

An internal error occurred when merging inserted content with its siblings. The insertion position should equal the merge position.

If you encountered this error, report it back to the CKEditor 5 team with as many details as possible regarding the content being inserted and the insertion position.

`insertcontent-wrong-position`

Given node cannot be inserted on the given position.

Parameters

node: ModelNode: Node to insert.
position: ModelPosition: Position to insert the node at.

`insertobject-element-not-an-object`

Tried to insert an element with insertObject() function that is not defined as an object in schema. See SchemaItemDefinition. If you want to insert content that is not an object you might want to use insertContent() function.

`insertobject-invalid-place-parameter-value`

The unsupported options.setSelection parameter was passed to the insertObject() function. Check the insertObject() API documentation for allowed options.setSelection parameter values.

`invalid-date-time-format`

Date format must be a function.

`invalid-license-key`

The license key provided is invalid. Please ensure that it is copied correctly from the Customer Portal. If the issue persists, please contact our customer support.

`keyboard-unknown-key`

Unknown key name. Only key names included in the keyCodes can be used.

Parameters

key: string: Ths specified key name.

`license-key-development-limit`

You have exceeded the operation limit for your development license key within the editor. Please restart the editor to continue using it. Read more about license key types.

`license-key-domain-limit`

The provided license does not allow the editor to run on this domain. Some license keys are restricted to local test environments only. For more details, please refer to the license key type documentation.

`license-key-evaluation-limit`

You have exceeded the editor operation limit available for your evaluation license key. Please restart the editor to continue using it. Read more about license key types.

`license-key-expired`

Your license key has expired.

If you used our free trial, you either need to switch to open-source license, or in case of a commercial plan, change the trial key to production key or development key. Switching from trial, you also need to align the editor configuration to the features available in your plan.

If you already had one of our Cloud or Custom plans, please renew your license in the Customer Portal.

`license-key-feature-not-allowed`

The feature you are trying to use is not permitted under your current license. Please check the available features on the Customer Portal or contact support for more information.

Parameters

featureName: String: The feature you tried to use.

`license-key-invalid-distribution-channel`

Your license does not allow the current distribution channel.

These are the available distribution channels:

Self-hosted - the editor is installed via npm or from a ZIP package
Cloud - the editor is run from CDN

The licenses available include:

GPL license for open-source users.
Commercial plans (Cloud or sales-assisted).

The relation between distribution channels and licenses works as follows:

With the 'GPL' license key, you may use the editor installed via npm or a ZIP package (self-hosted).
With the CKEditor Cloud plans, you may use the editor via our CDN.
With the CKEditor Custom plans, depending on your plan details, you can use the editor via npm or a ZIP package (self-hosted) or Cloud (CDN).

Read more about distributions in the documentation. Please verify your installation or contact support for assistance. Should you need to migrate your installation from npm to CDN, please refer to our dedicated migration guides.

`license-key-lts-not-allowed`

You are running CKEditor 5 Long-term Support Edition (LTS), but the provided license key does not include access to the LTS version, or the key is invalid.

Please ensure that it is copied correctly from the Customer Portal, and if the issue persists, please contact our customer support.

In case you intended to use the LTS Edition, but have not yet made a purchase, please contact our sales team

If you did not intend to use LTS, please note that all releases in the v47.7 line are for LTS subscribers only. To use a non-LTS edition, either upgrade to v48 or newer, which is our standard latest release line, or stay on a version 47.6.2 or earlier.

`license-key-missing`

The licenseKey property is missing in the editor configuration.

If you are using the editor in a commercial setup, please provide your license key.
If you still need to acquire a key, please contact us or create a free account with a 14 day premium features trial.
If you are using the editor under a GPL license or another license from our Open Source Initiative, use the 'GPL' license key instead.

ClassicEditor.create( {
	attachTo: document.querySelector( '#editor' ),
	licenseKey: '<YOUR_LICENSE_KEY>', // Or 'GPL'.
	// ... Other configuration options ...
} ) ;

`license-key-plugin-not-allowed`

The plugin you are trying to use is not permitted under your current license. Please check the available features on the Customer Portal or contact support for more information.

Parameters

pluginName: String: The plugin you tried to load.

`license-key-trial-limit`

You have exceeded the editor operation limit for your trial license key. Please restart the editor to continue using it. Read more about license key types.

`license-key-usage-limit`

You have reached the usage limit of your license key. This can occur in the following situations:

You are on a free subscription without a connected payment method and have exceeded the allowed usage threshold.
Your account has overdue invoices and the grace period has ended.

To extend the limit and restore access, please update the required details in the Customer Portal or contact our customer support.

`license-key-validation-endpoint-not-reachable`

Your license key cannot be validated due to a network issue. Please ensure that your setup does not block requests to the validation endpoint.

Parameters

url: string: The URL that was attempted to be reached for validation.

`list-feature-conflict`

The List feature cannot be loaded together with the LegacyList plugin.

Parameters

conflictPlugin: string: Name of the plugin.

`locale-deprecated-language-property`

The Locale#language property was deprecated and will be removed in the near future. Please use the Locale#uiLanguage and Locale#contentLanguage properties instead.

`mapping-model-offset-not-found`

A model position could not be mapped to the view because specified model offset was too big and could not be found inside the mapped view element or view document fragment.

`mapping-model-position-view-parent-not-found`

A model position could not be mapped to the view because the parent of the model position does not have a mapped view element (might have not been converted yet or it has no converter).

Make sure that the model element is correctly converted to the view.

`marker-destroyed`

Cannot use a destroyed marker instance.

`markercollection-incorrect-marker-name`

Marker name cannot contain the "," character.

`markercollection-refresh-marker-not-exists`

Marker with provided name does not exists.

`matcher-pattern-deprecated-attributes-class-key`

The key-value matcher pattern for attributes option is using deprecated class key.

Use classes matcher pattern option instead:

// Instead of:
const pattern = {
	attributes: {
		key1: 'value1',
		key2: 'value2',
		class: 'foobar'
	}
}

// Use:
const pattern = {
	attributes: {
		key1: 'value1',
		key2: 'value2'
	},
	classes: 'foobar'
}

Refer to the #update-to-ckeditor-5-v2910 paragraph in the Update to v29.x guide in the updating from older versions guide and the MatcherPattern documentation.

Parameters

pattern: any: Pattern with missing properties.

`matcher-pattern-deprecated-attributes-style-key`

The key-value matcher pattern for attributes option is using deprecated style key.

Use styles matcher pattern option instead:

// Instead of:
const pattern = {
	attributes: {
		key1: 'value1',
		key2: 'value2',
		style: /^border.*$/
	}
}

// Use:
const pattern = {
	attributes: {
		key1: 'value1',
		key2: 'value2'
	},
	styles: /^border.*$/
}

Refer to the #update-to-ckeditor-5-v2910 section in the Update to v29.x section in the updating from older versions guide and MatcherPattern documentation.

Parameters

pattern: any: Pattern with missing properties.

`matcher-pattern-missing-key-or-value`

The key-value matcher pattern is missing key or value. Both must be present. Refer the documentation: MatcherPattern.

Parameters

pattern: any: Pattern with missing properties.

`media-embed-no-provider-name`

One of the providers (or extra providers) specified in the media embed configuration has no name and will not be used by the editor. In order to get this media provider working, double check your editor configuration.

`media-style-configuration-definition-invalid`

The media style configuration provided in the editor config is invalid. The warning is emitted in two situations:

An entry in config.mediaEmbed.styles.options does not reference a built-in style by name ('alignLeft', 'alignBlockLeft', 'alignCenter', 'alignBlockRight', 'alignRight') and does not follow the MediaStyleOptionDefinition shape — name, title, icon, and (unless isDefault: true) className are required. The offending entry is reported under the style parameter.
A dropdown entry placed inline in config.mediaEmbed.toolbar does not follow the MediaStyleDropdownDefinition shape (name and every items[] entry must use the full mediaEmbed: prefix, defaultItem must be one of the items, title must be a non-empty string), or its items[] reference styles that are not in the resolved config.mediaEmbed.styles list. The offending entry is reported under the dropdown parameter.

`mediaembedresizebuttons-missing-icon`

When configuring resizeOptions * config.mediaEmbed.resizeOptions} for standalone buttons, a valid icon token must be set for each option.

See all valid options described in the plugin configuration.

Parameters

option: MediaEmbedResizeOption: Invalid media embed resize option.

`mention-feed-callback-error`

The callback used for obtaining mention autocomplete feed thrown and error and the mention UI was hidden or not displayed at all.

`mentioncommand-incorrect-id`

The feed item ID must start with the marker character(s).

Correct mention feed setting:

mentions: [
	{
		marker: '@',
		feed: [ '@Ann', '@Barney', ... ]
	}
]

Incorrect mention feed setting:

mentions: [
	{
		marker: '@',
		feed: [ 'Ann', 'Barney', ... ]
	}
]

See MentionConfig.

`mentionconfig-incorrect-marker`

The marker must be a single character.

Correct markers: '@', '#'.

Incorrect markers: '$$', '[@'.

See MentionConfig.

Parameters

marker: string: Configured marker

Adding unsupported components to the MenuBarView is not possible.

A component should be either a MenuBarMenuView (sub-menu) or a MenuBarMenuListItemButtonView (button).

Parameters

componentName: string: A name of the unsupported component used in the configuration.
componentView: View: An unsupported component view.

There was a problem processing the configuration of the menu bar. The item with the given name does could not be removed from the menu bar configuration.

This warning usually shows up when the Plugin which is supposed to provide a menu bar item has not been loaded or there is a typo in the menu bar configuration.

Parameters

menuBarConfig: any: The full configuration of the menu bar.
itemName: any: The name of the item that was not removed from the menu bar.

There was a problem processing the configuration of the menu bar. The configured item could not be added because the position it was supposed to be added to does not exist.

This warning usually shows up when the Plugin which is supposed to provide a menu bar item has not been loaded or there is a typo in the menu bar configuration.

Parameters

menuBarConfig: object: The full configuration of the menu bar.
addedItemConfig: object: The name of the item that was not removed from the menu bar.

There was a problem processing the configuration of the menu bar. The item with the given name does not exist so it was omitted when rendering the menu bar.

This warning usually shows up when the Plugin which is supposed to provide a menu bar item has not been loaded or there is a typo in the menu bar configuration.

Make sure the plugin responsible for this menu bar item is loaded and the menu bar configuration is correct, e.g. BoldUI is loaded for the 'menuBar:bold' menu bar item.

Parameters

menuBarConfig: object: The full configuration of the menu bar.
parentMenuConfig: object: The config of the menu the unavailable component was defined in.
componentName: string: The name of the unavailable component.

There was a problem processing the configuration of the menu bar. One of the menus is empty so it was omitted when rendering the menu bar.

This warning usually shows up when some plugins responsible for providing menu bar items have not been loaded and the menu bar configuration was not updated.

Make sure all necessary editor plugins are loaded and/or update the menu bar configuration to account for the missing menu items.

Parameters

menuBarConfig: object: The full configuration of the menu bar.
emptyMenuConfig: object: The definition of the menu that has no child items.

`merge-fields-data-set-not-found`

The requested data set was not found.

`merge-fields-duplicate-data-set-id`

Data set ids must be unique.

`merge-fields-duplicate-group-id`

Merge field group ids must be unique.

`merge-fields-duplicate-merge-field-id`

Merge field ids must be unique.

`merge-fields-invalid-id`

Merge field ids can contain only alphanumeric characters, dots, underscores, and hyphens.

`merge-fields-invalid-prefix-or-suffix`

The merge field prefix and suffix can only contain the following characters: '"`!#%:;=@{}~$()*+/?[\]^|.

`merge-fields-invalid-preview-mode-set`

The preview mode that was tried to be set was not available. See the preview modes configuration for more information.

`merge-fields-invalid-preview-modes-configuration`

Invalid preview modes definition. It should be a non-empty array, with one or more of the following values: '$labels', '$defaultValues' and '$dataSets'.

`merge-fields-prefix-and-suffix-must-differ`

Merge field prefix and suffix must be different.

`merge-fields-prefix-or-suffix-too-long`

The merge field prefix and suffix cannot be longer than 8 characters.

`merge-fields-provide-sanitize-function`

When using the merge fields feature with the config.mergeFields.previewHtmlValues set to true, it is strongly recommended to define a sanitize function that will clean up the input HTML in order to avoid XSS vulnerability.

For a detailed overview, check the Merge fields feature documentation.

`merge-operation-how-many-invalid`

Merge operation specifies wrong number of nodes to move.

`merge-operation-source-position-invalid`

Merge source position is invalid. The element to be merged must have a parent node.

`merge-operation-target-position-invalid`

Merge target position is invalid. The element to be merged must have a parent node.

`model-createpositionat-offset-required`

Model#createPositionAt() requires the offset to be specified when the first parameter is a model item.

`model-document-createroot-name-exists`

A root with the specified name already exists.

`model-document-history-addoperation-incorrect-version`

Only operations with matching versions can be added to the history.

Parameters

operation: Operation: The current operation.
historyVersion: number: The current document history version.

`model-liveposition-no-model-reference`

LivePosition's root has to be an instance of ModelRootElement or have a reference to a model instance.

`model-liverange-no-model-reference`

LiveRange's root has to be an instance of ModelRootElement or have a reference to a model instance.

`model-nodelist-index-out-of-bounds`

Given index cannot be found in the node list.

`model-nodelist-insertnodes-not-node`

Trying to insert an object which is not a Node instance.

`model-nodelist-offset-out-of-bounds`

Given offset cannot be found in the node list.

Parameters

offset: number: The offset value.
nodeList: ModelNodeList: Stringified node list.

`model-position-after-root`

You cannot make a position after a root element.

Parameters

root: ModelRootElement: The root element..

`model-position-before-root`

You cannot make a position before a root element.

Parameters

root: ModelRootElement: The root element..

`model-position-fromjson-no-root`

Cannot create position for document. Root with specified name does not exist.

Parameters

rootName: string: The root name.

`model-position-parent-incorrect`

Position parent have to be a model element or model document fragment.

`model-position-path-incorrect`

The position's path is incorrect. This means that a position does not point to a correct place in the tree and hence, some of its methods and getters cannot work correctly.

Note: Unlike DOM and view positions, in the model, the position's parent is always an element or a document fragment. The last offset in the position's path is the point in this element where this position points.

Read more about model positions and offsets in the Editing engine architecture guide.

Parameters

position: ModelPosition: The incorrect position.

`model-position-path-incorrect-format`

Position path must be an array with at least one item.

Parameters

path: Array<number>: A path to the position.

`model-position-root-invalid`

Position root is invalid.

Positions can only be anchored in elements or document fragments.

`model-selection-range-intersects`

Trying to add a range that intersects with another range in the selection.

Parameters

addedRange: ModelRange: Range that was added to the selection.
intersectingRange: ModelRange: Range in the selection that intersects with addedRange.

`model-selection-set-ranges-not-range`

Selection range set to an object that is not an instance of ModelRange.

Only ModelRange instances can be used to set a selection. Common mistakes leading to this error are:

using DOM Range object,
incorrect CKEditor 5 installation with multiple ckeditor5-engine packages having different versions.

`model-selection-setfocus-no-ranges`

Cannot set selection focus if there are no ranges in selection.

`model-selection-setto-not-selectable`

Cannot set the selection to the given place.

Invalid parameters were specified when setting the selection. Common issues:

A ModelTextProxy instance was passed instead of a real ModelText.
View nodes were passed instead of model nodes.
null/undefined was passed.

`model-selection-setto-required-second-parameter`

selection.setTo requires the second parameter when the first parameter is a node.

`model-textproxy-wrong-length`

Given length value is incorrect.

`model-textproxy-wrong-offsetintext`

Given offsetInText value is incorrect.

`model-tree-walker-no-start-position`

Neither boundaries nor starting position of a TreeWalker have been defined.

`model-tree-walker-unknown-direction`

Only backward and forward direction allowed.

`model-writer-insert-forbidden-move`

Cannot move a node from a document to a different tree. It is forbidden to move a node that was already in a document outside of it.

`move-operation-node-into-itself`

Trying to move a range of nodes into one of nodes from that range.

`move-operation-nodes-do-not-exist`

The nodes which should be moved do not exist.

`move-operation-range-into-itself`

Trying to move a range of nodes into the middle of that range.

`multi-level-list-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`multi-level-list-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`multi-root-editor-add-root-element-is-not-limit`

The model root element must be a limit element. The element name specified in addRoot() options must be registered in the schema with isLimit set to true.

Parameters

rootName: any: The name of the root that uses a non-limit element.
elementName: any: The name of the model element used for the root.

`multi-root-editor-add-root-element-option-ignored`

Passing an existing DOM element as the element option of addRoot() is not supported and will be ignored. The addRoot() method only registers the model root; the DOM editable is created later by createEditable().

Pass a tag name string (e.g. 'h1') or a view element definition instead, or omit the option to create a default <div>.

`multi-root-editor-cannot-disable-graveyard-root`

You cannot disable the $graveyard root.

`multi-root-editor-load-root-already-loaded`

The root to load was already loaded before. The loadRoot() call has no effect.

`multi-root-editor-load-root-no-root`

The root to load does not exist.

`multi-root-editor-root-attributes-conflict`

Trying to set attributes using deprecated config.rootsAttributes on a root that has already defined attributes using config.roots.<rootName>.modelAttributes.

`multi-root-editor-root-attributes-no-root`

Trying to set attributes on a non-existing root.

Roots specified in legacy config.rootsAttributes do not match initial editor roots. Use config.roots.<rootName>.modelAttributes instead.

`multi-root-editor-root-attributes-no-root`

Trying to set attributes on a non-existing root.

Roots specified in config.rootsAttributes do not match initial editor roots.

`multi-root-editor-root-deprecated-config-lazy-roots`

Using deprecated config.lazyRoots configuration option. Use config.roots.<rootName>.lazyLoad instead.

`multi-root-editor-root-initial-data-mismatch`

Editor roots do not match the initialData configuration.

This may happen for one of the two reasons:

Configuration error. The sourceElementsOrData parameter in MultiRootEditor.create() contains different roots than initialData configuration.
As the editor was initialized, the initialData configuration value or the state of the editor roots has been changed.

`narrowsidebar-attach-already-attached`

Cannot attach narrow sidebar twice.

`narrowsidebar-detach-not-attached`

Cannot detach not attached sidebar.

`no-operations-provided`

The compressor cannot compress operations because no operation was provided.

`observable-bind-duplicate-properties`

Properties must be unique.

`observable-bind-rebind`

Cannot bind the same property more than once.

`observable-bind-to-extra-callback`

Cannot bind multiple properties and use a callback in one binding.

`observable-bind-to-many-not-one-binding`

Binding one attribute to many observables only possible with one attribute.

`observable-bind-to-no-callback`

Binding multiple observables only possible with callback.

`observable-bind-to-parse-error`

Invalid argument syntax in to().

`observable-bind-to-properties-length`

The number of properties must match.

`observable-bind-wrong-properties`

All properties must be strings.

`observable-set-cannot-override`

Cannot override an existing property.

This error is thrown when trying to set a property with a name of an already existing property. For example:

let observable = new Model();
observable.property = 1;
observable.set( 'property', 2 );			// throws

observable.set( 'property', 1 );
observable.set( 'property', 2 );			// ok, because this is an existing property.

`observable-unbind-wrong-properties`

Properties must be strings.

`observablemixin-cannot-decorate-undefined`

Cannot decorate an undefined method.

Parameters

object: object: The object which method should be decorated.
methodName: string: Name of the method which does not exist.

`operation-utils-move-range-not-flat`

Trying to move a range which starts and ends in different element.

`operation-utils-remove-range-not-flat`

Trying to remove a range which starts and ends in different element.

`pagination-config-not-found`

The configuration required by the pagination plugin is missing. Follow the instructions provided in Pagination feature documentation to initialize the plugin properly.

Parameters

config: EditorConfig: Configuration of the editor.

`pagination-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`pagination-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`paste-from-office-enhanced-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`paste-from-office-enhanced-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`pendingactions-add-invalid-message`

The message must be a string.

`permissions-set-permissions-invalid-channel-id`

Trying to set permissions for a channelId that does not exist.

`plugin-load *`

The CKEditor error class.

You should throw CKEditorError when:

An unexpected situation occurred and the editor (most probably) will not work properly. Such exception will be reported to the callbacks registered with onEditorError(),
If the editor is incorrectly integrated or the editor API is used in the wrong way. This way you will give feedback to the developer as soon as possible. Keep in mind that for common integration issues which should not stop editor initialization (like missing upload adapter, wrong name of a toolbar component) we use logWarning() and logError() to improve developers experience and let them see the a working editor as soon as possible.

/**
 * Error thrown when a plugin cannot be loaded due to JavaScript errors, lack of plugins with a given name, etc.
 *
 *

Parameters

pluginName: any

The name of the plugin that could not be loaded. *

moduleName: any

The name of the module which tried to load this plugin. */ throw new CKEditorError( 'plugin-load', { pluginName: 'foo', moduleName: 'bar' } );

`plugin-obsolete-documentlist`

The DocumentList plugin is obsolete. Use List instead.

`plugin-obsolete-documentlistproperties`

The DocumentListProperties plugin is obsolete. Use ListProperties instead.

`plugin-obsolete-tododocumentlist`

The TodoDocumentList plugin is obsolete. Use TodoList instead.

`plugincollection-context-required`

If a plugin is a context plugin, all plugins it requires should also be context plugins instead of plugins. In other words, if one plugin can be used in the context, all its requirements should also be ready to be used in the context. Note that the context provides only a part of the API provided by the editor. If one plugin needs a full editor API, all plugins which require it are considered as plugins that need a full editor API.

Parameters

plugin: string: The name of the required plugin.
requiredBy: string: The name of the parent plugin.

`plugincollection-plugin-for-replacing-cannot-have-dependencies`

The plugin replacing an existing plugin cannot depend on other plugins.

Parameters

pluginName: string: The name of the plugin.

`plugincollection-plugin-for-replacing-not-exist`

The replaced plugin does not exist in the available plugins collection.

Parameters

pluginName: string: The name of the plugin.

`plugincollection-plugin-for-replacing-not-loaded`

The replaced plugin will not be loaded so it cannot be replaced.

Parameters

pluginName: string: The name of the plugin.

`plugincollection-plugin-invalid-constructor`

The provided class constructor is not a plugin.

This error is usually caused by passing an editor, context, or command constructor in the config.plugins array.

Parameters

name: String: The name of the provided constructor.

`plugincollection-plugin-name-conflict`

Two plugins with the same pluginName were loaded. This will lead to runtime conflicts between these plugins.

In practice, this warning usually means that new plugins were added to an existing CKEditor 5 build. Plugins should always be added to a source version of the editor (@ckeditor/ckeditor5-editor-*), not to an editor imported from one of the @ckeditor/ckeditor5-build-* packages.

Check your import paths and the list of plugins passed to Editor.create() or specified in Editor.builtinPlugins.

Predefined builds are a deprecated solution and we strongly advise migrating to new installation methods.

The second option is that your node_modules/ directory contains duplicated versions of the same CKEditor 5 packages. Normally, on clean installations, npm deduplicates packages in node_modules/, so it may be enough to call rm -rf node_modules && npm i. However, if you installed conflicting versions of some packages, their dependencies may need to be installed in more than one version which may lead to this warning.

Technically speaking, this error occurs because after adding a plugin to an existing editor build the dependencies of this plugin are being duplicated. They are already built into that editor build and now get added for the second time as dependencies of the plugin you are installing.

Parameters

pluginName: string: The duplicated plugin name.
plugin1: PluginConstructor: The first plugin constructor.
plugin2: PluginConstructor: The second plugin constructor.

`plugincollection-plugin-not-found`

A plugin is not available and could not be loaded.

Plugin classes (constructors) need to be provided to the editor before they can be loaded by name. This is usually done in the now deprecated CKEditor 5 builds by setting the builtinPlugins property.

If you see this warning when using one of the deprecated CKEditor 5 Builds, it means that you tried to enable a plugin that was not included in that build. This may be due to a typo in the plugin name or simply because that plugin was not a part of this build.

Predefined builds are no longer supported and you need to migrate to new installation methods.

If you see this warning when using one of the editor creators directly (not a build), then it means that you tried loading plugins by name. However, unlike CKEditor 4, CKEditor 5 does not implement a "plugin loader". This means that CKEditor 5 does not know where to load the plugin modules from. Therefore, you need to provide each plugin through a reference (as a constructor function). Check out the examples in the Quick start guide.

Parameters

plugin: string: The name of the plugin which could not be loaded.

`plugincollection-plugin-not-loaded`

The plugin is not loaded and could not be obtained.

Plugin classes (constructors) need to be provided to the editor and must be loaded before they can be obtained from the plugin collection.

Note: You can use editor.plugins.has() to check if a plugin was loaded.

Parameters

plugin: string: The name of the plugin which is not loaded.

`plugincollection-replace-plugin-invalid-type`

The plugin replacing an existing plugin must be a function.

Parameters

pluginItem: never: The plugin item.

`plugincollection-replace-plugin-missing-name`

The plugin replacing an existing plugin must have a name.

Parameters

pluginItem: PluginConstructor: The plugin item.

`plugincollection-replaced-plugin-cannot-have-dependencies`

The replaced plugin cannot depend on other plugins.

Parameters

pluginName: string: The name of the plugin.

`plugincollection-required`

Cannot load a plugin because one of its dependencies is listed in the removePlugins option.

Parameters

plugin: string: The name of the required plugin.
requiredBy: string: The name of the parent plugin.

`plugincollection-soft-required`

A required "soft" dependency was not found on the plugin list.

When configuring the editor, either prior to building (via Editor.builtinPlugins) or when creating a new instance of the editor (e.g. via config.plugins), you need to provide some of the dependencies for other plugins that you used.

This error is thrown when one of these dependencies was not provided. The name of the missing plugin can be found in missingPlugin and the plugin that required it in requiredBy.

In order to resolve it, you need to import the missing plugin and add it to the current list of plugins (Editor.builtinPlugins or config.plugins/config.extraPlugins).

Soft requirements were introduced in version 26.0.0. If you happen to stumble upon this error when upgrading to version 26.0.0, read also the Update to v26.x section in the updating from older versions guide.

Parameters

missingPlugin: string: The name of the required plugin.
requiredBy: string: The name of the plugin that requires the other plugin.

`presencelist-collapseat-invalid-format`

The config.presenceList.collapseAt configuration value must be a number greater than 0.

`presencelist-missing-container`

Missing container element for the presence list. Please make sure config.presenceList.container is set and refers to an existing DOM element.

`protobuffactory-cannot-get-descriptor-before-build`

Cannot get a descriptor before building ProtobufFactory.

`range-create-from-ranges-empty-array`

At least one range has to be passed to Range._createFromRanges().

`realtimecollaborationclient-editor-setdata-and-editor-data-set-are-forbidden-in-real-time-collaboration`

Trying to use editor.setData() or editor.data.set() in real-time collaboration. Re-setting data in real-time collaboration usually means a mistake (incorrect integration or plugin). Using it may overwrite local (not yet synchronized) changes on remote clients. If you tried to set editor initial data, use initialData configuration option instead. If you tried to set editor data in a plugin, consider applying the changes through the Writer in a model.change() block. If you understand effects of using editor.data.set() in real-time collaboration and want to suppress this error, set suppressErrorInCollaboration flag to true in the second parameter of editor.data.set() call: editor.data.set( '<p>Your data</p>', { suppressErrorInCollaboration: true } ).

`realtimecollaborationclient-handleserverresponse`

Server response error.

`realtimecollaborationclient-init-document-already-initialized`

Trying to set initial data to initialized document.

`realtimecollaborationclient-init-non-existent-root`

Attempting to init data on a non-existing root.

`realtimecollaborationclient-init-service-internal-error`

Internal CollaborativeEditingService error.

`realtimecollaborationclient-init-session-connection-error`

Connecting to the session resulted in an error.

`rename-operation-wrong-name`

Element to change has different name than operation's old name.

`rename-operation-wrong-position`

Given position is invalid or node after it is not instance of Element.

`revision-history-missing-configuration`

Configuration for revision history plugin is missing.

Please refer to documentation to learn how to set up the plugin.

`rootattribute-operation-attribute-exists`

The attribute with given key already exists for the given node.

Parameters

root: ModelRootElement: The root element.
key: string: The key of the attribute.

`rootattribute-operation-fromjson-no-root`

Cannot create RootAttributeOperation for document. Root with the specified name does not exist.

Parameters

rootName: string: The root name.

`rootattribute-operation-not-a-root`

The element to change is not a root element.

Parameters

root: ModelRootElement: The root element.
key: string: The key of the attribute.

`rootattribute-operation-wrong-old-value`

The attribute which should be removed does not exist for the given node.

Parameters

root: ModelRootElement: The root element.
key: string: The key of the attribute.

`schema-cannot-extend-missing-item`

Cannot extend an item which was not registered yet.

This error happens when a plugin tries to extend the schema definition of an item which was not registered yet.

Parameters

itemName: any: The name of the model element which is being extended.

`schema-cannot-register-item-twice`

A single item cannot be registered twice in the schema.

This situation may happen when:

Two or more plugins called register() with the same name. This will usually mean that there is a collision between plugins which try to use the same element in the model. Unfortunately, the only way to solve this is by modifying one of these plugins to use a unique model element name.
A single plugin was loaded twice. This happens when it is installed by npm/yarn in two versions and usually means one or more of the following issues:
- a version mismatch (two of your dependencies require two different versions of this plugin),
- incorrect imports (this plugin is somehow imported twice in a way which confuses webpack),
- mess in node_modules/ (rm -rf node_modules/ may help).

Note: Check the logged itemName to better understand which plugin was duplicated/conflicting.

Parameters

itemName: any: The name of the model element that is being registered twice.

`schema-check-merge-no-element-after`

The node after the merge position must be an element.

`schema-check-merge-no-element-before`

The node before the merge position must be an element.

`sessions-register-already-registered`

Sessions of given channelId already registered.

`sessions-unregister-not-exist`

Cannot unregister not registered sessions.

Missing container element.

Container element is not a HTMLElement.

`simple-upload-adapter-missing-uploadurl`

The config.simpleUpload.uploadUrl configuration required by the SimpleUploadAdapter is missing. Make sure the correct URL is specified for the image upload to work properly.

`slash-command-execute-missing`

Either execute or commandName has to be specified in SlashCommandDefinition.

`slash-command-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`slash-command-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`source-editing-enhanced-incompatible-with-real-time-collaboration`

Source editing enhanced feature is not fully compatible with real-time collaboration, and using it may lead to data loss. Please read source editing enhanced feature guide to learn more.

If you understand the possible risk of data loss, you can enable the source editing enhanced by setting the allowCollaborationFeatures configuration flag to true.

`source-editing-incompatible-with-real-time-collaboration`

Source editing feature is not fully compatible with real-time collaboration, and using it may lead to data loss. Please read source editing feature guide to learn more.

If you understand the possible risk of data loss, you can enable the source editing by setting the allowCollaborationFeatures configuration flag to true.

`special-character-invalid-group-name`

The name "All" for a special category group cannot be used because it is a special category that displays all available special characters.

`special-character-invalid-order-group-name`

One of the special character groups in the "specialCharacters.order" configuration doesn't exist.

`split-operation-graveyard-position-invalid`

Graveyard position invalid.

`split-operation-how-many-invalid`

Split operation specifies wrong number of nodes to move.

`split-operation-position-invalid`

Split position is invalid.

`split-operation-split-in-root`

Cannot split root element.

`style-command-executed-with-incorrect-style-name`

Style command can be executed only with a correct style name.

This warning may be caused by:

passing a name that is not specified in the configuration (e.g. a CSS class name),
when trying to apply a style that is not allowed on a given element.

`table-of-contents-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`table-of-contents-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`tableslot-getter-removed`

This TableSlot's getter (property) was removed in CKEditor 5 v20.0.0.

Check out the new TableWalker's API in the documentation.

`tableutils-insertrows-insert-out-of-range`

The options.at points at a row position that does not exist.

`tableutils-removerows-row-index-out-of-range`

The options.at param must point at existing row and options.rows must not exceed the rows in the table.

`template-extend-render`

Extending a template after rendering may not work as expected. To make sure the extending works for an element, make sure it happens before render is called.

`template-invalid-license-key`

Invalid license key. Please contact our customer support at https://ckeditor.com/contact/.

`template-trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`title-no-supported-root`

The Title feature was loaded, but none of the editor's roots supports the title element. The feature only operates on roots whose modelElement is the default $root; roots configured with a custom modelElement (including $inlineRoot) are silently skipped, so getTitle() / getBody() fall back to the regular data getter and no title structure is ever inserted.

To use the Title feature, ensure at least one root uses the default $root model element. Otherwise, remove the Title plugin from this editor's plugin list.

`token-cannot-download-new-token`

Cannot download new token from the provided url.

`token-missing-token-url`

A tokenUrl must be provided as the first constructor argument.

`token-not-in-jwt-format`

The provided token must follow the JSON Web Tokens format.

`token-refresh-failed`

You will see this warning when the CKEditor token could not be refreshed. This may be a result of a network error, a token endpoint (server) error, or an invalid token URL configuration.

If this warning repeats, please make sure that the configuration is correct and that the token endpoint is up and running. Learn more about token configuration.

Note: If the token's auto refresh option is enabled, attempts to refresh will be made until success or token's destruction.

Parameters

autoRefresh: boolean: Whether the token will keep auto refreshing.

`toolbarview-item-unavailable`

There was a problem processing the configuration of the toolbar. The item with the given name does not exist so it was omitted when rendering the toolbar.

This warning usually shows up when the Plugin which is supposed to provide a toolbar item has not been loaded or there is a typo in the toolbar configuration.

Make sure the plugin responsible for this toolbar item is loaded and the toolbar configuration is correct, e.g. Bold is loaded for the 'bold' toolbar item.

You can use the following snippet to retrieve all available toolbar items:

Array.from( editor.ui.componentFactory.names() );

Parameters

item: string: The name of the component or nested toolbar definition.

`toolbarview-item-unavailable *`

Logs a warning to the console with a properly formatted message and adds a link to the documentation. Use whenever you want to log a warning to the console.

/**
 * There was a problem processing the configuration of the toolbar. The item with the given
 * name does not exist, so it was omitted when rendering the toolbar.
 *
 *

Parameters

name: String: The name of the component.
errorName: any: The error name to be logged.
data: any: Additional data to be logged.

`toolbarview-item-unavailable *`

Logs an error to the console with a properly formatted message and adds a link to the documentation. Use whenever you want to log an error to the console.

/**
 * There was a problem processing the configuration of the toolbar. The item with the given
 * name does not exist, so it was omitted when rendering the toolbar.
 *
 *

Parameters

name: String: The name of the component.
errorName: any: The error name to be logged.
data: any: Additional data to be logged.

`toolbarview-line-break-ignored-when-grouping-items`

The toolbar multiline breaks (- items) only work when the automatic button grouping is disabled in the toolbar configuration. To do this, set the shouldNotGroupWhenFull option to true in the editor configuration:

const config = {
	toolbar: {
		items: [ ... ],
		shouldNotGroupWhenFull: true
	}
}

Learn more about toolbar configuration.

A dropdown definition in the toolbar configuration is missing a text label.

Without a label, the dropdown becomes inaccessible to users relying on assistive technologies. Make sure the label property is set in your drop-down configuration:

{
 	label: 'A human-readable label',
	icon: '...',
	items: [ ... ]
 },

Learn more about toolbar configuration.

`track-changes-accept-suggestion-not-found`

Suggestion to accept does not exist.

`track-changes-adapter-already-set`

Cannot set an adapter more than once.

`track-changes-adapter-missing-getsuggestion`

Adapter not set or is missing getSuggestion() method.

`track-changes-command-not-found`

Trying to enable command that does not exist.

`track-changes-data-invalid-editor-creator`

Editor creator has to be a function.

`track-changes-discard-suggestion-not-found`

Suggestion to discard does not exist.

`track-changes-enable-command-twice`

Trying to enable the same command twice.

`track-changes-suggestion-data-mismatch`

Suggestion marker data does not match loaded suggestion data.

`track-changes-suggestion-not-found`

Suggestion with given id not found.

`track-changes-user-not-found`

User with the ID specified in suggestion authorId property not found.

`translation-service-quantity-not-a-number`

An incorrect value was passed to the translation function. This was probably caused by an incorrect message interpolation of a plural form. Note that for messages supporting plural forms the second argument of the t() function should always be a number or an array with a number as the first element.

`trial-license-key-reached-limit-changes`

You have exhausted the trial usage limit (reason: reached document changes limit). Restart the editor.

Please contact our customer support to get full access at https://ckeditor.com/contact/.

`trial-license-key-reached-limit-revisions`

You have exhausted the trial usage limit (reason: reached revisions number limit).

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`trial-license-key-reached-limit-time`

You have exhausted the trial usage limit (reason: reached time limit). Restart the editor.

Please contact our customer support to get a full access at https://ckeditor.com/contact/.

`trusted-types-policy-creation-failed`

The editor could not create the Trusted Types policy that it needs to write HTML into the DOM. Without the policy it can only write plain strings, which the require-trusted-types-for 'script' CSP directive rejects, so the editor cannot start.

The browser refuses to create the policy for two reasons:

The trusted-types CSP directive does not list the ckeditor5 policy name. Add it to that directive, next to any names that are already there:
```
Content-Security-Policy: require-trusted-types-for 'script'; trusted-types ckeditor5 lit-html;
```
Copy code
Something else in the same document already created a policy with that name. Let that code use a different name, or allow the name to be taken twice:
```
Content-Security-Policy: require-trusted-types-for 'script'; trusted-types ckeditor5 lit-html 'allow-duplicates';
```
Copy code

For a detailed overview, check the Content Security Policy guide.

The child view of a dropdown is missing the focus() method and could not be focused when the dropdown got open.

Making the content of a dropdown focusable in this case greatly improves the accessibility. Please make the view instance implements the focusable interface for the best user experience.

Parameters

view: View: Child to focus.

The child view of a dropdown could not be focused because it is missing the focus() method.

This warning appears when a dropdown gets open and it attempts to focus the first child of its panel but the child does not implement the focusable interface.

Focusing the content of a dropdown on open greatly improves the accessibility. Please make sure the view instance provides the focus() method for the best user experience.

Parameters

childView: View: Child view.
dropdownPanel: DropdownPanelView: A parent of a child.

`ui-iconview-invalid-svg`

The provided icon content is not a valid SVG.

`ui-overlay-container-not-configured`

The editor UI is rendered inside a shadow root but config.ui.overlayContainer is not configured. In this case the overlay layer (balloons, dialogs, tooltips) is mounted automatically into the shadow root hosting the editing root.

Such an automatically chosen container inherits the layout of the shadow host and its ancestors. If any of them creates a containing block or a stacking context – for example it has position: relative, overflow: hidden, a transform, or a low z-index – the floating UI may be misplaced, clipped, or rendered underneath other content of the page.

To make sure the floating UI behaves correctly, set the overlay container explicitly. See the config.ui.overlayContainer documentation to learn where such a container should be located. Configuring it also silences this warning.

Parameters

shadowRoot: ShadowRoot: The shadow root the editor UI was detected in.

`ui-overlay-container-not-connected`

The element passed as overlayContainer * config.ui.overlayContainer} is not connected to the document. The overlay layer mounts into it anyway, but its floating UI (balloons, dialogs, tooltips) stays invisible until the element is inserted into the document.

Make sure the configured container is attached to the document before creating the editor, or attach it afterwards.

Parameters

overlayContainer: HTMLElement | ShadowRoot: The configured, not connected container.

`ui-tabsview-tab-not-found`

The tab with the given ID was not found.

Parameters

tabs: AITabsView: The tabs view instance.
tabId: string: The ID of the tab that was not found.

`ui-template-extend-children-mismatch`

The number of children in extended definition does not match.

`ui-template-revert-not-applied`

Attempting to revert a template which has not been applied yet.

`ui-template-wrong-syntax`

Node definition cannot have the "tag" and "text" properties at the same time. Node definition must have either "tag" or "text" when rendering a new Node.

`ui-textarea-view-min-rows-greater-than-max-rows`

The minimum number of rows is greater than the maximum number of rows.

Parameters

textareaView: TextareaView: The misconfigured textarea view instance.
minRows: number: The value of minRows property.
maxRows: number: The value of maxRows property.

`ui-view-render-already-rendered`

This View has already been rendered.

`ui-viewcollection-delegate-wrong-events`

All event names must be strings.

`unexpected-error`

An unexpected error occurred inside the CKEditor 5 codebase. This error will look like the original one to make the debugging easier.

Like any CKEditorError, it is reported to the callbacks registered with onEditorError(), naming the editor it came from.

`update-bookmark-command-executed-with-invalid-name`

Update bookmark command can be executed only with a valid name.

A valid bookmark name must be a non-empty string and must not contain any spaces.

`uploadcare-unavailable-with-trusted-types`

The file uploader of Uploadcare is not available, because the application enforces Trusted Types with the require-trusted-types-for 'script' CSP directive. The uploader writes HTML in a way that this directive rejects, and the editor cannot change how it does that.

Uploading files still works. What is unavailable is the Uploadcare dialog and the image editor.

For a detailed overview, check the Content Security Policy guide.

`uploadgateway-missing-api-address`

Api address must be provided.

`uploadgateway-missing-token`

Token must be provided.

`users-add-duplicated-id`

User with a given id is already added.

`users-add-invalid-id`

The id must be a string.

`users-me-already-defined`

Cannot add a local user more than once.

`users-me-missing-user`

Cannot specify a non-existing user as the local user.

`view-conversion-dispatcher-incorrect-result`

Incorrect conversion result was dropped.

Model range should be a conversion result.

`view-createpositionat-offset-required`

View#createPositionAt() requires the offset to be specified when the first parameter is a view item.

`view-emptyelement-cannot-add`

Cannot add children to ViewEmptyElement.

`view-node-not-found-in-parent`

The node's parent does not contain this node. It means that the document tree is corrupted.

`view-position-after-root`

You cannot make a position after a root.

Parameters

root: ViewNode: A root item.

`view-position-before-root`

You cannot make a position before a root.

Parameters

root: ViewNode: A root item.

`view-rawelement-cannot-add`

Cannot add children to a ViewRawElement instance.

`view-renderer-filler-was-lost`

The inline filler node was lost. Most likely, something overwrote the filler text node in the DOM.

`view-renderer-unknown-type`

Unknown type passed to Renderer.markToSync.

`view-selection-add-range-not-range`

Selection range set to an object that is not an instance of ViewRange.

`view-selection-range-intersects`

Trying to add a range that intersects with another range from selection.

Parameters

addedRange: ViewRange: Range that was added to the selection.
intersectingRange: ViewRange: Range from selection that intersects with addedRange.

`view-selection-setfocus-no-ranges`

Cannot set selection focus if there are no ranges in selection.

`view-selection-setto-not-selectable`

Cannot set selection to given place.

`view-selection-setto-required-second-parameter`

selection.setTo requires the second parameter when the first parameter is a node.

`view-textproxy-wrong-length`

Given length value is incorrect.

`view-textproxy-wrong-offsetintext`

Given offsetInText value is incorrect.

`view-tree-walker-no-start-position`

Neither boundaries nor starting position have been defined.

`view-tree-walker-unknown-direction`

Only backward and forward direction allowed.

`view-uielement-cannot-add`

Cannot add children to ViewUIElement.

`view-writer-break-non-container-element`

Trying to break an element which is not a container element.

`view-writer-break-root`

Trying to break root element.

`view-writer-cannot-break-empty-element`

Cannot break an EmptyElement instance.

This error is thrown if ViewDowncastWriter#breakAttributes() was executed in an incorrect position.

`view-writer-cannot-break-raw-element`

Cannot break a RawElement instance.

This error is thrown if ViewDowncastWriter#breakAttributes() was executed in an incorrect position.

`view-writer-cannot-break-ui-element`

Cannot break a UIElement instance.

This error is thrown if ViewDowncastWriter#breakAttributes() was executed in an incorrect position.

`view-writer-insert-invalid-node-type`

One of the nodes to be inserted is of an invalid type.

Nodes to be inserted with ViewDowncastWriter#insert() should be of the following types:

`view-writer-invalid-create-slot-context`

The createSlot() method is only allowed inside the elementToStructure downcast helper callback.

`view-writer-invalid-position-container`

Position's parent container cannot be found.

`view-writer-invalid-range-container`

The container of the given range is invalid.

This may happen if range start and range end positions are not placed inside the same container element or a parent container for these positions cannot be found.

Methods like ViewDowncastWriter#remove(), ViewDowncastWriter#clean(), ViewDowncastWriter#wrap(), ViewDowncastWriter#unwrap() need to be called on a range that has its start and end positions located in the same container element. Both positions can be nested within other elements (e.g. an attribute element) but the closest container ancestor must be the same.

`view-writer-merge-containers-invalid-position`

Element before and after given position cannot be merged.

`view-writer-unwrap-invalid-attribute`

The attribute passed to ViewDowncastWriter#unwrap() must be an instance of AttributeElement.

`view-writer-wrap-invalid-attribute`

The attribute passed to ViewDowncastWriter#wrap() must be an instance of AttributeElement.

`viewconsumable-invalid-attribute`

Class and style attributes should be handled separately in ViewConsumable#add().

What you have done is trying to use:

consumables.add( { attributes: [ 'class', 'style' ] } );

While each class and style should be registered separately:

consumables.add( { classes: 'some-class', styles: 'font-weight' } );

`websocketgateway-invalid-plugin-interface`

Cannot add a plugin that does not implement the reconnect() method to the WebSocketGateway reconnection stack.

`websocketgateway-missing-token`

The authentication tokenUrl * config.cloudServices.tokenUrl} configuration is required for creating a websocket connection.

`websocketgateway-missing-websocket-url`

The config.cloudServices.webSocketUrl configuration is required for creating a websocket connection in the real-time collaboration.

ClassicEditor.create( {
	cloudServices: {
		webSocketUrl: "YOUR_WEBSOCKET_URL"
		// ...
	}
	// ...
} );

`websocketgateway-plugin-already-registered`

A plugin was added twice to the WebSocketGateway reconnection stack.

`widesidebar-attach-already-attached`

Cannot attach wide sidebar twice.

`widesidebar-detach-not-attached`

Cannot detach not attached sidebar.

The element passed to toWidget() must be a ViewContainerElement instance.

Parameters

element: any: The view element passed to toWidget().

Toolbar with the given id was already added.

Parameters

toolbarId: string: Toolbar id.

When registering a new widget toolbar, you need to provide a non-empty array with the items that will be inserted into the toolbar.

If you see this error when integrating the editor, you likely forgot to configure one of the widget toolbars.

See for instance:

Parameters

toolbarId: string: The id of the toolbar that has not been configured correctly.

Parameters

markerName: any: The name of the updated marker.