ckeditor5 1.37.5 → 1.38.0

data/npm_package/dist/index.mjs

@@ -1,110 +1,122 @@
-function f(e) {
+function d() {
+  const i = Promise.withResolvers();
+  return i.promise.catch(() => {
+  }), i;
+}
+function p(i) {
   switch (document.readyState) {
     case "loading":
-      document.addEventListener("DOMContentLoaded", e, { once: !0 });
+      document.addEventListener("DOMContentLoaded", i, { once: !0 });
       break;
     case "interactive":
     case "complete":
-      setTimeout(e, 0);
+      setTimeout(i, 0);
       break;
     default:
-      console.warn("Unexpected document.readyState:", document.readyState), setTimeout(e, 0);
+      console.warn("Unexpected document.readyState:", document.readyState), setTimeout(i, 0);
   }
 }
 const E = /* @__PURE__ */ new Map();
-function y(e) {
-  if (E.has(e))
-    return E.get(e);
-  const t = new Promise((i, n) => {
-    const s = document.createElement("script");
-    s.src = e, s.onload = i, s.onerror = n, document.head.appendChild(s);
+function y(i) {
+  if (E.has(i))
+    return E.get(i);
+  const t = new Promise((e, n) => {
+    const r = document.createElement("script");
+    r.src = i, r.onload = e, r.onerror = n, document.head.appendChild(r);
   });
-  return E.set(e, t), t;
+  return E.set(i, t), t;
 }
-function v(e) {
-  return typeof e == "string" && e !== "__proto__" && e !== "constructor" && e !== "prototype";
+function w(i) {
+  return typeof i == "string" && i !== "__proto__" && i !== "constructor" && i !== "prototype";
 }
-function C(e) {
+function v(i) {
   return Array.from(document.styleSheets).some(
-    (t) => t.href === e || t.href === new URL(e, window.location.href).href
+    (t) => t.href === i || t.href === new URL(i, window.location.href).href
   );
 }
-function b(e = []) {
-  const t = e.map(
-    (i) => new Promise((n, s) => {
-      if (C(i)) {
+function g(i = []) {
+  const t = i.map(
+    (e) => new Promise((n, r) => {
+      if (v(e)) {
         n();
         return;
       }
-      const r = document.createElement("link");
-      r.rel = "stylesheet", r.href = i, r.onerror = s, r.onload = () => n(), document.head.appendChild(r);
+      const s = document.createElement("link");
+      s.rel = "stylesheet", s.href = e, s.onerror = r, s.onload = () => n(), document.head.appendChild(s);
     })
   );
   return Promise.all(t);
 }
-function h(e = []) {
-  const t = async ({ url: n, import_name: s, import_as: r, window_name: c, stylesheets: d }) => {
-    if (d?.length && await b(d), c) {
-      let a = function() {
-        return Object.prototype.hasOwnProperty.call(window, c);
+function h(i = []) {
+  const t = async ({ url: n, import_name: r, import_as: s, window_name: o, stylesheets: a }) => {
+    if (a?.length && await g(a), o) {
+      let u = function() {
+        return Object.prototype.hasOwnProperty.call(window, o);
       };
-      if (n && !a() && await y(n), a() || window.dispatchEvent(
-        new CustomEvent(`ckeditor:request-cjs-plugin:${c}`)
-      ), !a())
+      if (n && !u() && await y(n), u() || window.dispatchEvent(
+        new CustomEvent(`ckeditor:request-cjs-plugin:${o}`)
+      ), !u())
         throw new Error(
-          `Plugin window['${c}'] not found in global scope. Please ensure the plugin is loaded before CKEditor initialization.`
+          `Plugin window['${o}'] not found in global scope. Please ensure the plugin is loaded before CKEditor initialization.`
         );
-      return window[c];
+      return window[o];
     }
-    const o = await import(s), l = o[r || "default"];
-    if (!l)
+    const l = await import(r), c = l[s || "default"];
+    if (!c)
       throw new Error(
-        `Plugin "${r || "default"}" not found in the ESM module "${s}"! Available imports: ${Object.keys(o).join(", ")}! Consider changing "import_as" value.`
+        `Plugin "${s || "default"}" not found in the ESM module "${r}"! Available imports: ${Object.keys(l).join(", ")}! Consider changing "import_as" value.`
       );
-    return l;
+    return c;
   };
-  function i(n) {
+  function e(n) {
     return t(typeof n == "string" ? { import_name: "ckeditor5", import_as: n } : n);
   }
-  return Promise.all(e.map(i));
+  return Promise.all(i.map(e));
 }
-function m(e) {
-  if (!e || typeof e != "object")
-    return e;
-  if (Array.isArray(e))
-    return e.map((n) => m(n));
-  const t = e;
+function f(i) {
+  if (!i || typeof i != "object")
+    return i;
+  if (Array.isArray(i))
+    return i.map((n) => f(n));
+  const t = i;
   if (t.$element && typeof t.$element == "string") {
     const n = document.querySelector(t.$element);
     return n || console.warn(`Element not found for selector: ${t.$element}`), n || null;
   }
-  const i = /* @__PURE__ */ Object.create(null);
-  for (const [n, s] of Object.entries(e))
-    i[n] = m(s);
-  return i;
-}
-function A() {
-  return Math.random().toString(36).substring(2);
+  const e = /* @__PURE__ */ Object.create(null);
+  for (const [n, r] of Object.entries(i))
+    e[n] = f(r);
+  return e;
 }
-class P extends HTMLElement {
+class C extends HTMLElement {
   instance = null;
-  instancePromise = Promise.withResolvers();
+  instancePromise = d();
   #e = /* @__PURE__ */ new Set();
+  /**
+   * Incremented on every (re)initialization and on disconnect. An initialization that finishes
+   * with a different value is stale and destroys the context it created.
+   */
+  #t = 0;
+  /**
+   * Unregisters the error callback of the current context instance.
+   */
+  #i = null;
   static get observedAttributes() {
     return ["plugins", "config"];
   }
-  async connectedCallback() {
-    try {
-      f(() => this.#t());
-    } catch (t) {
-      console.error("Failed to initialize context:", t), this.dispatchEvent(new CustomEvent("context-error", { detail: t }));
-    }
+  connectedCallback() {
+    p(() => this.#n());
   }
-  async attributeChangedCallback(t, i, n) {
-    i !== null && i !== n && await this.#t();
+  async attributeChangedCallback(t, e, n) {
+    e !== null && e !== n && await this.#n();
   }
   async disconnectedCallback() {
-    this.instance && (await this.instance.destroy(), this.instance = null);
+    this.#t++;
+    try {
+      await this.#r();
+    } catch (t) {
+      console.error("Failed to destroy context:", t);
+    }
   }
   /**
    * Register editor component with this context
@@ -122,30 +134,67 @@ class P extends HTMLElement {
   unregisterEditor(t) {
     this.#e.delete(t);
   }
+  /**
+   * Initializes the context and reports failures instead of leaking rejections
+   * (lifecycle callbacks are not awaited by the browser).
+   */
+  async #n() {
+    const t = ++this.#t;
+    try {
+      await this.#c(t);
+    } catch (e) {
+      if (t !== this.#t)
+        return;
+      this.instancePromise.reject(e), this.instancePromise = d(), this.#s("Failed to initialize context:", e);
+    }
+  }
   /**
    * Initialize CKEditor context with shared configuration
    *
    * @private
+   * @param generation - Value of `#generation` assigned to this initialization.
    */
-  async #t() {
-    this.instance && (this.instancePromise = Promise.withResolvers(), await this.instance.destroy(), this.instance = null), window.dispatchEvent(
+  async #c(t) {
+    await this.#r(), window.dispatchEvent(
       new CustomEvent("ckeditor:context:attach:before", { detail: { element: this } })
     );
-    const { Context: t, ContextWatchdog: i } = await import("ckeditor5"), n = await this.#i(), s = this.#s();
+    const { Context: e, onEditorError: n } = await import("ckeditor5"), r = await this.#o(), s = this.#a();
     window.dispatchEvent(
       new CustomEvent("ckeditor:context:attach", { detail: { config: s, element: this } })
-    ), this.instance = new i(t, {
-      crashNumberLimit: 10
-    }), await this.instance.create({
+    );
+    const o = await e.create({
       ...s,
-      plugins: n
-    }), this.instance.on("itemError", (...r) => {
-      console.error("Context item error:", ...r);
-    }), this.instancePromise.resolve(this.instance), this.dispatchEvent(new CustomEvent("context-ready", { detail: this.instance })), await Promise.all(
-      [...this.#e].map((r) => r.reinitializeEditor())
+      plugins: r
+    });
+    if (t !== this.#t) {
+      await o.destroy();
+      return;
+    }
+    this.instance = o, this.#i = n(({ error: a, source: l }) => {
+      if (l === o) {
+        for (const c of o.editors)
+          c.enableReadOnlyMode("error-handling");
+        this.#s("Context failed:", a);
+      }
+    }), this.instancePromise.resolve(o), this.dispatchEvent(new CustomEvent("context-ready", { detail: o })), await Promise.all(
+      [...this.#e].map((a) => a.reinitializeEditor().catch(() => {
+      }))
     );
   }
-  async #i() {
+  /**
+   * Destroys the current context instance (and all editors created in it).
+   */
+  async #r() {
+    const { instance: t } = this;
+    t && (this.#i?.(), this.#i = null, this.instance = null, this.instancePromise = d(), await t.destroy());
+  }
+  /**
+   * Logs the error and dispatches the `context-error` event.
+   */
+  #s(t, e) {
+    console.error(t, e), this.dispatchEvent(new CustomEvent("context-error", { detail: e }));
+  }
+  async #o() {
     const t = this.getAttribute("plugins");
     return h(t ? JSON.parse(t) : []);
   }
@@ -154,13 +203,13 @@ class P extends HTMLElement {
    *
    * @private
    */
-  #s() {
+  #a() {
     const t = JSON.parse(this.getAttribute("config") || "{}");
-    return m(t);
+    return f(t);
   }
 }
-customElements.define("ckeditor-context-component", P);
-class x extends HTMLElement {
+customElements.define("ckeditor-context-component", C);
+class A extends HTMLElement {
   /**
    * Gets the name of this editable region
    */
@@ -190,13 +239,13 @@ class x extends HTMLElement {
    * Sets up the editable element and registers it with the parent editor
    */
   connectedCallback() {
-    f(() => {
+    p(() => {
       const t = this.#e();
       if (!t)
         throw new Error("ckeditor-editable-component must be a child of ckeditor-component");
       if (this.innerHTML = `<div>${this.innerHTML}</div>`, this.style.display = "block", t.isDecoupled())
-        t.runAfterEditorReady((i) => {
-          this.appendChild(i.ui.view[this.name].element);
+        t.runAfterEditorReady((e) => {
+          this.appendChild(e.ui.view[this.name].element);
         });
       else if (t.editables) {
         if (!this.name)
@@ -220,8 +269,8 @@ class x extends HTMLElement {
     return this.closest("ckeditor-component") || document.body.querySelector("ckeditor-component");
   }
 }
-customElements.define("ckeditor-editable-component", x);
-class w {
+customElements.define("ckeditor-editable-component", A);
+class b {
   #e;
   #t;
   /**
@@ -231,16 +280,16 @@ class w {
    * @param initialEditables - Initial editable elements
    * @returns Proxy wrapping the tracker
    */
-  constructor(t, i = {}) {
-    return this.#e = t, this.#t = i, new Proxy(this, {
+  constructor(t, e = {}) {
+    return this.#e = t, this.#t = e, new Proxy(this, {
       /**
        * Handles property access, returns class methods or editable elements
        *
        * @param target - The tracker instance
        * @param name - Property name being accessed
        */
-      get(n, s) {
-        return typeof n[s] == "function" ? n[s].bind(n) : n.#t[s];
+      get(n, r) {
+        return typeof n[r] == "function" ? n[r].bind(n) : n.#t[r];
       },
       /**
        * Handles setting new editable elements, triggers root attachment
@@ -249,8 +298,8 @@ class w {
        * @param name - Name of the editable root
        * @param element - Element to attach as editable
        */
-      set(n, s, r) {
-        return n.#t[s] !== r && (n.attachRoot(s, r), n.#t[s] = r), !0;
+      set(n, r, s) {
+        return n.#t[r] !== s && (n.attachRoot(r, s), n.#t[r] = s), !0;
       },
       /**
        * Handles removing editable elements, triggers root detachment
@@ -258,8 +307,8 @@ class w {
        * @param target - The tracker instance
        * @param name - Name of the root to remove
        */
-      deleteProperty(n, s) {
-        return n.detachRoot(s), delete n.#t[s], !0;
+      deleteProperty(n, r) {
+        return n.detachRoot(r), delete n.#t[r], !0;
       }
     });
   }
@@ -271,18 +320,18 @@ class w {
    * @param element - DOM element to use as editable
    * @returns Resolves when root is attached
    */
-  async attachRoot(t, i) {
+  async attachRoot(t, e) {
     return await this.detachRoot(t), this.#e.runAfterEditorReady((n) => {
-      const { ui: s, editing: r, model: c } = n, d = i.modelElement, o = i.initialData;
+      const { ui: r, editing: s, model: o } = n, a = e.modelElement, l = e.initialData;
       n.addRoot(t, {
         isUndoable: !1,
-        initialData: o ?? i.innerHTML,
-        ...d && { modelElement: d }
+        initialData: l ?? e.innerHTML,
+        ...a && { modelElement: a }
       });
-      const l = c.document.getRoot(t);
-      s.getEditableElement(t) && n.detachEditable(l);
-      const a = s.view.createEditable(t, i);
-      s.addEditable(a), r.view.forceRender();
+      const c = o.document.getRoot(t);
+      r.getEditableElement(t) && n.detachEditable(c);
+      const u = r.view.createEditable(t, e);
+      r.addEditable(u), s.view.forceRender();
     });
   }
   /**
@@ -293,9 +342,9 @@ class w {
    * @returns Resolves when root is detached
    */
   async detachRoot(t) {
-    return this.#e.runAfterEditorReady((i) => {
-      const n = i.model.document.getRoot(t);
-      n && (i.detachEditable(n), i.detachRoot(t, !0));
+    return this.#e.runAfterEditorReady((e) => {
+      const n = e.model.document.getRoot(t);
+      n && (e.detachEditable(n), e.detachRoot(t, !0));
     });
   }
   /**
@@ -307,15 +356,22 @@ class w {
     return this.#t;
   }
 }
-class p extends HTMLElement {
-  instancePromise = Promise.withResolvers();
-  watchdog = null;
+class m extends HTMLElement {
+  instancePromise = d();
   instance = null;
   editables = /* @__PURE__ */ Object.create(null);
   #e = "";
   #t = null;
-  #i = null;
-  #s = null;
+  /**
+   * Incremented on every (re)initialization and on disconnect. An initialization that finishes
+   * with a different value is stale and destroys the editor it created.
+   */
+  #i = 0;
+  /**
+   * Unregisters the error callback of the current editor instance.
+   */
+  #n = null;
+  #c = null;
   /**
    * List of attributes that trigger updates when changed.
    */
@@ -332,19 +388,19 @@ class p extends HTMLElement {
     return this.#r("editorchange");
   }
   set oneditorchange(t) {
-    this.#o("editorchange", t);
+    this.#s("editorchange", t);
   }
   get oneditorready() {
     return this.#r("editorready");
   }
   set oneditorready(t) {
-    this.#o("editorready", t);
+    this.#s("editorready", t);
   }
   get oneditorerror() {
     return this.#r("editorerror");
   }
   set oneditorerror(t) {
-    this.#o("editorerror", t);
+    this.#s("editorerror", t);
   }
   /**
    * Gets event handler function from attribute or property
@@ -354,7 +410,7 @@ class p extends HTMLElement {
    * @returns Event handler or null
    */
   #r(t) {
-    return this.hasAttribute(`on${t}`) ? z(this.getAttribute(`on${t}`)) : this[`#${t}Handler`];
+    return this.hasAttribute(`on${t}`) ? j(this.getAttribute(`on${t}`)) : this[`#${t}Handler`];
   }
   /**
    * Sets event handler function
@@ -363,8 +419,8 @@ class p extends HTMLElement {
    * @param name - Event name without 'on' prefix
    * @param handler - Event handler
    */
-  #o(t, i) {
-    typeof i == "string" ? this.setAttribute(`on${t}`, i) : (this.removeAttribute(`on${t}`), this[`#${t}Handler`] = i);
+  #s(t, e) {
+    typeof e == "string" ? this.setAttribute(`on${t}`, e) : (this.removeAttribute(`on${t}`), this[`#${t}Handler`] = e);
   }
   /**
    * Lifecycle callback when element is connected to DOM
@@ -373,16 +429,19 @@ class p extends HTMLElement {
    * @protected
    */
   connectedCallback() {
-    this.#t = this.closest("ckeditor-context-component"), this.#e = this.innerHTML;
-    try {
-      f(async () => {
-        this.#t && (await this.#t.instancePromise.promise, this.#t.registerEditor(this)), await this.reinitializeEditor();
+    this.#t = this.closest("ckeditor-context-component"), this.#e = this.innerHTML, p(async () => {
+      if (this.#t) {
+        try {
+          await this.#t.instancePromise.promise;
+        } catch (t) {
+          this.#l("Failed to initialize editor:", t);
+          return;
+        }
+        this.#t.registerEditor(this);
+      }
+      await this.reinitializeEditor().catch(() => {
       });
-    } catch (t) {
-      console.error("Failed to initialize editor:", t);
-      const i = new CustomEvent("editor-error", { detail: t });
-      this.dispatchEvent(i), this.oneditorerror?.(i);
-    }
+    });
   }
   /**
    * Handles attribute changes and reinitializes editor if needed
@@ -392,8 +451,9 @@ class p extends HTMLElement {
    * @param oldValue - Previous attribute value
    * @param newValue - New attribute value
    */
-  async attributeChangedCallback(t, i, n) {
-    i !== null && i !== n && p.observedAttributes.includes(t) && this.isConnected && await this.reinitializeEditor();
+  async attributeChangedCallback(t, e, n) {
+    e !== null && e !== n && m.observedAttributes.includes(t) && this.isConnected && await this.reinitializeEditor().catch(() => {
+    });
   }
   /**
    * Lifecycle callback when element is removed from DOM
@@ -401,9 +461,9 @@ class p extends HTMLElement {
    * @protected
    */
   async disconnectedCallback() {
-    this.#t && this.#t.unregisterEditor(this);
+    this.#t && this.#t.unregisterEditor(this), this.#i++;
     try {
-      await this.#l();
+      await this.#a();
     } catch (t) {
       console.error("Failed to destroy editor:", t);
     }
@@ -420,70 +480,67 @@ class p extends HTMLElement {
   /**
    * Determines appropriate editor element tag based on editor type
    */
-  get #n() {
-    return S(this.getAttribute("type"));
+  get #o() {
+    return P(this.getAttribute("type"));
   }
   /**
-   * Gets the CKEditor context instance if available.
+   * Destroys the current editor instance, if any.
    */
-  get #a() {
-    return this.#t?.instance;
+  async #a() {
+    const t = this.#u();
+    t && t.state !== "destroyed" && await t.destroy();
+  }
+  /**
+   * Detaches the current editor instance from the component without destroying it.
+   *
+   * @returns The detached instance or `null` if there was none.
+   */
+  #u() {
+    const { instance: t } = this;
+    return t ? (this.#n?.(), this.#n = null, this.instance = null, this.instancePromise = d(), t) : null;
   }
   /**
-   * Destroys the editor instance and watchdog if available
+   * Logs the error and dispatches the `editor-error` event.
    */
-  async #l() {
-    this.#i && await this.#a.remove(this.#i), await this.instance?.destroy(), this.watchdog?.destroy();
+  #l(t, e) {
+    console.error(t, e);
+    const n = new CustomEvent("editor-error", { detail: e });
+    this.dispatchEvent(n), this.oneditorerror?.(n);
   }
   /**
    * Gets editor configuration with resolved element references
    */
-  #d() {
-    return R(this.getAttribute("config"));
+  #h() {
+    return x(this.getAttribute("config"));
   }
   /**
    * Creates a new CKEditor instance
    */
-  async #h(t) {
+  async #m(t) {
+    const e = this.#t ? await this.#t.instancePromise.promise : null;
     await Promise.all([
-      this.#E(),
-      this.#b()
+      this.#y(),
+      this.#w()
     ]);
-    const { isMultiroot: i, content: n } = M(t), s = k(n, i);
+    const { isMultiroot: n, content: r } = S(t), s = M(r, n);
     window.dispatchEvent(
       new CustomEvent("ckeditor:attach:before", { detail: s })
     );
-    const r = await this.#v(), [c, d] = await Promise.all([
-      this.#y(),
-      this.#w()
-    ]), o = {
-      ...this.#d(),
-      ...d.length && {
-        translations: d
+    const o = await this.#A(), [a, l] = await Promise.all([
+      this.#C(),
+      this.#v()
+    ]), c = {
+      ...this.#h(),
+      ...l.length && {
+        translations: l
       },
-      plugins: c
+      plugins: a
     };
-    D(o, n, i, this.isClassic()), window.dispatchEvent(
-      new CustomEvent("ckeditor:attach", { detail: { config: o, ...s } })
+    return R(c, r, n, this.isClassic()), window.dispatchEvent(
+      new CustomEvent("ckeditor:attach", { detail: { config: c, ...s } })
+    ), o.create(
+      e ? { ...c, context: e } : c
     );
-    let l = null, a = null, u = null;
-    if (this.#t)
-      u = A(), await this.#a.add({
-        creator: (g) => r.create(g),
-        id: u,
-        type: "editor",
-        config: o
-      }), a = this.#a.getItem(u);
-    else if (this.hasWatchdog()) {
-      const { EditorWatchdog: g } = await import("ckeditor5");
-      l = new g(r), await l.create(o), a = l.editor;
-    } else
-      a = await r.create(o);
-    return {
-      contextId: u,
-      instance: a,
-      watchdog: l
-    };
   }
   /**
    * Re-initializes the editor by destroying existing instance and creating new one
@@ -492,29 +549,43 @@ class p extends HTMLElement {
    * @returns {Promise<void>}
    */
   async reinitializeEditor() {
-    this.instance && (this.instancePromise = Promise.withResolvers(), await this.#l(), this.instance = null), this.style.display = "block", !this.isMultiroot() && !this.isDecoupled() && (this.innerHTML = `<${this.#n}>${this.#e}</${this.#n}>`, this.#p()), this.isMultiroot() ? this.editables = new w(this, this.#u()) : this.isDecoupled() ? this.editables = null : this.editables = this.#u();
+    const t = ++this.#i;
     try {
-      const { watchdog: t, instance: i, contextId: n } = await this.#h(this.editables || this.#d().root?.initialData || "");
-      this.watchdog = t, this.instance = i, this.#i = n, this.#f(), this.#g(), this.#m(), this.instancePromise.resolve(this.instance);
-      const s = new CustomEvent("editor-ready", { detail: this.instance });
-      this.dispatchEvent(s), this.oneditorready?.(s);
-    } catch (t) {
-      throw this.instancePromise.reject(t), t;
+      await this.#a(), this.style.display = "block", !this.isMultiroot() && !this.isDecoupled() && (this.innerHTML = `<${this.#o}>${this.#e}</${this.#o}>`, this.#E()), this.isMultiroot() ? this.editables = new b(this, this.#f()) : this.isDecoupled() ? this.editables = null : this.editables = this.#f();
+      const [e, { onEditorError: n }] = await Promise.all([
+        this.#m(this.editables || this.#h().root?.initialData || ""),
+        import("ckeditor5")
+      ]);
+      if (t !== this.#i) {
+        e.state !== "destroyed" && await e.destroy();
+        return;
+      }
+      this.instance = e, this.#n = n(({ error: s, source: o }) => {
+        o === e && (e.enableReadOnlyMode("error-handling"), this.#l("Editor failed:", s));
+      }), e.once("destroy", () => {
+        this.instance === e && this.#u();
+      }), this.#g(), this.#b(), this.#p(), this.instancePromise.resolve(e);
+      const r = new CustomEvent("editor-ready", { detail: e });
+      this.dispatchEvent(r), this.oneditorready?.(r);
+    } catch (e) {
+      if (t !== this.#i)
+        return;
+      throw this.instancePromise.reject(e), this.instancePromise = d(), this.#l("Failed to initialize editor:", e), e;
     }
   }
   /**
    * Sets up data change listener that broadcasts content changes
    */
-  #m() {
-    const t = (n) => this.instance.getData({ rootName: n }), i = () => this.instance?.model.document.getRootNames().reduce((n, s) => ({
+  #p() {
+    const t = (n) => this.instance.getData({ rootName: n }), e = () => this.instance?.model.document.getRootNames().reduce((n, r) => ({
       ...n,
-      [s]: t(s)
+      [r]: t(r)
     }), {});
     this.instance?.model.document.on("change:data", () => {
       const n = new CustomEvent("editor-change", {
         detail: {
           editor: this.instance,
-          data: i()
+          data: e()
         },
         bubbles: !0
       });
@@ -545,25 +616,19 @@ class p extends HTMLElement {
   isDecoupled() {
     return this.getAttribute("type") === "DecoupledEditor";
   }
-  /**
-   * Checks if current editor has watchdog enabled
-   */
-  hasWatchdog() {
-    return this.getAttribute("watchdog") === "true";
-  }
   /**
    * Queries and validates editable elements
    */
-  #u() {
+  #f() {
     if (this.isDecoupled())
       return {};
     if (this.isMultiroot()) {
-      const i = [...this.querySelectorAll("ckeditor-editable-component")];
-      return H(i);
+      const e = [...this.querySelectorAll("ckeditor-editable-component")];
+      return D(e);
     }
-    const t = this.querySelector(this.#n);
+    const t = this.querySelector(this.#o);
     if (!t)
-      throw new Error(`No ${this.#n} element found`);
+      throw new Error(`No ${this.#o} element found`);
     return { main: t };
   }
   /**
@@ -571,26 +636,26 @@ class p extends HTMLElement {
    *
    * @private
    */
-  #p() {
+  #E() {
     const t = this.querySelector("textarea");
-    t && T(this, t, p.inputAttributes);
+    t && $(this, t, m.inputAttributes);
   }
   /**
    * Sets up content sync between editor and textarea element.
    *
    * @private
    */
-  #f() {
+  #g() {
     if (!this.instance)
       return;
     const t = this.querySelector("textarea");
     if (!t)
       return;
-    const i = () => {
-      this.style.position = "relative", t.innerHTML = "", t.value = this.instance.getData(), L(t);
+    const e = () => {
+      this.style.position = "relative", t.innerHTML = "", t.value = this.instance.getData(), H(t);
     };
-    i(), this.instance.model.document.on("change:data", () => {
-      t.dispatchEvent(new Event("input", { bubbles: !0 })), t.dispatchEvent(new Event("change", { bubbles: !0 })), i();
+    e(), this.instance.model.document.on("change:data", () => {
+      t.dispatchEvent(new Event("input", { bubbles: !0 })), t.dispatchEvent(new Event("change", { bubbles: !0 })), e();
     });
   }
   /**
@@ -598,102 +663,102 @@ class p extends HTMLElement {
    *
    * @private
    */
-  #g() {
+  #b() {
     if (!this.isClassic() && !this.isBallon())
       return;
-    const t = I(this.getAttribute("editable-height"));
-    t !== null && O(this.instance, t);
+    const t = T(this.getAttribute("editable-height"));
+    t !== null && L(this.instance, t);
   }
   /**
    * Gets bundle JSON description from translations attribute
    */
-  #c() {
-    return this.#s ||= q(this.getAttribute("bundle"));
+  #d() {
+    return this.#c ||= O(this.getAttribute("bundle"));
   }
   /**
    * Checks if all required stylesheets are injected. If not, inject.
    */
-  async #E() {
-    await b(this.#c()?.stylesheets || []);
+  async #y() {
+    await g(this.#d()?.stylesheets || []);
   }
   /**
    * Checks if all required scripts are injected. If not, inject.
    */
-  async #b() {
-    const t = (this.#c()?.scripts || []).filter((i) => !!i.window_name);
+  async #w() {
+    const t = (this.#d()?.scripts || []).filter((e) => !!e.window_name);
     await h(t);
   }
   /**
    * Loads translation modules
    */
-  async #w() {
-    const t = this.#c()?.scripts.filter((i) => i.translation);
+  async #v() {
+    const t = this.#d()?.scripts.filter((e) => e.translation);
     return h(t);
   }
   /**
    * Loads plugin modules
    */
-  async #y() {
-    return h(j(this.getAttribute("plugins")));
+  async #C() {
+    return h(I(this.getAttribute("plugins")));
   }
   /**
    * Gets editor constructor based on type attribute
    */
-  async #v() {
+  async #A() {
     const t = await import("ckeditor5");
-    return N(t, this.getAttribute("type"));
+    return q(t, this.getAttribute("type"));
   }
 }
-function S(e) {
-  return e === "ClassicEditor" ? "textarea" : "div";
+function P(i) {
+  return i === "ClassicEditor" ? "textarea" : "div";
 }
-function R(e) {
-  const t = JSON.parse(e || "{}");
-  return m(t);
+function x(i) {
+  const t = JSON.parse(i || "{}");
+  return f(t);
 }
-function M(e) {
-  const t = e instanceof w;
-  let i = e;
-  return t ? i = e.getAll() : typeof e != "string" && (i = e.main), { isMultiroot: t, content: i };
+function S(i) {
+  const t = i instanceof b;
+  let e = i;
+  return t ? e = i.getAll() : typeof i != "string" && (e = i.main), { isMultiroot: t, content: e };
 }
-function k(e, t) {
+function M(i, t) {
   return {
-    ...e instanceof HTMLElement && { element: e },
-    ...typeof e == "string" && { data: e },
-    ...t && { editables: e }
+    ...i instanceof HTMLElement && { element: i },
+    ...typeof i == "string" && { data: i },
+    ...t && { editables: i }
   };
 }
-function D(e, t, i, n) {
-  i ? e.roots = $(t) : n && t instanceof HTMLElement ? e.attachTo = t : t instanceof HTMLElement ? e.root = { ...e.root, element: t } : typeof t == "string" && (e.root = { ...e.root, initialData: t });
+function R(i, t, e, n) {
+  e ? i.roots = k(t) : n && t instanceof HTMLElement ? i.attachTo = t : t instanceof HTMLElement ? i.root = { ...i.root, element: t } : typeof t == "string" && (i.root = { ...i.root, initialData: t });
 }
-function $(e) {
+function k(i) {
   return Object.fromEntries(
-    Object.entries(e).map(([t, i]) => {
-      const n = i.modelElement, s = i.initialData;
+    Object.entries(i).map(([t, e]) => {
+      const n = e.modelElement, r = e.initialData;
       return [
         t,
         {
-          element: i,
-          initialData: s ?? i.innerHTML,
+          element: e,
+          initialData: r ?? e.innerHTML,
           ...n && { modelElement: n }
         }
       ];
     })
   );
 }
-function H(e) {
-  return e.reduce((t, i) => {
-    if (!i.name)
+function D(i) {
+  return i.reduce((t, e) => {
+    if (!e.name)
       throw new Error('Editable component missing required "name" attribute');
-    return t[i.name] = i, t;
+    return t[e.name] = e, t;
   }, /* @__PURE__ */ Object.create(null));
 }
-function T(e, t, i) {
-  for (const n of i)
-    e.hasAttribute(n) && t.setAttribute(n, e.getAttribute(n));
+function $(i, t, e) {
+  for (const n of e)
+    i.hasAttribute(n) && t.setAttribute(n, i.getAttribute(n));
 }
-function L(e) {
-  e.tabIndex = -1, Object.assign(e.style, {
+function H(i) {
+  i.tabIndex = -1, Object.assign(i.style, {
     display: "flex",
     position: "absolute",
     bottom: "0",
@@ -707,45 +772,45 @@ function L(e) {
     border: "none"
   });
 }
-function I(e) {
-  if (e === null)
+function T(i) {
+  if (i === null)
     return null;
-  const t = Number.parseInt(e, 10);
+  const t = Number.parseInt(i, 10);
   return Number.isNaN(t) ? null : t;
 }
-function O(e, t) {
-  e.editing.view.change((i) => {
-    i.setStyle("height", `${t}px`, e.editing.view.document.getRoot());
+function L(i, t) {
+  i.editing.view.change((e) => {
+    e.setStyle("height", `${t}px`, i.editing.view.document.getRoot());
   });
 }
-function q(e) {
-  return JSON.parse(e);
+function O(i) {
+  return JSON.parse(i);
 }
-function j(e) {
-  return (e ? JSON.parse(e) : []).map(
-    (i) => typeof i == "string" ? { import_name: "ckeditor5", import_as: i } : i
+function I(i) {
+  return (i ? JSON.parse(i) : []).map(
+    (e) => typeof e == "string" ? { import_name: "ckeditor5", import_as: e } : e
   );
 }
-function N(e, t) {
-  if (!t || !Object.prototype.hasOwnProperty.call(e, t))
+function q(i, t) {
+  if (!t || !Object.prototype.hasOwnProperty.call(i, t))
     throw new Error(`Invalid editor type: ${t}`);
-  return e[t];
+  return i[t];
 }
-function z(e) {
-  if (!v(e))
-    throw new Error(`Unsafe event handler attribute value: ${e}`);
-  return window[e] || new Function("event", e);
+function j(i) {
+  if (!w(i))
+    throw new Error(`Unsafe event handler attribute value: ${i}`);
+  return window[i] || new Function("event", i);
 }
-customElements.define("ckeditor-component", p);
-class B extends HTMLElement {
+customElements.define("ckeditor-component", m);
+class z extends HTMLElement {
   /**
    * Lifecycle callback when element is added to DOM.
    * Adds the toolbar to the editor UI.
    */
   connectedCallback() {
-    f(async () => {
-      const t = this.getAttribute("name"), i = await this.#e().instancePromise.promise;
-      this.appendChild(i.ui.view[t].element);
+    p(async () => {
+      const t = this.getAttribute("name"), e = await this.#e().instancePromise.promise;
+      this.appendChild(e.ui.view[t].element);
     });
   }
   /**
@@ -755,5 +820,5 @@ class B extends HTMLElement {
     return this.closest("ckeditor-component") || document.body.querySelector("ckeditor-component");
   }
 }
-customElements.define("ckeditor-ui-part-component", B);
+customElements.define("ckeditor-ui-part-component", z);
 //# sourceMappingURL=index.mjs.map