@hkyhy/marsun-components-core 0.1.89 → 0.1.98

package/dist/node_modules/@ckeditor/ckeditor5-core/dist/index.js

@@ -0,0 +1,2107 @@
+var X = Object.defineProperty;
+var tt = (e, t, i) => t in e ? X(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var u = (e, t, i) => tt(e, typeof t != "symbol" ? t + "" : t, i);
+import { ObservableMixin as j, CKEditorError as a, logWarning as Y, getDataFromElement as et, setDataInElement as q, toArray as Z, Config as J, decodeLicenseKey as z, crc32 as it, releaseDate as nt, uid as M, logError as st, isFeatureBlockedByLicenseKey as ot, Locale as rt, Collection as at, KeystrokeHandler as lt, EmitterMixin as ct, global as N, env as P } from "../../ckeditor5-utils/dist/index.js";
+import { isPlainObject as ut } from "../../../es-toolkit/dist/compat/predicate/isPlainObject.js";
+import { get as dt } from "../../../es-toolkit/dist/compat/object/get.js";
+import { set as ft } from "../../../es-toolkit/dist/compat/object/set.js";
+import { isFunction as B } from "../../../es-toolkit/dist/compat/predicate/isFunction.js";
+import { isElement as ht } from "../../../es-toolkit/dist/compat/predicate/isElement.js";
+import { Model as gt, DataController as mt, StylesProcessor as wt, EditingController as yt, Conversion as pt } from "../../ckeditor5-engine/dist/index.js";
+import { EditorWatchdog as bt, ContextWatchdog as _t } from "../../ckeditor5-watchdog/dist/index.js";
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const kt = /* @__PURE__ */ j();
+var Jt = class extends kt {
+  /**
+  * @inheritDoc
+  */
+  constructor(t) {
+    super();
+    /**
+    * The editor instance.
+    *
+    * Note that most editors implement the {@link module:core/editor/editor~Editor#ui} property.
+    * However, editors with an external UI (i.e. Bootstrap-based) or a headless editor may not have this property or
+    * throw an error when accessing it.
+    *
+    * Because of above, to make plugins more universal, it is recommended to split features into:
+    *  - The "editing" part that uses the {@link module:core/editor/editor~Editor} class without `ui` property.
+    *  - The "UI" part that uses the {@link module:core/editor/editor~Editor} class and accesses `ui` property.
+    */
+    u(this, "editor");
+    /**
+    * Holds identifiers for {@link #forceDisabled} mechanism.
+    */
+    u(this, "_disableStack", /* @__PURE__ */ new Set());
+    this.editor = t, this.set("isEnabled", !0);
+  }
+  /**
+  * Disables the plugin.
+  *
+  * Plugin may be disabled by multiple features or algorithms (at once). When disabling a plugin, unique id should be passed
+  * (e.g. feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the plugin.
+  * The plugin becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
+  *
+  * Disabling and enabling a plugin:
+  *
+  * ```ts
+  * plugin.isEnabled; // -> true
+  * plugin.forceDisabled( 'MyFeature' );
+  * plugin.isEnabled; // -> false
+  * plugin.clearForceDisabled( 'MyFeature' );
+  * plugin.isEnabled; // -> true
+  * ```
+  *
+  * Plugin disabled by multiple features:
+  *
+  * ```ts
+  * plugin.forceDisabled( 'MyFeature' );
+  * plugin.forceDisabled( 'OtherFeature' );
+  * plugin.clearForceDisabled( 'MyFeature' );
+  * plugin.isEnabled; // -> false
+  * plugin.clearForceDisabled( 'OtherFeature' );
+  * plugin.isEnabled; // -> true
+  * ```
+  *
+  * Multiple disabling with the same identifier is redundant:
+  *
+  * ```ts
+  * plugin.forceDisabled( 'MyFeature' );
+  * plugin.forceDisabled( 'MyFeature' );
+  * plugin.clearForceDisabled( 'MyFeature' );
+  * plugin.isEnabled; // -> true
+  * ```
+  *
+  * **Note:** some plugins or algorithms may have more complex logic when it comes to enabling or disabling certain plugins,
+  * so the plugin might be still disabled after {@link #clearForceDisabled} was used.
+  *
+  * @param id Unique identifier for disabling. Use the same id when {@link #clearForceDisabled enabling back} the plugin.
+  */
+  forceDisabled(t) {
+    this._disableStack.add(t), this._disableStack.size == 1 && (this.on("set:isEnabled", F, { priority: "highest" }), this.isEnabled = !1);
+  }
+  /**
+  * Clears forced disable previously set through {@link #forceDisabled}. See {@link #forceDisabled}.
+  *
+  * @param id Unique identifier, equal to the one passed in {@link #forceDisabled} call.
+  */
+  clearForceDisabled(t) {
+    this._disableStack.delete(t), this._disableStack.size == 0 && (this.off("set:isEnabled", F), this.isEnabled = !0);
+  }
+  /**
+  * @inheritDoc
+  */
+  destroy() {
+    this.stopListening();
+  }
+  /**
+  * @inheritDoc
+  */
+  static get isContextPlugin() {
+    return !1;
+  }
+  /**
+  * @inheritDoc
+  * @internal
+  */
+  static get isOfficialPlugin() {
+    return !1;
+  }
+  /**
+  * @inheritDoc
+  * @internal
+  */
+  static get isPremiumPlugin() {
+    return !1;
+  }
+};
+function F(e) {
+  e.return = !1, e.stop();
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const Et = /* @__PURE__ */ j();
+var Qt = class extends Et {
+  /**
+  * Creates a new `Command` instance.
+  *
+  * @param editor The editor on which this command will be used.
+  */
+  constructor(t) {
+    super();
+    /**
+    * The editor on which this command will be used.
+    */
+    u(this, "editor");
+    /**
+    * A flag indicating whether a command's `isEnabled` state should be changed depending on where the document
+    * selection is placed.
+    *
+    * By default, it is set to `true`. If the document selection is placed in a
+    * {@link module:engine/model/model~Model#canEditAt non-editable} place (such as non-editable root), the command becomes disabled.
+    *
+    * The flag should be changed to `false` in a concrete command's constructor if the command should not change its `isEnabled`
+    * accordingly to the document selection.
+    */
+    u(this, "_isEnabledBasedOnSelection");
+    /**
+    * A flag indicating whether a command execution changes the editor data or not.
+    *
+    * @see #affectsData
+    */
+    u(this, "_affectsData");
+    /**
+    * Holds identifiers for {@link #forceDisabled} mechanism.
+    */
+    u(this, "_disableStack");
+    this.editor = t, this.set("value", void 0), this.set("isEnabled", !1), this._affectsData = !0, this._isEnabledBasedOnSelection = !0, this._disableStack = /* @__PURE__ */ new Set(), this.decorate("execute"), this.listenTo(this.editor.model.document, "change", () => {
+      this.refresh();
+    }), this.listenTo(t, "change:isReadOnly", () => {
+      this.refresh();
+    }), this.on("set:isEnabled", (i) => {
+      if (!this.affectsData) return;
+      const n = t.model.document.selection, s = n.getFirstPosition().root.rootName != "$graveyard" && t.model.canEditAt(n);
+      (t.isReadOnly || this._isEnabledBasedOnSelection && !s) && (i.return = !1, i.stop());
+    }, { priority: "highest" }), this.on("execute", (i) => {
+      this.isEnabled || i.stop();
+    }, { priority: "high" });
+  }
+  /**
+  * `Command` class is commonly put in `config.plugins` array.
+  *
+  * This property helps with better error detection.
+  *
+  * @internal
+  */
+  static get _throwErrorWhenUsedAsAPlugin() {
+    return !0;
+  }
+  /**
+  * A flag indicating whether a command execution changes the editor data or not.
+  *
+  * Commands with `affectsData` set to `false` will not be automatically disabled in
+  * the {@link module:core/editor/editor~Editor#isReadOnly read-only mode} and
+  * {@glink features/read-only#related-features other editor modes} with restricted user write permissions.
+  *
+  * **Note:** You do not have to set it for your every command. It is `true` by default.
+  *
+  * @default true
+  */
+  get affectsData() {
+    return this._affectsData;
+  }
+  set affectsData(t) {
+    this._affectsData = t;
+  }
+  /**
+  * Refreshes the command. The command should update its {@link #isEnabled} and {@link #value} properties
+  * in this method.
+  *
+  * This method is automatically called when
+  * {@link module:engine/model/document~ModelDocument#event:change any changes are applied to the document}.
+  */
+  refresh() {
+    this.isEnabled = !0;
+  }
+  /**
+  * Disables the command.
+  *
+  * Command may be disabled by multiple features or algorithms (at once). When disabling a command, unique id should be passed
+  * (e.g. the feature name). The same identifier should be used when {@link #clearForceDisabled enabling back} the command.
+  * The command becomes enabled only after all features {@link #clearForceDisabled enabled it back}.
+  *
+  * Disabling and enabling a command:
+  *
+  * ```ts
+  * command.isEnabled; // -> true
+  * command.forceDisabled( 'MyFeature' );
+  * command.isEnabled; // -> false
+  * command.clearForceDisabled( 'MyFeature' );
+  * command.isEnabled; // -> true
+  * ```
+  *
+  * Command disabled by multiple features:
+  *
+  * ```ts
+  * command.forceDisabled( 'MyFeature' );
+  * command.forceDisabled( 'OtherFeature' );
+  * command.clearForceDisabled( 'MyFeature' );
+  * command.isEnabled; // -> false
+  * command.clearForceDisabled( 'OtherFeature' );
+  * command.isEnabled; // -> true
+  * ```
+  *
+  * Multiple disabling with the same identifier is redundant:
+  *
+  * ```ts
+  * command.forceDisabled( 'MyFeature' );
+  * command.forceDisabled( 'MyFeature' );
+  * command.clearForceDisabled( 'MyFeature' );
+  * command.isEnabled; // -> true
+  * ```
+  *
+  * **Note:** some commands or algorithms may have more complex logic when it comes to enabling or disabling certain commands,
+  * so the command might be still disabled after {@link #clearForceDisabled} was used.
+  *
+  * @param id Unique identifier for disabling. Use the same id when {@link #clearForceDisabled enabling back} the command.
+  */
+  forceDisabled(t) {
+    this._disableStack.add(t), this._disableStack.size == 1 && (this.on("set:isEnabled", G, { priority: "highest" }), this.isEnabled = !1);
+  }
+  /**
+  * Clears forced disable previously set through {@link #forceDisabled}. See {@link #forceDisabled}.
+  *
+  * @param id Unique identifier, equal to the one passed in {@link #forceDisabled} call.
+  */
+  clearForceDisabled(t) {
+    this._disableStack.delete(t), this._disableStack.size == 0 && (this.off("set:isEnabled", G), this.refresh());
+  }
+  /**
+  * Executes the command.
+  *
+  * A command may accept parameters. They will be passed from {@link module:core/editor/editor~Editor#execute `editor.execute()`}
+  * to the command.
+  *
+  * The `execute()` method will automatically abort when the command is disabled ({@link #isEnabled} is `false`).
+  * This behavior is implemented by a high priority listener to the {@link #event:execute} event.
+  *
+  * In order to see how to disable a command from "outside" see the {@link #isEnabled} documentation.
+  *
+  * This method may return a value, which would be forwarded all the way down to the
+  * {@link module:core/editor/editor~Editor#execute `editor.execute()`}.
+  *
+  * @fires execute
+  */
+  execute(...t) {
+  }
+  /**
+  * Destroys the command.
+  */
+  destroy() {
+    this.stopListening();
+  }
+};
+function G(e) {
+  e.return = !1, e.stop();
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var vt = class {
+  /**
+  * Creates collection instance.
+  */
+  constructor() {
+    /**
+    * Command map.
+    */
+    u(this, "_commands");
+    this._commands = /* @__PURE__ */ new Map();
+  }
+  /**
+  * Registers a new command.
+  *
+  * @param commandName The name of the command.
+  */
+  add(e, t) {
+    this._commands.set(e, t);
+  }
+  /**
+  * Retrieves a command from the collection.
+  *
+  * @param commandName The name of the command.
+  */
+  get(e) {
+    return this._commands.get(e);
+  }
+  /**
+  * Executes a command.
+  *
+  * @param commandName The name of the command.
+  * @param commandParams Command parameters.
+  * @returns The value returned by the {@link module:core/command~Command#execute `command.execute()`}.
+  */
+  execute(e, ...t) {
+    const i = this.get(e);
+    if (!i)
+      throw new a("commandcollection-command-not-found", this, { commandName: e });
+    return i.execute(...t);
+  }
+  /**
+  * Returns iterator of command names.
+  */
+  *names() {
+    yield* this._commands.keys();
+  }
+  /**
+  * Returns iterator of command instances.
+  */
+  *commands() {
+    yield* this._commands.values();
+  }
+  /**
+  * Iterable interface.
+  *
+  * Returns `[ commandName, commandInstance ]` pairs.
+  */
+  [Symbol.iterator]() {
+    return this._commands[Symbol.iterator]();
+  }
+  /**
+  * Destroys all collection commands.
+  */
+  destroy() {
+    for (const e of this.commands()) e.destroy();
+  }
+};
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const Pt = /* @__PURE__ */ ct();
+var Q = class extends Pt {
+  /**
+  * Creates an instance of the plugin collection class.
+  * Allows loading and initializing plugins and their dependencies.
+  * Allows providing a list of already loaded plugins. These plugins will not be destroyed along with this collection.
+  *
+  * @param availablePlugins Plugins (constructors) which the collection will be able to use
+  * when {@link module:core/plugincollection~PluginCollection#init} is used with the plugin names (strings, instead of constructors).
+  * Usually, the editor will pass its built-in plugins to the collection so they can later be
+  * used in `config.plugins` or `config.removePlugins` by names.
+  * @param contextPlugins A list of already initialized plugins represented by a `[ PluginConstructor, pluginInstance ]` pair.
+  */
+  constructor(t, i = [], n = []) {
+    super();
+    u(this, "_context");
+    u(this, "_plugins", /* @__PURE__ */ new Map());
+    /**
+    * A map of plugin constructors that can be retrieved by their names.
+    */
+    u(this, "_availablePlugins");
+    /**
+    * Map of {@link module:core/contextplugin~ContextPlugin context plugins} which can be retrieved by their constructors or instances.
+    */
+    u(this, "_contextPlugins");
+    this._context = t, this._availablePlugins = /* @__PURE__ */ new Map();
+    for (const s of i) s.pluginName && this._availablePlugins.set(s.pluginName, s);
+    this._contextPlugins = /* @__PURE__ */ new Map();
+    for (const [s, c] of n)
+      this._contextPlugins.set(s, c), this._contextPlugins.set(c, s), s.pluginName && this._availablePlugins.set(s.pluginName, s);
+  }
+  /**
+  * Iterable interface.
+  *
+  * Returns `[ PluginConstructor, pluginInstance ]` pairs.
+  */
+  *[Symbol.iterator]() {
+    for (const t of this._plugins) typeof t[0] == "function" && (yield t);
+  }
+  /**
+  * Gets the plugin instance by its constructor or name.
+  *
+  * ```ts
+  * // Check if 'Clipboard' plugin was loaded.
+  * if ( editor.plugins.has( 'ClipboardPipeline' ) ) {
+  * 	// Get clipboard plugin instance
+  * 	const clipboard = editor.plugins.get( 'ClipboardPipeline' );
+  *
+  * 	this.listenTo( clipboard, 'inputTransformation', ( evt, data ) => {
+  * 		// Do something on clipboard input.
+  * 	} );
+  * }
+  * ```
+  *
+  * **Note**: This method will throw an error if a plugin is not loaded. Use `{@link #has editor.plugins.has()}`
+  * to check if a plugin is available.
+  *
+  * @param key The plugin constructor or {@link module:core/plugin~PluginStaticMembers#pluginName name}.
+  */
+  get(t) {
+    const i = this._plugins.get(t);
+    if (!i) {
+      let n = t;
+      throw typeof t == "function" && (n = t.pluginName || t.name), new a("plugincollection-plugin-not-loaded", this._context, { plugin: n });
+    }
+    return i;
+  }
+  /**
+  * Checks if a plugin is loaded.
+  *
+  * ```ts
+  * // Check if the 'Clipboard' plugin was loaded.
+  * if ( editor.plugins.has( 'ClipboardPipeline' ) ) {
+  * 	// Now use the clipboard plugin instance:
+  * 	const clipboard = editor.plugins.get( 'ClipboardPipeline' );
+  *
+  * 	// ...
+  * }
+  * ```
+  *
+  * @param key The plugin constructor or {@link module:core/plugin~PluginStaticMembers#pluginName name}.
+  */
+  has(t) {
+    return this._plugins.has(t);
+  }
+  /**
+  * Initializes a set of plugins and adds them to the collection.
+  *
+  * @param plugins An array of {@link module:core/plugin~PluginInterface plugin constructors}
+  * or {@link module:core/plugin~PluginStaticMembers#pluginName plugin names}.
+  * @param pluginsToRemove Names of the plugins or plugin constructors
+  * that should not be loaded (despite being specified in the `plugins` array).
+  * @param pluginsSubstitutions An array of {@link module:core/plugin~PluginInterface plugin constructors}
+  * that will be used to replace plugins of the same names that were passed in `plugins` or that are in their dependency tree.
+  * A useful option for replacing built-in plugins while creating tests (for mocking their APIs). Plugins that will be replaced
+  * must follow these rules:
+  *   * The new plugin must be a class.
+  *   * The new plugin must be named.
+  *   * Both plugins must not depend on other plugins.
+  * @returns A promise which gets resolved once all plugins are loaded and available in the collection.
+  */
+  async init(t, i = [], n = []) {
+    const s = this, c = this._context;
+    g(t), x(t);
+    const f = [...k(t.filter((o) => !h(o, i)))];
+    A(f, n);
+    const p = R(f);
+    return await b(p, "init"), await b(p, "afterInit"), p;
+    function m(o) {
+      return typeof o == "function";
+    }
+    function w(o) {
+      return m(o) && !!o.isContextPlugin;
+    }
+    function h(o, l) {
+      return l.some((r) => r === o || y(o) === r || y(r) === o);
+    }
+    function y(o) {
+      return m(o) ? o.pluginName || o.name : o;
+    }
+    function g(o, l = /* @__PURE__ */ new Set()) {
+      o.forEach((r) => {
+        m(r) && (l.has(r) || (l.add(r), r.pluginName && !s._availablePlugins.has(r.pluginName) && s._availablePlugins.set(r.pluginName, r), r.requires && g(r.requires, l)));
+      });
+    }
+    function k(o, l = /* @__PURE__ */ new Set()) {
+      return o.map((r) => m(r) ? r : s._availablePlugins.get(r)).reduce((r, d) => l.has(d) ? r : (l.add(d), d.requires && (x(d.requires, d), k(d.requires, l).forEach((v) => r.add(v))), r.add(d)), /* @__PURE__ */ new Set());
+    }
+    function x(o, l = null) {
+      o.map((r) => m(r) ? r : s._availablePlugins.get(r) || r).forEach((r) => {
+        _(r), D(r, l), I(r, l), L(r, l);
+      });
+    }
+    function _(o) {
+      if (typeof o == "function" && o._throwErrorWhenUsedAsAPlugin)
+        throw new a("plugincollection-plugin-invalid-constructor", c, { name: o.name });
+    }
+    function D(o, l) {
+      if (!m(o))
+        throw l ? new a("plugincollection-soft-required", c, {
+          missingPlugin: o,
+          requiredBy: y(l)
+        }) : new a("plugincollection-plugin-not-found", c, { plugin: o });
+    }
+    function I(o, l) {
+      if (w(l) && !w(o))
+        throw new a("plugincollection-context-required", c, {
+          plugin: y(o),
+          requiredBy: y(l)
+        });
+    }
+    function L(o, l) {
+      if (l && h(o, i))
+        throw new a("plugincollection-required", c, {
+          plugin: y(o),
+          requiredBy: y(l)
+        });
+    }
+    function R(o) {
+      return o.map((l) => {
+        let r = s._contextPlugins.get(l);
+        return r = r || new l(c), s._add(l, r), r;
+      });
+    }
+    function b(o, l) {
+      return o.reduce((r, d) => !d[l] || s._contextPlugins.has(d) ? r : r.then(d[l].bind(d)), Promise.resolve());
+    }
+    function A(o, l) {
+      for (const r of l) {
+        if (typeof r != "function")
+          throw new a("plugincollection-replace-plugin-invalid-type", null, { pluginItem: r });
+        const d = r.pluginName;
+        if (!d)
+          throw new a("plugincollection-replace-plugin-missing-name", null, { pluginItem: r });
+        if (r.requires && r.requires.length)
+          throw new a("plugincollection-plugin-for-replacing-cannot-have-dependencies", null, { pluginName: d });
+        const v = s._availablePlugins.get(d);
+        if (!v)
+          throw new a("plugincollection-plugin-for-replacing-not-exist", null, { pluginName: d });
+        const O = o.indexOf(v);
+        if (O === -1) {
+          if (s._contextPlugins.has(v)) return;
+          throw new a("plugincollection-plugin-for-replacing-not-loaded", null, { pluginName: d });
+        }
+        if (v.requires && v.requires.length)
+          throw new a("plugincollection-replaced-plugin-cannot-have-dependencies", null, { pluginName: d });
+        o.splice(O, 1, r), s._availablePlugins.set(d, r);
+      }
+    }
+  }
+  /**
+  * Destroys all loaded plugins.
+  */
+  destroy() {
+    const t = [];
+    for (const [, i] of this) typeof i.destroy == "function" && !this._contextPlugins.has(i) && t.push(i.destroy());
+    return Promise.all(t);
+  }
+  /**
+  * Adds the plugin to the collection. Exposed mainly for testing purposes.
+  *
+  * @param PluginConstructor The plugin constructor.
+  * @param plugin The instance of the plugin.
+  */
+  _add(t, i) {
+    this._plugins.set(t, i);
+    const n = t.pluginName;
+    if (n) {
+      if (this._plugins.has(n))
+        throw new a("plugincollection-plugin-name-conflict", null, {
+          pluginName: n,
+          plugin1: this._plugins.get(n).constructor,
+          plugin2: t
+        });
+      this._plugins.set(n, i);
+    }
+  }
+};
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var C, W = (C = class {
+  /**
+  * Creates a context instance with a given configuration.
+  *
+  * Usually not to be used directly. See the static {@link module:core/context~Context.create `create()`} method.
+  *
+  * @param config The context configuration.
+  */
+  constructor(e) {
+    /**
+    * Stores all the configurations specific to this context instance.
+    */
+    u(this, "config");
+    /**
+    * The plugins loaded and in use by this context instance.
+    */
+    u(this, "plugins");
+    u(this, "locale");
+    /**
+    * Shorthand for {@link module:utils/locale~Locale#t}.
+    */
+    u(this, "t");
+    /**
+    * A list of editors that this context instance is injected to.
+    */
+    u(this, "editors");
+    /**
+    * Reference to the editor which created the context.
+    * Null when the context was created outside of the editor.
+    *
+    * It is used to destroy the context when removing the editor that has created the context.
+    */
+    u(this, "_contextOwner", null);
+    const { translations: t, ...i } = e || {};
+    this.config = new J(i, this.constructor.defaultConfig);
+    const n = this.constructor.builtinPlugins;
+    this.config.define("plugins", n), this.plugins = new Q(this, n);
+    const s = this.config.get("language") || {};
+    this.locale = new rt({
+      uiLanguage: typeof s == "string" ? s : s.ui,
+      contentLanguage: this.config.get("language.content"),
+      translations: t
+    }), this.t = this.locale.t, this.editors = new at();
+  }
+  /**
+  * Loads and initializes plugins specified in the configuration.
+  *
+  * @returns A promise which resolves once the initialization is completed, providing an array of loaded plugins.
+  */
+  initPlugins() {
+    const e = this.config.get("plugins") || [], t = this.config.get("substitutePlugins") || [];
+    for (const i of e.concat(t)) {
+      if (typeof i != "function")
+        throw new a("context-initplugins-constructor-only", null, { Plugin: i });
+      if (i.isContextPlugin !== !0)
+        throw new a("context-initplugins-invalid-plugin", null, { Plugin: i });
+    }
+    return this.plugins.init(e, [], t);
+  }
+  /**
+  * Destroys the context instance and all editors used with the context,
+  * releasing all resources used by the context.
+  *
+  * @returns A promise that resolves once the context instance is fully destroyed.
+  */
+  destroy() {
+    return Promise.all(Array.from(this.editors, (e) => e.destroy())).then(() => this.plugins.destroy());
+  }
+  /**
+  * Adds a reference to the editor which is used with this context.
+  *
+  * When the given editor has created the context, the reference to this editor will be stored
+  * as a {@link ~Context#_contextOwner}.
+  *
+  * This method should only be used by the editor.
+  *
+  * @internal
+  * @param isContextOwner Stores the given editor as a context owner.
+  */
+  _addEditor(e, t) {
+    if (this._contextOwner)
+      throw new a("context-addeditor-private-context");
+    this.editors.add(e), t && (this._contextOwner = e);
+  }
+  /**
+  * Removes a reference to the editor which was used with this context.
+  * When the context was created by the given editor, the context will be destroyed.
+  *
+  * This method should only be used by the editor.
+  *
+  * @internal
+  * @return A promise that resolves once the editor is removed from the context or when the context was destroyed.
+  */
+  _removeEditor(e) {
+    return this.editors.has(e) && this.editors.remove(e), this._contextOwner === e ? this.destroy() : Promise.resolve();
+  }
+  /**
+  * Returns the context configuration which will be copied to the editors created using this context.
+  *
+  * The configuration returned by this method has the plugins configuration removed – plugins are shared with all editors
+  * through another mechanism.
+  *
+  * This method should only be used by the editor.
+  *
+  * @internal
+  * @returns Configuration as a plain object.
+  */
+  _getEditorConfig() {
+    const e = {};
+    for (const t of this.config.names()) [
+      "plugins",
+      "removePlugins",
+      "extraPlugins"
+    ].includes(t) || (e[t] = this.config.get(t));
+    return e;
+  }
+  /**
+  * Creates and initializes a new context instance.
+  *
+  * ```ts
+  * const commonConfig = { ... }; // Configuration for all the plugins and editors.
+  * const editorPlugins = [ ... ]; // Regular plugins here.
+  *
+  * Context
+  * 	.create( {
+  * 		// Only context plugins here.
+  * 		plugins: [ ... ],
+  *
+  * 		// Configure the language for all the editors (it cannot be overwritten).
+  * 		language: { ... },
+  *
+  * 		// Configuration for context plugins.
+  * 		comments: { ... },
+  * 		...
+  *
+  * 		// Default configuration for editor plugins.
+  * 		toolbar: { ... },
+  * 		image: { ... },
+  * 		...
+  * 	} )
+  * 	.then( context => {
+  * 		const promises = [];
+  *
+  * 		promises.push( ClassicEditor.create(
+  * 			document.getElementById( 'editor1' ),
+  * 			{
+  * 				editorPlugins,
+  * 				context
+  * 			}
+  * 		) );
+  *
+  * 		promises.push( ClassicEditor.create(
+  * 			document.getElementById( 'editor2' ),
+  * 			{
+  * 				editorPlugins,
+  * 				context,
+  * 				toolbar: { ... } // You can overwrite the configuration of the context.
+  * 			}
+  * 		) );
+  *
+  * 		return Promise.all( promises );
+  * 	} );
+  * ```
+  *
+  * @param config The context configuration.
+  * @returns A promise resolved once the context is ready. The promise resolves with the created context instance.
+  */
+  static create(e) {
+    return new Promise((t) => {
+      const i = new this(e);
+      t(i.initPlugins().then(() => i));
+    });
+  }
+  /**
+  * `Context` class is commonly put in `config.plugins` array.
+  *
+  * This property helps with better error detection.
+  *
+  * @internal
+  */
+  static get _throwErrorWhenUsedAsAPlugin() {
+    return !0;
+  }
+}, /**
+* The default configuration which is built into the `Context` class.
+*
+* It was used in the now deprecated CKEditor 5 builds featuring `Context` to provide the default configuration options
+* which are later used during the context initialization.
+*
+* ```ts
+* Context.defaultConfig = {
+* 	foo: 1,
+* 	bar: 2
+* };
+*
+* Context
+* 	.create()
+* 	.then( context => {
+* 		context.config.get( 'foo' ); // -> 1
+* 		context.config.get( 'bar' ); // -> 2
+* 	} );
+*
+* // The default options can be overridden by the configuration passed to create().
+* Context
+* 	.create( { bar: 3 } )
+* 	.then( context => {
+* 		context.config.get( 'foo' ); // -> 1
+* 		context.config.get( 'bar' ); // -> 3
+* 	} );
+* ```
+*
+* See also {@link module:core/context~Context.builtinPlugins `Context.builtinPlugins`}
+* and {@link module:core/editor/editor~Editor.defaultConfig `Editor.defaultConfig`}.
+*/
+u(C, "defaultConfig"), /**
+* An array of plugins built into the `Context` class.
+*
+* It was used in the now deprecated CKEditor 5 builds featuring `Context` to provide the default configuration options
+* which are later used during the context initialization.
+*
+* They will be automatically initialized by `Context` unless `config.plugins` is passed.
+*
+* ```ts
+* // Build some context plugins into the Context class first.
+* Context.builtinPlugins = [ FooPlugin, BarPlugin ];
+*
+* // Normally, you need to define config.plugins, but since Context.builtinPlugins was
+* // defined, now you can call create() without any configuration.
+* Context
+* 	.create()
+* 	.then( context => {
+* 		context.plugins.get( FooPlugin ); // -> An instance of the Foo plugin.
+* 		context.plugins.get( BarPlugin ); // -> An instance of the Bar plugin.
+* 	} );
+* ```
+*
+* See also {@link module:core/context~Context.defaultConfig `Context.defaultConfig`}
+* and {@link module:core/editor/editor~Editor.builtinPlugins `Editor.builtinPlugins`}.
+*/
+u(C, "builtinPlugins"), C);
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var St = class extends lt {
+  /**
+  * Creates an instance of the keystroke handler.
+  */
+  constructor(t) {
+    super();
+    /**
+    * The editor instance.
+    */
+    u(this, "editor");
+    this.editor = t;
+  }
+  /**
+  * Registers a handler for the specified keystroke.
+  *
+  * The handler can be specified as a command name or a callback.
+  *
+  * @param keystroke Keystroke defined in a format accepted by
+  * the {@link module:utils/keyboard~parseKeystroke} function.
+  * @param callback If a string is passed, then the keystroke will
+  * {@link module:core/editor/editor~Editor#execute execute a command}.
+  * If a function, then it will be called with the
+  * {@link module:engine/view/observer/keyobserver~ViewDocumentKeyEventData key event data} object and
+  * a `cancel()` helper to both `preventDefault()` and `stopPropagation()` of the event.
+  * @param options Additional options.
+  * @param options.priority The priority of the keystroke callback. The higher the priority value
+  * the sooner the callback will be executed. Keystrokes having the same priority
+  * are called in the order they were added.
+  */
+  set(t, i, n = {}) {
+    if (typeof i == "string") {
+      const s = i;
+      i = (c, f) => {
+        this.editor.execute(s), f();
+      };
+    }
+    super.set(t, i, n);
+  }
+};
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const T = "contentEditing", $ = "common";
+var xt = class {
+  /**
+  * @inheritDoc
+  */
+  constructor(e) {
+    /**
+    * Stores information about keystrokes brought by editor features for the users to interact with the editor, mainly
+    * keystroke combinations and their accessible labels.
+    *
+    * This information is particularly useful for screen reader and other assistive technology users. It gets displayed
+    * by the {@link module:ui/editorui/accessibilityhelp/accessibilityhelp~AccessibilityHelp Accessibility help} dialog.
+    *
+    * Keystrokes are organized in categories and groups. They can be added using ({@link #addKeystrokeInfoCategory},
+    * {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfos}) methods.
+    *
+    * Please note that:
+    * * two categories are always available:
+    *   * `'contentEditing'` for keystrokes related to content creation,
+    *   * `'navigation'` for keystrokes related to navigation in the UI and the content.
+    * * unless specified otherwise, new keystrokes are added into the `'contentEditing'` category and the `'common'`
+    * keystroke group within that category while using the {@link #addKeystrokeInfos} method.
+    */
+    u(this, "keystrokeInfos", /* @__PURE__ */ new Map());
+    /**
+    * The editor instance.
+    */
+    u(this, "_editor");
+    this._editor = e;
+    const t = e.config.get("menuBar.isVisible"), i = e.locale.t;
+    this.addKeystrokeInfoCategory({
+      id: T,
+      label: i("Content editing keystrokes"),
+      description: i("These keyboard shortcuts allow for quick access to content editing features.")
+    });
+    const n = [
+      {
+        label: i("Close contextual balloons, dropdowns, and dialogs"),
+        keystroke: "Esc"
+      },
+      {
+        label: i("Open the accessibility help dialog"),
+        keystroke: "Alt+0"
+      },
+      {
+        label: i("Move focus between form fields (inputs, buttons, etc.)"),
+        keystroke: [["Tab"], ["Shift+Tab"]]
+      },
+      {
+        label: i("Move focus to the toolbar, navigate between toolbars"),
+        keystroke: "Alt+F10",
+        mayRequireFn: !0
+      },
+      {
+        label: i("Navigate through the toolbar or menu bar"),
+        keystroke: [
+          ["arrowup"],
+          ["arrowright"],
+          ["arrowdown"],
+          ["arrowleft"]
+        ]
+      },
+      {
+        label: i("Execute the currently focused button. Executing buttons that interact with the editor content moves the focus back to the content."),
+        keystroke: [["Enter"], ["Space"]]
+      }
+    ];
+    t && n.push({
+      label: i("Move focus to the menu bar, navigate between menu bars"),
+      keystroke: "Alt+F9",
+      mayRequireFn: !0
+    }), this.addKeystrokeInfoCategory({
+      id: "navigation",
+      label: i("User interface and content navigation keystrokes"),
+      description: i("Use the following keystrokes for more efficient navigation in the CKEditor 5 user interface."),
+      groups: [{
+        id: "common",
+        keystrokes: n
+      }]
+    });
+  }
+  /**
+  * Adds a top-level category in the {@link #keystrokeInfos keystroke information database} with a label and optional description.
+  *
+  * Categories organize keystrokes and help users to find the right keystroke. Each category can have multiple groups
+  * of keystrokes that narrow down the context in which the keystrokes are available. Every keystroke category comes
+  * with a `'common'` group by default.
+  *
+  * By default, two categories are available:
+  * * `'contentEditing'` for keystrokes related to content creation,
+  * * `'navigation'` for keystrokes related to navigation in the UI and the content.
+  *
+  * To create a new keystroke category with new groups, use the following code:
+  *
+  * ```js
+  * class MyPlugin extends Plugin {
+  * 	// ...
+  * 	init() {
+  * 		const editor = this.editor;
+  * 		const t = editor.t;
+  *
+  * 		// ...
+  *
+  * 		editor.accessibility.addKeystrokeInfoCategory( {
+  * 			id: 'myCategory',
+  * 			label: t( 'My category' ),
+  * 			description: t( 'My category description.' ),
+  * 			groups: [
+  * 				{
+  * 					id: 'myGroup',
+  * 					label: t( 'My keystroke group' ),
+  * 					keystrokes: [
+  * 						{
+  * 							label: t( 'Keystroke label 1' ),
+  * 							keystroke: 'Ctrl+Shift+N'
+  * 						},
+  * 						{
+  * 							label: t( 'Keystroke label 2' ),
+  * 							keystroke: 'Ctrl+Shift+M'
+  * 						}
+  * 					]
+  * 				}
+  * 			]
+  * 		};
+  * 	}
+  * }
+  * ```
+  *
+  * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfos}.
+  */
+  addKeystrokeInfoCategory({ id: e, label: t, description: i, groups: n }) {
+    this.keystrokeInfos.set(e, {
+      id: e,
+      label: t,
+      description: i,
+      groups: /* @__PURE__ */ new Map()
+    }), this.addKeystrokeInfoGroup({
+      categoryId: e,
+      id: $
+    }), n && n.forEach((s) => {
+      this.addKeystrokeInfoGroup({
+        categoryId: e,
+        ...s
+      });
+    });
+  }
+  /**
+  * Adds a group of keystrokes in a specific category to the {@link #keystrokeInfos keystroke information database}.
+  *
+  * Groups narrow down the context in which the keystrokes are available. When `categoryId` is not specified,
+  * the group goes to the `'contentEditing'` category (default).
+  *
+  * To create a new group within an existing category, use the following code:
+  *
+  * ```js
+  * class MyPlugin extends Plugin {
+  * 	// ...
+  * 	init() {
+  * 		const editor = this.editor;
+  * 		const t = editor.t;
+  *
+  * 		// ...
+  *
+  * 		editor.accessibility.addKeystrokeInfoGroup( {
+  * 			id: 'myGroup',
+  * 			categoryId: 'navigation',
+  * 			label: t( 'My keystroke group' ),
+  * 			keystrokes: [
+  * 				{
+  * 					label: t( 'Keystroke label 1' ),
+  * 					keystroke: 'Ctrl+Shift+N'
+  * 				},
+  * 				{
+  * 					label: t( 'Keystroke label 2' ),
+  * 					keystroke: 'Ctrl+Shift+M'
+  * 				}
+  * 			]
+  * 		} );
+  * 	}
+  * }
+  * ```
+  *
+  * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoCategory}, and {@link #addKeystrokeInfos}.
+  */
+  addKeystrokeInfoGroup({ categoryId: e = T, id: t, label: i, keystrokes: n }) {
+    const s = this.keystrokeInfos.get(e);
+    if (!s) throw new a("accessibility-unknown-keystroke-info-category", this._editor, {
+      groupId: t,
+      categoryId: e
+    });
+    s.groups.set(t, {
+      id: t,
+      label: i,
+      keystrokes: n || []
+    });
+  }
+  /**
+  * Adds information about keystrokes to the {@link #keystrokeInfos keystroke information database}.
+  *
+  * Keystrokes without specified `groupId` or `categoryId` go to the `'common'` group in the `'contentEditing'` category (default).
+  *
+  * To add a keystroke brought by your plugin (using default group and category), use the following code:
+  *
+  * ```js
+  * class MyPlugin extends Plugin {
+  * 	// ...
+  * 	init() {
+  * 		const editor = this.editor;
+  * 		const t = editor.t;
+  *
+  * 		// ...
+  *
+  * 		editor.accessibility.addKeystrokeInfos( {
+  * 			keystrokes: [
+  * 				{
+  * 					label: t( 'Keystroke label' ),
+  * 					keystroke: 'CTRL+B'
+  * 				}
+  * 			]
+  * 		} );
+  * 	}
+  * }
+  * ```
+  * To add a keystroke in a specific existing `'widget'` group in the default `'contentEditing'` category:
+  *
+  * ```js
+  * class MyPlugin extends Plugin {
+  * 	// ...
+  * 	init() {
+  * 		const editor = this.editor;
+  * 		const t = editor.t;
+  *
+  * 		// ...
+  *
+  * 		editor.accessibility.addKeystrokeInfos( {
+  * 			// Add a keystroke to the existing "widget" group.
+  * 			groupId: 'widget',
+  * 			keystrokes: [
+  * 				{
+  * 					label: t( 'A an action on a selected widget' ),
+  * 					keystroke: 'Ctrl+D',
+  * 				}
+  * 			]
+  * 		} );
+  * 	}
+  * }
+  * ```
+  *
+  * To add a keystroke to another existing category (using default group):
+  *
+  * ```js
+  * class MyPlugin extends Plugin {
+  * 	// ...
+  * 	init() {
+  * 		const editor = this.editor;
+  * 		const t = editor.t;
+  *
+  * 		// ...
+  *
+  * 		editor.accessibility.addKeystrokeInfos( {
+  * 			// Add keystrokes to the "navigation" category (one of defaults).
+  * 			categoryId: 'navigation',
+  * 			keystrokes: [
+  * 				{
+  * 					label: t( 'Keystroke label' ),
+  * 					keystroke: 'CTRL+B'
+  * 				}
+  * 			]
+  * 		} );
+  * 	}
+  * }
+  * ```
+  *
+  * See {@link #keystrokeInfos}, {@link #addKeystrokeInfoGroup}, and {@link #addKeystrokeInfoCategory}.
+  */
+  addKeystrokeInfos({ categoryId: e = T, groupId: t = $, keystrokes: i }) {
+    if (!this.keystrokeInfos.has(e))
+      throw new a("accessibility-unknown-keystroke-info-category", this._editor, {
+        categoryId: e,
+        keystrokes: i
+      });
+    const n = this.keystrokeInfos.get(e);
+    if (!n.groups.has(t))
+      throw new a("accessibility-unknown-keystroke-info-group", this._editor, {
+        groupId: t,
+        categoryId: e,
+        keystrokes: i
+      });
+    n.groups.get(t).keystrokes.push(...i);
+  }
+};
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function At(e) {
+  return {
+    sessionId: Lt(),
+    pageSessionId: Rt(),
+    hostname: window.location.hostname,
+    version: globalThis.CKEDITOR_VERSION,
+    type: Ot(e),
+    plugins: Ct(e.plugins),
+    distribution: Dt(),
+    env: It(),
+    integration: /* @__PURE__ */ Object.create(null),
+    menuBar: { isVisible: !!e.config.get("menuBar.isVisible") },
+    language: {
+      ui: e.locale.uiLanguage,
+      content: e.locale.contentLanguage
+    },
+    toolbar: {
+      main: K(e.config.get("toolbar")),
+      block: K(e.config.get("blockToolbar")),
+      balloon: K(e.config.get("balloonToolbar"))
+    }
+  };
+}
+function Ot(e) {
+  return Object.getPrototypeOf(e).constructor.editorName;
+}
+function Ct(e) {
+  return Array.from(e).filter(([t]) => !!t.pluginName).map(([t]) => {
+    const { pluginName: i, isContextPlugin: n, isOfficialPlugin: s, isPremiumPlugin: c } = t;
+    return {
+      isContext: !!n,
+      isOfficial: !!s,
+      isPremium: !!c,
+      name: i
+    };
+  });
+}
+function K(e) {
+  if (!e) return;
+  const t = Array.isArray(e) ? { items: e } : e, i = s(t.items || []);
+  return {
+    isMultiline: i.includes("-"),
+    shouldNotGroupWhenFull: !!t.shouldNotGroupWhenFull,
+    items: n(i)
+  };
+  function n(c) {
+    return c.filter((f) => f !== "|" && f !== "-");
+  }
+  function s(c) {
+    return c.flatMap((f) => typeof f == "string" ? [f] : s(f.items));
+  }
+}
+function Dt() {
+  return { channel: window[Symbol.for("cke distribution")] || "sh" };
+}
+function It() {
+  let e = "unknown", t = "unknown";
+  return P.isMac ? e = "mac" : P.isWindows ? e = "windows" : P.isiOS ? e = "ios" : P.isAndroid && (e = "android"), P.isGecko ? t = "gecko" : P.isBlink ? t = "blink" : P.isSafari && (t = "safari"), {
+    os: e,
+    browser: t
+  };
+}
+function Lt() {
+  return localStorage.getItem("__ckeditor-session-id") || localStorage.setItem("__ckeditor-session-id", M()), localStorage.getItem("__ckeditor-session-id");
+}
+function Rt() {
+  return N.window.CKEDITOR_PAGE_SESSION_ID = N.window.CKEDITOR_PAGE_SESSION_ID || M(), N.window.CKEDITOR_PAGE_SESSION_ID;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const Nt = /* @__PURE__ */ j();
+var S, Xt = (S = class extends Nt {
+  /**
+  * Creates a new instance of the editor class.
+  *
+  * Usually, not to be used directly. See the static {@link module:core/editor/editor~Editor.create `create()`} method.
+  *
+  * @param config The editor configuration.
+  */
+  constructor(t = {}) {
+    super();
+    /**
+    * A namespace for the accessibility features of the editor.
+    */
+    u(this, "accessibility");
+    /**
+    * Commands registered to the editor.
+    *
+    * Use the shorthand {@link #execute `editor.execute()`} method to execute commands:
+    *
+    * ```ts
+    * // Execute the bold command:
+    * editor.execute( 'bold' );
+    *
+    * // Check the state of the bold command:
+    * editor.commands.get( 'bold' ).value;
+    * ```
+    */
+    u(this, "commands");
+    /**
+    * Stores all configurations specific to this editor instance.
+    *
+    * ```ts
+    * editor.config.get( 'image.toolbar' );
+    * // -> [ 'imageStyle:block', 'imageStyle:side', '|', 'toggleImageCaption', 'imageTextAlternative' ]
+    * ```
+    */
+    u(this, "config");
+    /**
+    * Conversion manager through which you can register model-to-view and view-to-model converters.
+    *
+    * See the {@link module:engine/conversion/conversion~Conversion} documentation to learn how to add converters.
+    */
+    u(this, "conversion");
+    /**
+    * The {@link module:engine/controller/datacontroller~DataController data controller}.
+    * Used e.g. for setting and retrieving the editor data.
+    */
+    u(this, "data");
+    /**
+    * The {@link module:engine/controller/editingcontroller~EditingController editing controller}.
+    * Controls user input and rendering the content for editing.
+    */
+    u(this, "editing");
+    /**
+    * The locale instance.
+    */
+    u(this, "locale");
+    /**
+    * The editor's model.
+    *
+    * The central point of the editor's abstract data model.
+    */
+    u(this, "model");
+    /**
+    * The plugins loaded and in use by this editor instance.
+    *
+    * ```ts
+    * editor.plugins.get( 'ClipboardPipeline' ); // -> An instance of the clipboard pipeline plugin.
+    * ```
+    */
+    u(this, "plugins");
+    /**
+    * An instance of the {@link module:core/editingkeystrokehandler~EditingKeystrokeHandler}.
+    *
+    * It allows setting simple keystrokes:
+    *
+    * ```ts
+    * // Execute the bold command on Ctrl+E:
+    * editor.keystrokes.set( 'Ctrl+E', 'bold' );
+    *
+    * // Execute your own callback:
+    * editor.keystrokes.set( 'Ctrl+E', ( data, cancel ) => {
+    * 	console.log( data.keyCode );
+    *
+    * 	// Prevent the default (native) action and stop the underlying keydown event
+    * 	// so no other editor feature will interfere.
+    * 	cancel();
+    * } );
+    * ```
+    *
+    * Note: Certain typing-oriented keystrokes (like <kbd>Backspace</kbd> or <kbd>Enter</kbd>) are handled
+    * by a low-level mechanism and trying to listen to them via the keystroke handler will not work reliably.
+    * To handle these specific keystrokes, see the events fired by the
+    * {@link module:engine/view/document~ViewDocument editing view document} (`editor.editing.view.document`).
+    */
+    u(this, "keystrokes");
+    /**
+    * Shorthand for {@link module:utils/locale~Locale#t}.
+    *
+    * @see module:utils/locale~Locale#t
+    */
+    u(this, "t");
+    /**
+    * The editor context.
+    * When it is not provided through the configuration, the editor creates it.
+    */
+    u(this, "_context");
+    /**
+    * A set of lock IDs for the {@link #isReadOnly} getter.
+    */
+    u(this, "_readOnlyLocks");
+    /**
+    * Holds attributes keys that were passed in
+    * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}
+    *  or {@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`}.
+    */
+    u(this, "_registeredRootsAttributesKeys", /* @__PURE__ */ new Set());
+    if (typeof t != "object" || Array.isArray(t))
+      throw new a("editor-config-invalid-type");
+    if ("sanitizeHtml" in t)
+      throw new a("editor-config-sanitizehtml-not-supported");
+    const i = this.constructor, { translations: n, ...s } = i.defaultConfig || {}, { translations: c = n, ...f } = t, p = t.language || s.language;
+    this._context = t.context || new W({
+      language: p,
+      translations: c
+    }), this._context._addEditor(this, !t.context);
+    const m = Array.from(i.builtinPlugins || []);
+    this.config = new J(f, s), this.config.define("plugins", m), this.config.define(this._context._getEditorConfig()), h(this.config), this.plugins = new Q(this, m, this._context.plugins), this.locale = this._context.locale, this.t = this.locale.t, this._readOnlyLocks = /* @__PURE__ */ new Set(), this.commands = new vt(), this.set("state", "initializing"), this.once("ready", () => this.state = "ready", { priority: "high" }), this.once("destroy", () => this.state = "destroyed", { priority: "high" }), this.model = new gt(this.config), this.on("change:isReadOnly", () => {
+      this.model.document.isReadOnly = this.isReadOnly;
+    });
+    const w = new wt();
+    this.data = new mt(this.model, w), this.editing = new yt(this.model, w), this.editing.view.document.bind("isReadOnly").to(this), this.conversion = new pt([this.editing.downcastDispatcher, this.data.downcastDispatcher], this.data.upcastDispatcher), this.conversion.addAlias("dataDowncast", this.data.downcastDispatcher), this.conversion.addAlias("editingDowncast", this.editing.downcastDispatcher), this.keystrokes = new St(this), this.keystrokes.listenTo(this.editing.view.document), this.accessibility = new xt(this), y(this);
+    function h(g) {
+      let k = g.get("licenseKey");
+      if (!k && window.CKEDITOR_GLOBAL_LICENSE_KEY && (k = window.CKEDITOR_GLOBAL_LICENSE_KEY, g.set("licenseKey", k)), !k)
+        throw new a("license-key-missing");
+    }
+    function y(g) {
+      const k = g.config.get("licenseKey"), x = window[Symbol.for("cke distribution")] || "sh";
+      function _(o, l) {
+        g.enableReadOnlyMode(Symbol("invalidLicense")), g._showLicenseError(o, l);
+      }
+      function D(o) {
+        return [
+          "exp",
+          "jti",
+          "vc"
+        ].every((l) => l in o);
+      }
+      function I(o) {
+        return Object.getOwnPropertyNames(o).sort().filter((l) => l != "vc" && o[l] != null).map((l) => o[l]);
+      }
+      function L(o) {
+        const { hostname: l } = new URL(window.location.href);
+        if (o.includes(l)) return !0;
+        const r = l.split(".");
+        return o.filter((d) => d.includes("*")).map((d) => d.split(".")).filter((d) => d.length <= r.length).map((d) => Array(r.length - d.length).fill(d[0] === "*" ? "*" : "").concat(d)).some((d) => r.every((v, O) => d[O] === v || d[O] === "*"));
+      }
+      function R(o) {
+        const l = o[0].toUpperCase() + o.slice(1), r = o === "evaluation" ? "an" : "a";
+        console.info(`%cCKEditor 5 ${l} License`, "color: #ffffff; background: #743CCD; font-size: 14px; padding: 4px 8px; border-radius: 4px;"), console.warn(`⚠️ You are using ${r} ${o} license of CKEditor 5${o === "trial" ? " which is for evaluation purposes only" : ""}. For production usage, please obtain a production license at https://portal.ckeditor.com/`);
+      }
+      if (k == "GPL") {
+        x == "cloud" && _("distributionChannel");
+        return;
+      }
+      const b = z(k);
+      if (!b) {
+        _("invalid");
+        return;
+      }
+      if (!D(b)) {
+        _("invalid");
+        return;
+      }
+      if (b.distributionChannel && !Z(b.distributionChannel).includes(x)) {
+        _("distributionChannel");
+        return;
+      }
+      if (it(I(b)) != b.vc.toLowerCase()) {
+        _("invalid");
+        return;
+      }
+      if (/* @__PURE__ */ new Date(b.exp * 1e3) < nt) {
+        _("expired");
+        return;
+      }
+      const A = b.licensedHosts;
+      if (A && A.length > 0 && !L(A)) {
+        _("domainLimit");
+        return;
+      }
+      if (["evaluation", "trial"].includes(b.licenseType) && b.exp * 1e3 < Date.now()) {
+        _("expired");
+        return;
+      }
+      if ([
+        "development",
+        "evaluation",
+        "trial"
+      ].includes(b.licenseType)) {
+        const { licenseType: o } = b;
+        window.CKEDITOR_WARNING_SUPPRESSIONS = window.CKEDITOR_WARNING_SUPPRESSIONS || {}, window.CKEDITOR_WARNING_SUPPRESSIONS[o] || (R(o), window.CKEDITOR_WARNING_SUPPRESSIONS[o] = !0);
+      }
+      if (b.licenseType === "evaluation") {
+        const o = setTimeout(() => {
+          _("evaluationLimit");
+        }, 6e5);
+        g.on("destroy", () => {
+          clearTimeout(o);
+        });
+      }
+      b.usageEndpoint && g.once("ready", () => {
+        const o = {
+          requestId: M(),
+          requestTime: Math.round(Date.now() / 1e3),
+          license: k,
+          editor: Tt(g)
+        };
+        g._sendUsageRequest(b.usageEndpoint, o).then((l) => {
+          const { status: r, message: d } = l;
+          d && console.warn(d), r != "ok" && _("usageLimit");
+        }, () => {
+          st("license-key-validation-endpoint-not-reachable", { url: b.usageEndpoint });
+        });
+      }, { priority: "high" });
+    }
+  }
+  /**
+  * A required name of the editor class. The name should reflect the constructor name.
+  */
+  static get editorName() {
+    return "Editor";
+  }
+  /**
+  * `Editor` class is commonly put in `config.plugins` array.
+  *
+  * This property helps with better error detection.
+  *
+  * @internal
+  */
+  static get _throwErrorWhenUsedAsAPlugin() {
+    return !0;
+  }
+  /**
+  * Defines whether the editor is in the read-only mode.
+  *
+  * In read-only mode the editor {@link #commands commands} are disabled so it is not possible
+  * to modify the document by using them. Also, the editable element(s) become non-editable.
+  *
+  * In order to make the editor read-only, you need to call the {@link #enableReadOnlyMode} method:
+  *
+  * ```ts
+  * editor.enableReadOnlyMode( 'feature-id' );
+  * ```
+  *
+  * Later, to turn off the read-only mode, call {@link #disableReadOnlyMode}:
+  *
+  * ```ts
+  * editor.disableReadOnlyMode( 'feature-id' );
+  * ```
+  *
+  * @readonly
+  * @observable
+  */
+  get isReadOnly() {
+    return this._readOnlyLocks.size > 0;
+  }
+  set isReadOnly(t) {
+    throw new a("editor-isreadonly-has-no-setter");
+  }
+  /**
+  * Turns on the read-only mode in the editor.
+  *
+  * Editor can be switched to or out of the read-only mode by many features, under various circumstances. The editor supports locking
+  * mechanism for the read-only mode. It enables easy control over the read-only mode when many features wants to turn it on or off at
+  * the same time, without conflicting with each other. It guarantees that you will not make the editor editable accidentally (which
+  * could lead to errors).
+  *
+  * Each read-only mode request is identified by a unique id (also called "lock"). If multiple plugins requested to turn on the
+  * read-only mode, then, the editor will become editable only after all these plugins turn the read-only mode off (using the same ids).
+  *
+  * Note, that you cannot force the editor to disable the read-only mode if other plugins set it.
+  *
+  * After the first `enableReadOnlyMode()` call, the {@link #isReadOnly `isReadOnly` property} will be set to `true`:
+  *
+  * ```ts
+  * editor.isReadOnly; // `false`.
+  * editor.enableReadOnlyMode( 'my-feature-id' );
+  * editor.isReadOnly; // `true`.
+  * ```
+  *
+  * You can turn off the read-only mode ("clear the lock") using the {@link #disableReadOnlyMode `disableReadOnlyMode()`} method:
+  *
+  * ```ts
+  * editor.enableReadOnlyMode( 'my-feature-id' );
+  * // ...
+  * editor.disableReadOnlyMode( 'my-feature-id' );
+  * editor.isReadOnly; // `false`.
+  * ```
+  *
+  * All "locks" need to be removed to enable editing:
+  *
+  * ```ts
+  * editor.enableReadOnlyMode( 'my-feature-id' );
+  * editor.enableReadOnlyMode( 'my-other-feature-id' );
+  * // ...
+  * editor.disableReadOnlyMode( 'my-feature-id' );
+  * editor.isReadOnly; // `true`.
+  * editor.disableReadOnlyMode( 'my-other-feature-id' );
+  * editor.isReadOnly; // `false`.
+  * ```
+  *
+  * @param lockId A unique ID for setting the editor to the read-only state.
+  */
+  enableReadOnlyMode(t) {
+    if (typeof t != "string" && typeof t != "symbol")
+      throw new a("editor-read-only-lock-id-invalid", null, { lockId: t });
+    this._readOnlyLocks.has(t) || (this._readOnlyLocks.add(t), this._readOnlyLocks.size === 1 && this.fire("change:isReadOnly", "isReadOnly", !0, !1));
+  }
+  /**
+  * Removes the read-only lock from the editor with given lock ID.
+  *
+  * When no lock is present on the editor anymore, then the {@link #isReadOnly `isReadOnly` property} will be set to `false`.
+  *
+  * @param lockId The lock ID for setting the editor to the read-only state.
+  */
+  disableReadOnlyMode(t) {
+    if (typeof t != "string" && typeof t != "symbol") throw new a("editor-read-only-lock-id-invalid", null, { lockId: t });
+    this._readOnlyLocks.has(t) && (this._readOnlyLocks.delete(t), this._readOnlyLocks.size === 0 && this.fire("change:isReadOnly", "isReadOnly", !1, !0));
+  }
+  /**
+  * Sets the data in the editor.
+  *
+  * ```ts
+  * editor.setData( '<p>This is editor!</p>' );
+  * ```
+  *
+  * If your editor implementation uses multiple roots, you should pass an object with keys corresponding
+  * to the editor root names and values equal to the data that should be set in each root:
+  *
+  * ```ts
+  * editor.setData( {
+  *     header: '<p>Content for header part.</p>',
+  *     content: '<p>Content for main part.</p>',
+  *     footer: '<p>Content for footer part.</p>'
+  * } );
+  * ```
+  *
+  * By default the editor accepts HTML. This can be controlled by injecting a different data processor.
+  * See the {@glink features/markdown Markdown output} guide for more details.
+  *
+  * @param data Input data.
+  */
+  setData(t) {
+    this.data.set(t);
+  }
+  /**
+  * Gets the data from the editor.
+  *
+  * ```ts
+  * editor.getData(); // -> '<p>This is editor!</p>'
+  * ```
+  *
+  * If your editor implementation uses multiple roots, you should pass root name as one of the options:
+  *
+  * ```ts
+  * editor.getData( { rootName: 'header' } ); // -> '<p>Content for header part.</p>'
+  * ```
+  *
+  * By default, the editor outputs HTML. This can be controlled by injecting a different data processor.
+  * See the {@glink features/markdown Markdown output} guide for more details.
+  *
+  * A warning is logged when you try to retrieve data for a detached root, as most probably this is a mistake. A detached root should
+  * be treated like it is removed, and you should not save its data. Note, that the detached root data is always an empty string.
+  *
+  * @param options Additional configuration for the retrieved data.
+  * Editor features may introduce more configuration options that can be set through this parameter.
+  * @param options.rootName Root name. Defaults to `'main'`.
+  * @param options.trim Whether returned data should be trimmed. This option is set to `'empty'` by default,
+  * which means that whenever editor content is considered empty, an empty string is returned. To turn off trimming
+  * use `'none'`. In such cases exact content will be returned (for example `'<p>&nbsp;</p>'` for an empty editor).
+  * @returns Output data.
+  */
+  getData(t) {
+    return this.data.get(t);
+  }
+  /**
+  * Loads and initializes plugins specified in the configuration.
+  *
+  * @returns A promise which resolves once the initialization is completed, providing an array of loaded plugins.
+  */
+  async initPlugins() {
+    const t = this.config, i = t.get("plugins"), n = t.get("removePlugins") || [], s = t.get("extraPlugins") || [], c = t.get("substitutePlugins") || [], f = await this.plugins.init(i.concat(s), n, c);
+    return p(this), f;
+    function p(m) {
+      const w = m.config.get("licenseKey");
+      if (w === "GPL") return;
+      const h = z(w);
+      if (!h) return;
+      const y = [...m.plugins].map(([g]) => g).find((g) => !g.pluginName || !g.licenseFeatureCode ? !1 : ot(h, g.licenseFeatureCode));
+      y && (m.enableReadOnlyMode(Symbol("invalidLicense")), m._showLicenseError("pluginNotAllowed", y.pluginName));
+    }
+  }
+  /**
+  * Destroys the editor instance, releasing all resources used by it.
+  *
+  * **Note** The editor cannot be destroyed during the initialization phase so if it is called
+  * while the editor {@link #state is being initialized}, it will wait for the editor initialization before destroying it.
+  *
+  * @fires destroy
+  * @returns A promise that resolves once the editor instance is fully destroyed.
+  */
+  async destroy() {
+    this.state == "initializing" && await new Promise((t) => this.once("ready", t)), this.fire("destroy"), this.stopListening(), this.commands.destroy(), await this.plugins.destroy(), this.model.destroy(), this.data.destroy(), this.editing.destroy(), this.keystrokes.destroy(), await this._context._removeEditor(this);
+  }
+  /**
+  * Executes the specified command with given parameters.
+  *
+  * Shorthand for:
+  *
+  * ```ts
+  * editor.commands.get( commandName ).execute( ... );
+  * ```
+  *
+  * @param commandName The name of the command to execute.
+  * @param commandParams Command parameters.
+  * @returns The value returned by the {@link module:core/commandcollection~CommandCollection#execute `commands.execute()`}.
+  */
+  execute(t, ...i) {
+    try {
+      return this.commands.execute(t, ...i);
+    } catch (n) {
+      /* v8 ignore next -- @preserve */
+      a.rethrowUnexpectedError(n, this);
+    }
+  }
+  /**
+  * Focuses the editor.
+  *
+  * **Note** To explicitly focus the editing area of the editor, use the
+  * {@link module:engine/view/view~EditingView#focus `editor.editing.view.focus()`} method of the editing view.
+  *
+  * Check out the {@glink framework/deep-dive/ui/focus-tracking#focus-in-the-editor-ui Focus in the editor UI} section
+  * of the {@glink framework/deep-dive/ui/focus-tracking Deep dive into focus tracking} guide to learn more.
+  */
+  focus() {
+    this.editing.view.focus();
+  }
+  /**
+  * Registers a given string as a root attribute key. Registered root attributes are added to
+  * the {@link module:engine/model/schema~ModelSchema schema}.
+  *
+  * **Note:** Attributes passed in the configuration for multi-root editors
+  * ({@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.modelAttributes`}) or
+  * single-root editors ({@link module:core/editor/editorconfig~EditorConfig#root `config.root.modelAttributes`})
+  * are automatically registered when the editor is initialized. However, registering the same attribute twice
+  * does not have any negative impact, so it is recommended to use this method in any feature that uses
+  * root attributes.
+  *
+  * **Note:** Registered attributes are attached only to the generic `$root` schema element. A custom root
+  * {@link module:core/editor/editorconfig~RootConfig#modelElement `modelElement`} must opt into the `$root`
+  * attribute chain via `allowAttributesOf: '$root'` to inherit these attributes.
+  * See the {@glink framework/deep-dive/schema#custom-root-elements Custom root elements} section of the
+  * {@glink framework/deep-dive/schema Schema deep-dive} guide for more details.
+  */
+  registerRootAttribute(t) {
+    this._registeredRootsAttributesKeys.has(t) || (this._registeredRootsAttributesKeys.add(t), this.editing.model.schema.extend("$root", { allowAttributes: t }));
+  }
+  /**
+  * Returns attributes for the specified root.
+  * If no root name is provided, it returns attributes for the 'main' root by default.
+  *
+  * Note: all and only {@link ~Editor#registerRootAttribute registered} roots attributes will be returned.
+  * If a registered root attribute is not set for a given root, `null` will be returned.
+  */
+  getRootAttributes(t = "main") {
+    const i = this.model.document.getRoot(t);
+    if (!i)
+      throw new a("get-root-attributes-missing-root", this, { rootName: t });
+    const n = {};
+    for (const s of this._registeredRootsAttributesKeys) n[s] = i.hasAttribute(s) ? i.getAttribute(s) : null;
+    return n;
+  }
+  /**
+  * Creates and initializes a new editor instance.
+  *
+  * This is an abstract method. Every editor type needs to implement its own initialization logic.
+  *
+  * See the `create()` methods of the existing editor types to learn how to use them:
+  *
+  * * {@link module:editor-classic/classiceditor~ClassicEditor.create `ClassicEditor.create()`}
+  * * {@link module:editor-balloon/ballooneditor~BalloonEditor.create `BalloonEditor.create()`}
+  * * {@link module:editor-decoupled/decouplededitor~DecoupledEditor.create `DecoupledEditor.create()`}
+  * * {@link module:editor-inline/inlineeditor~InlineEditor.create `InlineEditor.create()`}
+  */
+  static create(...t) {
+    throw new Error("This is an abstract method.");
+  }
+  _showLicenseError(t, i) {
+    setTimeout(() => {
+      if (t == "invalid")
+        throw new a("invalid-license-key");
+      if (t == "expired")
+        throw new a("license-key-expired");
+      if (t == "domainLimit")
+        throw new a("license-key-domain-limit");
+      if (t == "pluginNotAllowed") {
+        const n = i.replace(/(Editing|UI)$/, ""), s = this.plugins.has(n);
+        throw new a("license-key-plugin-not-allowed", null, { pluginName: s ? n : i });
+      }
+      if (t == "featureNotAllowed")
+        throw new a("license-key-feature-not-allowed", null, { featureName: i });
+      if (t == "evaluationLimit")
+        throw new a("license-key-evaluation-limit");
+      if (t == "trialLimit")
+        throw new a("license-key-trial-limit");
+      if (t == "developmentLimit")
+        throw new a("license-key-development-limit");
+      if (t == "usageLimit")
+        throw new a("license-key-usage-limit");
+      /* v8 ignore else -- @preserve */
+      if (t == "distributionChannel")
+        throw new a("license-key-invalid-distribution-channel");
+    }, 0), this._showLicenseError = () => {
+    };
+  }
+  /**
+  * This part of the code is _not_ executed in installations under the GPL license (with `config.licenseKey = 'GPL'`).
+  *
+  * It is only executed when a specific license key is provided. If you are uncertain whether
+  * this applies to your installation, please contact our support team.
+  */
+  async _sendUsageRequest(t, i) {
+    const n = new Headers({ "Content-Type": "application/json" }), s = await fetch(new URL(t), {
+      method: "POST",
+      headers: n,
+      body: JSON.stringify(i)
+    });
+    if (!s.ok) throw new Error(`HTTP Response: ${s.status}`);
+    return s.json();
+  }
+}, /**
+* The default configuration which is built into the editor class.
+*
+* It was used in the now deprecated CKEditor 5 builds to provide the default configuration options
+* which are later used during the editor initialization.
+*
+* ```ts
+* ClassicEditor.defaultConfig = {
+* 	foo: 1,
+* 	bar: 2
+* };
+*
+* ClassicEditor
+* 	.create( sourceElement )
+* 	.then( editor => {
+* 		editor.config.get( 'foo' ); // -> 1
+* 		editor.config.get( 'bar' ); // -> 2
+* 	} );
+*
+* // The default options can be overridden by the configuration passed to create().
+* ClassicEditor
+* 	.create( { bar: 3 } )
+* 	.then( editor => {
+* 		editor.config.get( 'foo' ); // -> 1
+* 		editor.config.get( 'bar' ); // -> 3
+* 	} );
+* ```
+*
+* See also {@link module:core/editor/editor~Editor.builtinPlugins}.
+*/
+u(S, "defaultConfig"), /**
+* An array of plugins built into this editor class.
+*
+* It is used in the now deprecated CKEditor 5 builds to provide a list of plugins which are later automatically initialized
+* during the editor initialization.
+*
+* They will be automatically initialized by the editor, unless listed in `config.removePlugins` and
+* unless `config.plugins` is passed.
+*
+* ```ts
+* // Build some plugins into the editor class first.
+* ClassicEditor.builtinPlugins = [ FooPlugin, BarPlugin ];
+*
+* // Normally, you need to define config.plugins, but since ClassicEditor.builtinPlugins was
+* // defined, now you can call create() without any configuration.
+* ClassicEditor
+* 	.create( sourceElement )
+* 	.then( editor => {
+* 		editor.plugins.get( FooPlugin ); // -> An instance of the Foo plugin.
+* 		editor.plugins.get( BarPlugin ); // -> An instance of the Bar plugin.
+* 	} );
+*
+* ClassicEditor
+* 	.create( {
+* 		// Do not initialize these plugins (note: it is defined by a string):
+* 		removePlugins: [ 'Foo' ]
+* 	} )
+* 	.then( editor => {
+* 		editor.plugins.get( FooPlugin ); // -> Undefined.
+* 		editor.config.get( BarPlugin ); // -> An instance of the Bar plugin.
+* 	} );
+*
+* ClassicEditor
+* 	.create( {
+* 		// Load only this plugin. It can also be defined by a string if
+* 		// this plugin was built into the editor class.
+* 		plugins: [ FooPlugin ]
+* 	} )
+* 	.then( editor => {
+* 		editor.plugins.get( FooPlugin ); // -> An instance of the Foo plugin.
+* 		editor.config.get( BarPlugin ); // -> Undefined.
+* 	} );
+* ```
+*
+* See also {@link module:core/editor/editor~Editor.defaultConfig}.
+*/
+u(S, "builtinPlugins"), /**
+* The {@link module:core/context~Context} class.
+*
+* Exposed as static editor field for easier access in editor builds.
+*/
+u(S, "Context", W), /**
+* The {@link module:watchdog/editorwatchdog~EditorWatchdog} class.
+*
+* Exposed as static editor field for easier access in editor builds.
+*/
+u(S, "EditorWatchdog", bt), /**
+* The {@link module:watchdog/contextwatchdog~ContextWatchdog} class.
+*
+* Exposed as static editor field for easier access in editor builds.
+*/
+u(S, "ContextWatchdog", _t), S);
+function Tt(e) {
+  const t = At(e);
+  function i(n, s) {
+    if (dt(t, n) !== void 0)
+      throw new a("editor-usage-data-path-already-set", { path: n });
+    ft(t, n, s);
+  }
+  return e.fire("collectUsageData", { setUsageData: i }), t;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function te(e) {
+  if (!B(e.updateSourceElement))
+    throw new a("attachtoform-missing-elementapi-interface", e);
+  const t = e.sourceElement;
+  if (Kt(t) && t.form) {
+    let i;
+    const n = t.form, s = () => e.updateSourceElement();
+    B(n.submit) && (i = n.submit, n.submit = () => {
+      s(), i.apply(n);
+    }), n.addEventListener("submit", s), e.on("destroy", () => {
+      n.removeEventListener("submit", s), i && (n.submit = i);
+    });
+  }
+}
+function Kt(e) {
+  return !!e && e.tagName.toLowerCase() === "textarea";
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function ee(e) {
+  class t extends e {
+    constructor() {
+      super(...arguments);
+      u(this, "sourceElement");
+    }
+    updateSourceElement(s) {
+      if (!this.sourceElement)
+        throw new a("editor-missing-sourceelement", this);
+      const c = this.config.get("updateSourceElementOnDestroy"), f = this.sourceElement instanceof HTMLTextAreaElement;
+      if (!c && !f) {
+        q(this.sourceElement, "");
+        return;
+      }
+      const p = typeof s == "string" ? s : this.data.get();
+      q(this.sourceElement, p);
+    }
+  }
+  return t;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const Ut = [["description", "$description"], ["title", "$title"]];
+function ie(e) {
+  const t = e.config.get("roots");
+  for (const [s, c] of Object.entries(t)) {
+    let f = null;
+    for (const [p, m] of Ut)
+      c[p] == null || c.modelAttributes && m in c.modelAttributes || (f = f || { ...c.modelAttributes }, f[m] = c[p]);
+    f && e.config.set(`roots.${s}.modelAttributes`, f);
+  }
+  const i = e.config.get("roots");
+  let n = !1;
+  for (const s of Object.values(i)) for (const c of Object.keys(s.modelAttributes || {}))
+    e.registerRootAttribute(c), n = !0;
+  n && e.data.once("init", () => {
+    e.model.enqueueChange({ isUndoable: !1 }, (s) => {
+      for (const [c, f] of Object.entries(i)) {
+        const p = e.model.document.getRoot(c);
+        if (p)
+          for (const [m, w] of Object.entries(f.modelAttributes || {})) w !== null && s.setAttribute(m, w, p);
+      }
+    });
+  });
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function ne(e, t, i = "main", n = !1) {
+  const s = t.get("root"), c = t.get("roots") || /* @__PURE__ */ Object.create(null);
+  if (!ut(c))
+    throw new a("editor-create-roots-not-plain-object", null);
+  if (s)
+    if (i) {
+      if (i in c)
+        throw new a("editor-create-roots-with-main", null);
+    } else throw new a("editor-create-multi-root-with-main", null);
+  i && !c[i] && (c[i] = s || /* @__PURE__ */ Object.create(null));
+  const f = jt(e), p = qt(t, f, i), m = Array.from(/* @__PURE__ */ new Set([
+    ...f ? Object.keys(e) : [],
+    ...Object.keys(c),
+    ...Object.keys(p)
+  ]));
+  for (const w of m) {
+    const h = c[w] || /* @__PURE__ */ Object.create(null), y = f ? e[w] : e;
+    if (!n && E(y)) {
+      if (h.element)
+        throw new a("editor-create-root-element-overspecified", null);
+      h.element = y;
+    }
+    if (n && E(h.element) && (Y("editor-create-root-element-not-supported"), h.element = void 0), h.initialData === void 0) if (p[w] === void 0) {
+      const g = E(h.element) ? h.element : void 0;
+      h.initialData = Mt(y || g || n && t.get("attachTo") || "");
+    } else {
+      if (y && !E(y))
+        throw new a("editor-create-initial-data-overspecified", null);
+      h.initialData = p[w];
+    }
+    else {
+      if (y && !E(y))
+        throw new a("editor-create-root-initial-data-overspecified", null);
+      if (p[w] !== void 0)
+        throw new a("editor-create-legacy-initial-data-overspecified", null);
+    }
+    h.placeholder ?? (h.placeholder = V(t, "placeholder", w)), h.label ?? (h.label = V(t, "label", w)), h.modelElement || (h.modelElement = "$root"), h.element = zt(h.element), c[w] = h;
+  }
+  if (n && E(e)) {
+    if (t.get("attachTo"))
+      throw new a("editor-create-attachto-overspecified", null);
+    t.set("attachTo", e);
+  }
+  if (!n && t.get("attachTo"))
+    throw new a("editor-create-attachto-ignored", null);
+  t.set("roots", c);
+}
+function se(e, t) {
+  return typeof e == "string" || E(e) || t && Object.keys(t).length ? {
+    sourceElementOrData: e,
+    editorConfig: t
+  } : {
+    sourceElementOrData: "",
+    editorConfig: e
+  };
+}
+function jt(e) {
+  return !!e && typeof e == "object" && !Array.isArray(e) && !E(e);
+}
+function Mt(e) {
+  return E(e) ? et(e) : e;
+}
+function qt(e, t, i) {
+  return t || !i ? e.get("initialData") || /* @__PURE__ */ Object.create(null) : { [i]: e.get("initialData") };
+}
+function V(e, t, i) {
+  const n = e.get(t);
+  if (n) return typeof n == "string" ? n : n[i];
+}
+function zt(e) {
+  if (e == null) return;
+  if (E(e))
+    return U(e.tagName), e;
+  if (typeof e == "string")
+    return U(e), { name: e };
+  const { name: t, classes: i, styles: n, attributes: s } = e;
+  t !== void 0 && U(t);
+  const { class: c, style: f, ...p } = s || {}, m = !!s && "class" in s, w = !!n && Object.keys(n).length > 0, h = w && !!f;
+  h && Y("editor-root-element-styles-overspecified");
+  const y = [...H(i), ...H(c)], g = { ...p };
+  return m && (g.class = ""), h ? g.style = "" : f && (g.style = f), {
+    ...t !== void 0 && { name: t },
+    ...y.length && { classes: y },
+    ...w && { styles: n },
+    ...Object.keys(g).length && { attributes: g }
+  };
+}
+function H(e) {
+  return e ? Z(e).flatMap((t) => t.split(/\s+/)).filter(Boolean) : [];
+}
+function U(e) {
+  if (typeof e != "string" || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(e))
+    throw new a("editor-wrong-element-name", null, { name: e });
+  if (["textarea", "input"].includes(e.toLowerCase()))
+    throw new a("editor-wrong-element", null);
+}
+function E(e) {
+  return ht(e);
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function oe(e) {
+  const t = e.model.schema, i = e.model.document;
+  for (const n of i.roots)
+    if (!(n === i.graveyard || !n.isAttached()) && !t.isLimit(n))
+      throw new a("editor-root-element-is-not-limit", null, {
+        rootName: n.rootName,
+        elementName: n.name
+      });
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function re(e, t) {
+  const i = e.model.document.getRoot(t);
+  return e.model.schema.checkChild(i, "$block");
+}
+export {
+  xt as Accessibility,
+  Qt as Command,
+  vt as CommandCollection,
+  W as Context,
+  St as EditingKeystrokeHandler,
+  Xt as Editor,
+  ee as ElementApiMixin,
+  Jt as Plugin,
+  Q as PluginCollection,
+  $ as _DEFAULT_ACCESSIBILITY_GROUP_ID,
+  At as _getEditorUsageData,
+  te as attachToForm,
+  ne as normalizeRootsConfig,
+  se as normalizeSingleRootEditorConstructorParams,
+  zt as normalizeViewRootElementDefinition,
+  ie as registerAndInitializeRootConfigAttributes,
+  re as rootAcceptsBlocks,
+  oe as verifyRootElements
+};
+//# sourceMappingURL=index.js.map