@hkyhy/marsun-components-core 0.1.89 → 0.1.99

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

@@ -0,0 +1,471 @@
+import h, { memo as C, forwardRef as p, useRef as y, useEffect as v, useMemo as g } from "react";
+import { getInstalledCKBaseFeatures as f, assignElementToEditorConfig as S, assignInitialDataToEditorConfig as T, compareInstalledCKBaseVersion as L, createDefer as V, uid as W, isCKEditorFreeLicense as x, appendExtraPluginsToEditorConfig as k, mapObjectKeys as D, once as A, createIntegrationUsageDataPlugin as z, kebabToCamelCase as K } from "../../ckeditor5-integrations-common/dist/index.js";
+var O = Object.defineProperty, P = (i, e, t) => e in i ? O(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, d = (i, e, t) => P(i, typeof e != "symbol" ? e + "" : e, t);
+const b = class w {
+  constructor(e, t) {
+    d(this, "_lifecycle"), d(this, "_element"), d(this, "_releaseLock", null), d(this, "_value", null), d(this, "_afterMountCallbacks", []), d(this, "_state", {
+      destroyedBeforeInitialization: !1,
+      mountingInProgress: null
+    }), d(this, "release", A(() => {
+      const { _releaseLock: n, _state: r, _element: a, _lifecycle: o } = this;
+      r.mountingInProgress ? r.mountingInProgress.then(() => o.unmount({
+        element: a,
+        // Mount result might be overridden by watchdog during restart so use instance variable.
+        mountResult: this.value
+      })).catch((s) => {
+        console.error("CKEditor unmounting error:", s);
+      }).then(n.resolve).then(() => {
+        this._value = null;
+      }) : (r.destroyedBeforeInitialization = !0, n.resolve());
+    })), this._element = e, this._lifecycle = t, this._lock();
+  }
+  /**
+   * Getter for {@link #_value}.
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Resets the semaphore to its initial state.
+   */
+  discard() {
+    this._value = null, this._releaseLock = null, this._afterMountCallbacks = [], this._state = {
+      destroyedBeforeInitialization: !1,
+      mountingInProgress: null
+    };
+  }
+  /**
+   * Occasionally, the Watchdog restarts the editor instance, resulting in a new instance being assigned to the semaphore.
+   * In terms of race conditions, it's generally safer to simply override the semaphore value rather than recreating it
+   * with a different one.
+   */
+  unsafeSetValue(e) {
+    this._value = e, this._afterMountCallbacks.forEach((t) => {
+      this._lifecycle.isValueValid && !this._lifecycle.isValueValid(e) || t(e);
+    }), this._afterMountCallbacks = [];
+  }
+  /**
+   * This registers a callback that will be triggered after the editor has been successfully mounted.
+   *
+   * 	* If the editor is already mounted, the callback will be executed immediately.
+   *	* If the editor is in the process of mounting, the callback will be executed upon successful mounting.
+  * 	* If the editor is never mounted, the passed callback will not be executed.
+  * 	* If an exception is thrown within the callback, it will be re-thrown in the semaphore.
+  * 	* If the value is not valid (determined by isValueValid), the callback will not be executed.
+  */
+  runAfterMount(e) {
+    const { _value: t, _afterMountCallbacks: n } = this;
+    if (t) {
+      if (this._lifecycle.isValueValid && !this._lifecycle.isValueValid(t))
+        return;
+      e(t);
+    } else
+      n.push(e);
+  }
+  /**
+   * This method is used to inform other components that the {@link #_element} will be used by the editor,
+   * which is initialized by the {@link #_lifecycle} methods.
+   *
+   * 	* If an editor is already present on the provided element, the initialization of the current one
+   * 	  will be postponed until the previous one is destroyed.
+   *
+   * 	* If the element is empty and does not have an editor attached to it, the currently locked editor will
+   * 	  be mounted immediately.
+   *
+   * After the successful initialization of the editor and the assignment of the {@link #_value} member,
+   * the `onReady` lifecycle method is called.
+   *
+   * *Important note:*
+   *
+   * It’s really important to keep this method *sync*. If we make this method *async*, it won’t work well because
+   * it will cause problems when we’re trying to set up the {@link LifeCycleEditorElementSemaphore#_semaphores} map entries.
+   */
+  _lock() {
+    const { _semaphores: e } = w, { _state: t, _element: n, _lifecycle: r } = this, a = e.get(n) || Promise.resolve(null), o = V();
+    this._releaseLock = o;
+    const s = a.then(() => t.destroyedBeforeInitialization ? Promise.resolve(void 0) : (t.mountingInProgress = r.mount().then((l) => (l && this.unsafeSetValue(l), l)), t.mountingInProgress)).then(async (l) => {
+      l && r.afterMount && await r.afterMount({
+        element: n,
+        mountResult: l
+      });
+    }).then(() => o.promise).catch((l) => {
+      console.error("CKEditor mounting error:", l);
+    }).then(() => {
+      e.get(n) === s && e.delete(n);
+    });
+    e.set(n, s);
+  }
+};
+d(b, "_semaphores", /* @__PURE__ */ new Map());
+let B = b;
+const N = "$__CKEditorReactContextMetadata";
+function U(i, e) {
+  return {
+    ...e,
+    [N]: i
+  };
+}
+const F = h.createContext(null), H = (i) => !!i && typeof i == "object" && "status" in i && ["initializing", "initialized", "error"].includes(i.status), R = (i) => (e) => H(e) && e.status === i, E = R("initializing"), $ = (i) => R("initialized")(i) && i.watchdog.state === "ready", q = z(
+  "react",
+  {
+    version: "11.2.0",
+    frameworkVersion: h.version
+  }
+);
+function G(i) {
+  return x(i.licenseKey) ? i : k(i, [
+    /**
+     * This part of the code is not executed in open-source implementations using a GPL key.
+     * It only runs when a specific license key is provided. If you are uncertain whether
+     * this applies to your installation, please contact our support team.
+     */
+    q
+  ]);
+}
+class Y {
+  /**
+   * @param contextWatchdog The context watchdog instance that will be wrapped into editor watchdog API.
+   */
+  constructor(e) {
+    d(this, "_contextWatchdog"), d(this, "_id"), d(this, "_creator"), this._contextWatchdog = e, this._id = W();
+  }
+  /**
+   *  @param creator A watchdog's editor creator function.
+   */
+  setCreator(e) {
+    this._creator = e;
+  }
+  create(e, t) {
+    let n = {
+      creator: this._creator,
+      id: this._id,
+      type: "editor"
+    };
+    return t ? n = {
+      ...n,
+      sourceElementOrData: e,
+      config: t
+    } : n = {
+      ...n,
+      config: e
+    }, this._contextWatchdog.add(n);
+  }
+  /**
+   * Creates a listener that is attached to context watchdog's item and run when the context watchdog fires.
+   * Currently works only for the `error` event.
+   */
+  on(e, t) {
+    this._contextWatchdog.on("itemError", (n, { itemId: r, error: a }) => {
+      r === this._id && t(null, { error: a, causesRestart: void 0 });
+    });
+  }
+  destroy() {
+    return this._contextWatchdog.state === "ready" ? this._contextWatchdog.remove(this._id) : Promise.resolve();
+  }
+  /**
+   * An editor instance.
+   */
+  get editor() {
+    return this._contextWatchdog.getItem(this._id);
+  }
+}
+function J(i) {
+  return typeof i == "string" ? i : (i ?? []).join(" ");
+}
+function Q(i) {
+  return D(i, (e) => e.startsWith("--") ? e : K(e));
+}
+function M(i) {
+  if (typeof HTMLElement < "u" && i instanceof HTMLElement)
+    throw new Error(
+      "An HTMLElement cannot be used as an editor element definition. Please pass a string, a React component, or an object definition."
+    );
+  return typeof i != "object" || i === null ? {
+    name: i
+  } : i;
+}
+const _ = C(p(({ definition: i }, e) => {
+  const { name: t, classes: n, styles: r, attributes: a } = M(i ?? {
+    name: "div"
+  });
+  return /* @__PURE__ */ h.createElement(
+    t,
+    {
+      ref: e,
+      ...a,
+      style: Q(r ?? {}),
+      className: J(n)
+    }
+  );
+}));
+_.displayName = "EditorElement";
+const m = "Lock from React integration (@ckeditor/ckeditor5-react)";
+class X extends h.Component {
+  constructor(e) {
+    super(e), d(this, "domContainer", h.createRef()), d(this, "editorSemaphore", null), ee();
+  }
+  get _semaphoreValue() {
+    const { editorSemaphore: e } = this;
+    return e ? e.value : null;
+  }
+  /**
+   * An watchdog instance.
+   */
+  get watchdog() {
+    const { _semaphoreValue: e } = this;
+    return e ? e.watchdog : null;
+  }
+  /**
+   * An editor instance.
+   */
+  get editor() {
+    const { _semaphoreValue: e } = this;
+    return e ? e.instance : null;
+  }
+  /**
+   * The CKEditor component should not be updated by React itself.
+   * However, if the component identifier changes, the whole structure should be created once again.
+   */
+  shouldComponentUpdate(e) {
+    const { props: t, editorSemaphore: n } = this;
+    return e.id !== t.id || e.disableWatchdog !== t.disableWatchdog ? !0 : (n && (n.runAfterMount(({ instance: r }) => {
+      j(t, e, r) && r.data.set(e.data);
+    }), "disabled" in e && n.runAfterMount(({ instance: r }) => {
+      e.disabled ? r.enableReadOnlyMode(m) : r.disableReadOnlyMode(m);
+    })), !1);
+  }
+  /**
+   * Initialize the editor when the component is mounted.
+   */
+  componentDidMount() {
+    E(this.context) || this._initLifeCycleSemaphore();
+  }
+  /**
+   * Re-render the entire component once again. The old editor will be destroyed and the new one will be created.
+   */
+  componentDidUpdate() {
+    E(this.context) || this._initLifeCycleSemaphore();
+  }
+  /**
+   * Destroy the editor before unmounting the component.
+   */
+  componentWillUnmount() {
+    this._unlockLifeCycleSemaphore();
+  }
+  /**
+   * Async destroy attached editor and unlock element semaphore.
+   */
+  _unlockLifeCycleSemaphore() {
+    this.editorSemaphore && (this.editorSemaphore.release(), this.editorSemaphore = null);
+  }
+  /**
+   * Unlocks previous editor semaphore and creates new one..
+   */
+  _initLifeCycleSemaphore() {
+    this._unlockLifeCycleSemaphore(), this.editorSemaphore = new B(this.domContainer.current, {
+      isValueValid: (e) => e && !!e.instance,
+      mount: async () => {
+        var e, t;
+        try {
+          return await this._initializeEditor();
+        } catch (n) {
+          throw (t = (e = this.props).onError) == null || t.call(e, n, { phase: "initialization", willEditorRestart: !1 }), n;
+        }
+      },
+      afterMount: ({ mountResult: e }) => {
+        const { onReady: t } = this.props;
+        t && this.domContainer.current !== null && t(e.instance);
+      },
+      unmount: async ({ element: e, mountResult: t }) => {
+        const { onAfterDestroy: n } = this.props;
+        try {
+          await this._destroyEditor(t), e.innerHTML = "";
+        } finally {
+          n && n(t.instance);
+        }
+      }
+    });
+  }
+  /**
+   * Render a <div> element which will be replaced by CKEditor.
+   */
+  render() {
+    const { editor: e, config: t = {} } = this.props, n = Z(e, t);
+    return /* @__PURE__ */ h.createElement(
+      _,
+      {
+        ref: this.domContainer,
+        definition: n
+      }
+    );
+  }
+  /**
+   * Initializes the editor by creating a proper watchdog and initializing it with the editor's configuration.
+   */
+  async _initializeEditor() {
+    const e = f(), {
+      editor: t,
+      disableWatchdog: n,
+      watchdogConfig: r
+    } = this.props, a = this._getMergedConfig(!0);
+    if (n)
+      return {
+        instance: await this._createEditor(a),
+        watchdog: null
+      };
+    const o = $(this.context) ? new Y(this.context.watchdog) : new t.EditorWatchdog(t, r);
+    return o.on("error", (s, { error: l, causesRestart: c }) => {
+      var u;
+      ((u = this.props.onError) != null ? u : console.error)(l, { phase: "runtime", willEditorRestart: c });
+    }), e.elementConfigAttachment ? (o.setCreator(async (s) => this._watchdogCreateEditor(o, s)), await o.create(a)) : (o.setCreator(async (s, l) => this._watchdogCreateEditor(o, l)), await o.create(this.domContainer.current, a)), {
+      watchdog: o,
+      instance: o.editor
+    };
+  }
+  /**
+   * Creates editor in watchdog context.
+   *
+   * @param watchdog Watchdog adapter.
+   * @param config Editor configuration.
+   * @returns Editor instance.
+   */
+  async _watchdogCreateEditor(e, t) {
+    const { editorSemaphore: n } = this, { onAfterDestroy: r, onReady: a } = this.props, o = !!(n != null && n.value);
+    o && r && r(n.value.instance);
+    const s = await this._createEditor(t);
+    return o && n && (n.unsafeSetValue({
+      instance: s,
+      watchdog: e
+    }), setTimeout(() => {
+      a == null || a(e.editor);
+    })), s;
+  }
+  /**
+   * Creates an editor from the element and configuration.
+   *
+   * @param config CKEditor 5 editor configuration.
+   * @returns Editor instance.
+   */
+  async _createEditor(e) {
+    const { editor: t } = this.props, n = f(), r = this._getMergedConfig(!1, e), a = await /* istanbul ignore next -- @preserve */
+    (n.elementConfigAttachment ? t.create(r) : t.create(this.domContainer.current, r));
+    this.props.disabled && a.enableReadOnlyMode(m);
+    const o = a.model.document, s = a.editing.view.document;
+    return o.on("change:data", (l) => {
+      var c, u;
+      (u = (c = this.props).onChange) == null || u.call(c, l, a);
+    }), s.on("focus", (l) => {
+      var c, u;
+      (u = (c = this.props).onFocus) == null || u.call(c, l, a);
+    }), s.on("blur", (l) => {
+      var c, u;
+      (u = (c = this.props).onBlur) == null || u.call(c, l, a);
+    }), a;
+  }
+  /**
+   * It gets an extended configuration containing the entries required for the integration configuration.
+   *
+   * @param resetData Assigns `data` prop value to the configuration if true.
+   * @param config The configuration of the editor.
+   * @returns Shallow copy of config.
+   */
+  _getMergedConfig(e, t) {
+    const { contextItemMetadata: n, editor: r } = this.props, a = f();
+    let o = { ...t ?? this.props.config };
+    return n && (o = U(n, o)), o = G(o), a.elementConfigAttachment && (o = S(r, this.domContainer.current, o)), e && (o = T(o, this.props.data || "")), o;
+  }
+  /**
+   * Destroys the editor by destroying the watchdog.
+   */
+  async _destroyEditor(e) {
+    const { watchdog: t, instance: n } = e;
+    return new Promise((r, a) => {
+      setTimeout(async () => {
+        try {
+          if (t)
+            return await t.destroy(), r();
+          if (n)
+            return await n.destroy(), r();
+          r();
+        } catch (o) {
+          console.error(o), a(o);
+        }
+      });
+    });
+  }
+}
+d(X, "contextType", F);
+function Z(i, e) {
+  var t, n, r, a, o;
+  return !i.editorName || i.editorName === "ClassicEditor" ? "div" : (o = (a = (n = (t = e.roots) == null ? void 0 : t.main) == null ? void 0 : n.element) != null ? a : (r = e.root) == null ? void 0 : r.element) != null ? o : "div";
+}
+function j(i, e, t) {
+  return !(i.data === e.data || t.data.get() === e.data);
+}
+function ee() {
+  switch (L("42.0.0")) {
+    case null:
+      console.warn('Cannot find the "CKEDITOR_VERSION" in the "window" scope.');
+      break;
+    case -1:
+      console.warn("The <CKEditor> component requires using CKEditor 5 in version 42+ or nightly build.");
+      break;
+  }
+}
+function I(...i) {
+  return (e) => {
+    i.forEach((t) => {
+      typeof t == "function" ? t(e) : t != null && (t.current = e);
+    });
+  };
+}
+const te = p(({ editor: i }, e) => {
+  const t = y(null);
+  return v(() => {
+    const n = t.current;
+    if (!i || !n)
+      return;
+    const r = i.ui.view.toolbar.element;
+    return n.appendChild(r), () => {
+      n.contains(r) && n.removeChild(r);
+    };
+  }, [i]), /* @__PURE__ */ h.createElement("div", { ref: I(t, e) });
+});
+te.displayName = "EditorToolbarWrapper";
+const ne = "$rootEditableOptions", ie = C(p(({ id: i, editor: e, rootName: t }, n) => {
+  var r;
+  const a = y(null), o = g(() => e == null ? void 0 : e.model.document.getRoot(t), [e, t]), s = g(() => o ? { ...o.getAttribute(ne) } : null, [o]);
+  if (v(() => {
+    if (!e || !o || !s)
+      return;
+    e.ui.getEditableElement(t) && e.detachEditable(o);
+    const c = e.ui.view.createEditable(t, a.current, s.label);
+    return c.isInlineRoot = !e.model.schema.checkChild(o, "$block"), e.ui.addEditable(c, s.placeholder), e.editing.view.forceRender(), () => {
+      e && e.state !== "destroyed" && e.model.document.getRoot(t) === o && e.detachEditable(o);
+    };
+  }, [e, o, s]), !s)
+    return null;
+  let l = M((r = s == null ? void 0 : s.element) != null ? r : {
+    name: "div"
+  });
+  return l = {
+    ...l,
+    attributes: {
+      ...l.attributes,
+      id: i
+    }
+  }, /* @__PURE__ */ h.createElement(
+    _,
+    {
+      key: e == null ? void 0 : e.id,
+      ref: I(n, a),
+      definition: l
+    }
+  );
+}));
+ie.displayName = "EditorEditable";
+export {
+  X as CKEditor,
+  F as ContextWatchdogContext
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@ckeditor/ckeditor5-react/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/@ckeditor/ckeditor5-react/dist/index.js"],"sourcesContent":["var __defProp = Object.defineProperty;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\nimport React, { useRef, useEffect, useCallback, useState, useContext, memo, forwardRef, useMemo } from \"react\";\nimport { createDefer, once, uid, createIntegrationUsageDataPlugin, isCKEditorFreeLicense, appendExtraPluginsToEditorConfig, mapObjectKeys, kebabToCamelCase, getInstalledCKBaseFeatures, assignElementToEditorConfig, assignInitialDataToEditorConfig, compareInstalledCKBaseVersion, shallowCompareArrays, overwriteObject, overwriteArray, assignInitialDataToMultirootEditorConfig, assignAttributesPropToMultiRootEditorConfig, uniq, isSSR, loadCKEditorCloud } from \"@ckeditor/ckeditor5-integrations-common\";\nimport { loadCKEditorCloud as loadCKEditorCloud2 } from \"@ckeditor/ckeditor5-integrations-common\";\nconst _LifeCycleElementSemaphore = class _LifeCycleElementSemaphore {\n  constructor(element, lifecycle) {\n    /**\n     * This should define async methods for initializing and destroying the editor.\n     * Essentially, it's an async version of basic React lifecycle methods like `componentDidMount`, `componentWillUnmount`.\n     *\n     * \t* Result of {@link LifeCycleAsyncOperators#mount} method is passed to {@link LifeCycleAsyncOperators#unmount} as an argument.\n     */\n    __publicField(this, \"_lifecycle\");\n    /**\n     * This is the element instance that the editor uses for mounting. This element should contain the `ckeditorInstance` member\n     * once the editor has been successfully mounted to it. The semaphore ensures that a new instance of the editor, which will\n     * be assigned to this element by the {@link #_lifecycle:mount} method, will always be initialized after the successful\n     * destruction of the underlying `ckeditorInstance` that was previously mounted on this element.\n     */\n    __publicField(this, \"_element\");\n    /**\n     * This is the lock mechanism utilized by the {@link #lock} and {@link #release} methods.\n     *\n     * \t* If the editor is not yet mounted and is awaiting mounting (for instance, when another editor is\n     * \t  occupying the element), then it is null.\n     *\n     * \t* When the editor is mounted on the element, this variable holds an unresolved promise that will be\n     * \t  resolved after the editor is destroyed.\n     *\n     * \t* Once the editor is destroyed (and it was previously mounted), the promise is resolved.\n     */\n    __publicField(this, \"_releaseLock\", null);\n    /**\n     * This is the result of the {@link #_lifecycle:mount} function. This value should be reset to `null`\n     * once the semaphore is released. It is utilized to store certain data that must be removed following\n     * the destruction of the editor. This data may include the editor's instance, the assigned watchdog,\n     * or handles for additional window listeners.\n     */\n    __publicField(this, \"_value\", null);\n    /**\n     * This is a list of callbacks that are triggered if the semaphore {@link #_lifecycle:mount} method executes successfully.\n     * It is utilized in scenarios where we need to assign certain properties to an editor that is currently in the process of mounting.\n     * An instance of such usage could be two-way binding. We aim to prevent the loss of all `setData` calls if the editor has not\n     * yet been mounted, therefore these calls will be executed immediately following the completion of the mounting process.\n     */\n    __publicField(this, \"_afterMountCallbacks\", []);\n    /**\n     * This represents the actual mounting state of the semaphore. It is primarily used by the {@link #release} method to\n     * determine whether the initialization of the editor should be skipped or, if the editor is already initialized, the editor\n     * should be destroyed.\n     *\n     * \t* If `destroyedBeforeInitialization` is true, then the {@link #release} method was invoked before the editor began to mount.\n     * \t  This often occurs in strict mode when we assign a promise to the {@link LifeCycleEditorElementSemaphore#_semaphores} map\n     * \t  and the assigned `mount` callback has not yet been called. In this scenario, it is safe to skip the initialization of the editor\n     * \t  and simply release the semaphore.\n     *\n     *\t* If `mountingInProgress` is a Promise, then the {@link #release} method was invoked after the initialization of the editor and\n     \t  the editor must be destroyed before the semaphore is released.\n    */\n    __publicField(this, \"_state\", {\n      destroyedBeforeInitialization: false,\n      mountingInProgress: null\n    });\n    /**\n     * Inverse of {@link #_lock} method that tries to destroy attached editor.\n     *\n     * \t* If editor is being already attached to element (or is in attaching process) then after fully initialization of editor\n     * \t  destroy is performed and semaphore is released. The {@link #_lifecycle} unmount method is called.\n     *\n     * \t* If editor is being destroyed before initialization then it does nothing but sets `destroyedBeforeInitialization` flag that\n     * \t  will be later checked by {@link #_lock} method in initialization. The {@link #_lifecycle} unmount method is not called.\n     *\n     * *Important note:*\n     *\n     * It’s really important to keep this method *sync*. If we make this method *async*, it won’t work well because\n     * it will cause problems when we’re trying to set up the {@link LifeCycleEditorElementSemaphore#_semaphores} map entries.\n     */\n    __publicField(this, \"release\", once(() => {\n      const { _releaseLock, _state, _element, _lifecycle } = this;\n      if (_state.mountingInProgress) {\n        _state.mountingInProgress.then(() => _lifecycle.unmount({\n          element: _element,\n          // Mount result might be overridden by watchdog during restart so use instance variable.\n          mountResult: this.value\n        })).catch((error) => {\n          console.error(\"CKEditor unmounting error:\", error);\n        }).then(_releaseLock.resolve).then(() => {\n          this._value = null;\n        });\n      } else {\n        _state.destroyedBeforeInitialization = true;\n        _releaseLock.resolve();\n      }\n    }));\n    this._element = element;\n    this._lifecycle = lifecycle;\n    this._lock();\n  }\n  /**\n   * Getter for {@link #_value}.\n   */\n  get value() {\n    return this._value;\n  }\n  /**\n   * Resets the semaphore to its initial state.\n   */\n  discard() {\n    this._value = null;\n    this._releaseLock = null;\n    this._afterMountCallbacks = [];\n    this._state = {\n      destroyedBeforeInitialization: false,\n      mountingInProgress: null\n    };\n  }\n  /**\n   * Occasionally, the Watchdog restarts the editor instance, resulting in a new instance being assigned to the semaphore.\n   * In terms of race conditions, it's generally safer to simply override the semaphore value rather than recreating it\n   * with a different one.\n   */\n  unsafeSetValue(value) {\n    this._value = value;\n    this._afterMountCallbacks.forEach((callback) => {\n      if (this._lifecycle.isValueValid && !this._lifecycle.isValueValid(value)) {\n        return;\n      }\n      callback(value);\n    });\n    this._afterMountCallbacks = [];\n  }\n  /**\n   * This registers a callback that will be triggered after the editor has been successfully mounted.\n   *\n   * \t* If the editor is already mounted, the callback will be executed immediately.\n   *\t* If the editor is in the process of mounting, the callback will be executed upon successful mounting.\n  * \t* If the editor is never mounted, the passed callback will not be executed.\n  * \t* If an exception is thrown within the callback, it will be re-thrown in the semaphore.\n  * \t* If the value is not valid (determined by isValueValid), the callback will not be executed.\n  */\n  runAfterMount(callback) {\n    const { _value, _afterMountCallbacks } = this;\n    if (_value) {\n      if (this._lifecycle.isValueValid && !this._lifecycle.isValueValid(_value)) {\n        return;\n      }\n      callback(_value);\n    } else {\n      _afterMountCallbacks.push(callback);\n    }\n  }\n  /**\n   * This method is used to inform other components that the {@link #_element} will be used by the editor,\n   * which is initialized by the {@link #_lifecycle} methods.\n   *\n   * \t* If an editor is already present on the provided element, the initialization of the current one\n   * \t  will be postponed until the previous one is destroyed.\n   *\n   * \t* If the element is empty and does not have an editor attached to it, the currently locked editor will\n   * \t  be mounted immediately.\n   *\n   * After the successful initialization of the editor and the assignment of the {@link #_value} member,\n   * the `onReady` lifecycle method is called.\n   *\n   * *Important note:*\n   *\n   * It’s really important to keep this method *sync*. If we make this method *async*, it won’t work well because\n   * it will cause problems when we’re trying to set up the {@link LifeCycleEditorElementSemaphore#_semaphores} map entries.\n   */\n  _lock() {\n    const { _semaphores } = _LifeCycleElementSemaphore;\n    const { _state, _element, _lifecycle } = this;\n    const prevElementSemaphore = _semaphores.get(_element) || Promise.resolve(null);\n    const releaseLock = createDefer();\n    this._releaseLock = releaseLock;\n    const newElementSemaphore = prevElementSemaphore.then(() => {\n      if (_state.destroyedBeforeInitialization) {\n        return Promise.resolve(void 0);\n      }\n      _state.mountingInProgress = _lifecycle.mount().then((mountResult) => {\n        if (mountResult) {\n          this.unsafeSetValue(mountResult);\n        }\n        return mountResult;\n      });\n      return _state.mountingInProgress;\n    }).then(async (mountResult) => {\n      if (mountResult && _lifecycle.afterMount) {\n        await _lifecycle.afterMount({\n          element: _element,\n          mountResult\n        });\n      }\n    }).then(() => releaseLock.promise).catch((error) => {\n      console.error(\"CKEditor mounting error:\", error);\n    }).then(() => {\n      if (_semaphores.get(_element) === newElementSemaphore) {\n        _semaphores.delete(_element);\n      }\n    });\n    _semaphores.set(_element, newElementSemaphore);\n  }\n};\n/**\n * This is a map of elements associated with promises. It informs the semaphore that the underlying HTML element, used as a key,\n * is currently in use by another editor. Each element is assigned a promise, which allows for the easy chaining of new\n * editor instances on an element that is already in use by another instance. The process works as follows:\n *\n * \t1. If an element is being used by an editor, then the initialization of a new editor\n * \t   instance is chained using the `.then()` method of the Promise.\n *\n * \t2. If the editor associated with the underlying element is destroyed, then `Promise.resolve()` is called\n * \t   and the previously assigned `.then()` editor callback is executed.\n *\n *  @see {@link #lock} for more detailed information on the implementation.\n */\n__publicField(_LifeCycleElementSemaphore, \"_semaphores\", /* @__PURE__ */ new Map());\nlet LifeCycleElementSemaphore = _LifeCycleElementSemaphore;\nconst ReactContextMetadataKey = \"$__CKEditorReactContextMetadata\";\nfunction withCKEditorReactContextMetadata(metadata, config) {\n  return {\n    ...config,\n    [ReactContextMetadataKey]: metadata\n  };\n}\nfunction tryExtractCKEditorReactContextMetadata(object) {\n  return object.get(ReactContextMetadataKey);\n}\nconst useIsMountedRef = () => {\n  const mountedRef = useRef(false);\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n  return mountedRef;\n};\nconst useRefSafeCallback = (fn) => {\n  const callbackRef = useRef();\n  callbackRef.current = fn;\n  return useCallback(\n    (...args) => callbackRef.current(...args),\n    []\n  );\n};\nconst useInitializedCKEditorsMap = ({\n  currentContextWatchdog,\n  onChangeInitializedEditors\n}) => {\n  const onChangeInitializedEditorsSafe = useRefSafeCallback(onChangeInitializedEditors || (() => {\n  }));\n  useEffect(() => {\n    var _a;\n    if (currentContextWatchdog.status !== \"initialized\") {\n      return;\n    }\n    const { watchdog } = currentContextWatchdog;\n    const editors = (_a = watchdog == null ? void 0 : watchdog.context) == null ? void 0 : _a.editors;\n    if (!editors) {\n      return;\n    }\n    const getInitializedContextEditors = () => [...editors].reduce(\n      (map, editor) => {\n        var _a2;\n        if (editor.state !== \"ready\") {\n          return map;\n        }\n        const metadata = tryExtractCKEditorReactContextMetadata(editor.config);\n        const nameOrId = (_a2 = metadata == null ? void 0 : metadata.name) != null ? _a2 : editor.id;\n        map[nameOrId] = {\n          instance: editor,\n          metadata\n        };\n        return map;\n      },\n      /* @__PURE__ */ Object.create({})\n      // Prevent the prototype pollution.\n    );\n    const onEditorStatusChange = () => {\n      onChangeInitializedEditorsSafe(\n        getInitializedContextEditors(),\n        watchdog\n      );\n    };\n    const trackEditorLifecycle = (editor) => {\n      editor.once(\"ready\", onEditorStatusChange, { priority: \"lowest\" });\n      editor.once(\"destroy\", onEditorStatusChange, { priority: \"lowest\" });\n    };\n    const onAddEditorToCollection = (_, editor) => {\n      trackEditorLifecycle(editor);\n    };\n    editors.forEach(trackEditorLifecycle);\n    editors.on(\"add\", onAddEditorToCollection);\n    if (Array.from(editors).some((editor) => editor.state === \"ready\")) {\n      onEditorStatusChange();\n    }\n    return () => {\n      editors.off(\"add\", onAddEditorToCollection);\n    };\n  }, [currentContextWatchdog]);\n};\nconst ContextWatchdogContext = React.createContext(null);\nconst useCKEditorWatchdogContext = () => useContext(ContextWatchdogContext);\nconst CKEditorContext = (props) => {\n  const {\n    id,\n    context,\n    watchdogConfig,\n    children,\n    config,\n    onReady,\n    contextWatchdog: ContextWatchdogConstructor,\n    isLayoutReady = true,\n    onChangeInitializedEditors,\n    onError = (error, details) => console.error(error, details)\n  } = props;\n  const isMountedRef = useIsMountedRef();\n  const prevWatchdogInitializationIDRef = useRef(null);\n  const [currentContextWatchdog, setCurrentContextWatchdog] = useState({\n    status: \"initializing\"\n  });\n  useEffect(() => {\n    if (isLayoutReady) {\n      initializeContextWatchdog();\n    } else {\n      setCurrentContextWatchdog({\n        status: \"initializing\"\n      });\n    }\n  }, [id, isLayoutReady]);\n  useEffect(() => () => {\n    if (currentContextWatchdog.status === \"initialized\") {\n      currentContextWatchdog.watchdog.destroy();\n    }\n  }, [currentContextWatchdog]);\n  useInitializedCKEditorsMap({\n    currentContextWatchdog,\n    onChangeInitializedEditors\n  });\n  function regenerateInitializationID() {\n    prevWatchdogInitializationIDRef.current = uid();\n    return prevWatchdogInitializationIDRef.current;\n  }\n  function canUpdateState(initializationID) {\n    return prevWatchdogInitializationIDRef.current === initializationID && isMountedRef.current;\n  }\n  function initializeContextWatchdog() {\n    const watchdogInitializationID = regenerateInitializationID();\n    const contextWatchdog = new ContextWatchdogConstructor(context, watchdogConfig);\n    contextWatchdog.on(\"error\", (_, errorEvent) => {\n      if (canUpdateState(watchdogInitializationID)) {\n        onError(errorEvent.error, {\n          phase: \"runtime\",\n          willContextRestart: errorEvent.causesRestart\n        });\n      }\n    });\n    contextWatchdog.on(\"stateChange\", () => {\n      if (onReady && contextWatchdog.state === \"ready\" && canUpdateState(watchdogInitializationID)) {\n        onReady(\n          contextWatchdog.context,\n          contextWatchdog\n        );\n      }\n    });\n    contextWatchdog.create(config).then(() => {\n      if (canUpdateState(watchdogInitializationID)) {\n        setCurrentContextWatchdog({\n          status: \"initialized\",\n          watchdog: contextWatchdog\n        });\n      } else {\n        contextWatchdog.destroy();\n      }\n    }).catch((error) => {\n      if (canUpdateState(watchdogInitializationID)) {\n        onError(error, {\n          phase: \"initialization\",\n          willContextRestart: false\n        });\n        setCurrentContextWatchdog({\n          status: \"error\",\n          error\n        });\n      }\n    });\n    return contextWatchdog;\n  }\n  return /* @__PURE__ */ React.createElement(ContextWatchdogContext.Provider, { value: currentContextWatchdog }, children);\n};\nconst isContextWatchdogValue = (obj) => !!obj && typeof obj === \"object\" && \"status\" in obj && [\"initializing\", \"initialized\", \"error\"].includes(obj.status);\nconst isContextWatchdogValueWithStatus = (status) => (obj) => isContextWatchdogValue(obj) && obj.status === status;\nconst isContextWatchdogInitializing = isContextWatchdogValueWithStatus(\"initializing\");\nconst isContextWatchdogReadyToUse = (obj) => isContextWatchdogValueWithStatus(\"initialized\")(obj) && obj.watchdog.state === \"ready\";\nconst ReactIntegrationUsageDataPlugin = createIntegrationUsageDataPlugin(\n  \"react\",\n  {\n    version: \"11.2.0\",\n    frameworkVersion: React.version\n  }\n);\nfunction appendAllIntegrationPluginsToConfig(editorConfig) {\n  if (isCKEditorFreeLicense(editorConfig.licenseKey)) {\n    return editorConfig;\n  }\n  return appendExtraPluginsToEditorConfig(editorConfig, [\n    /**\n     * This part of the code is not executed in open-source implementations using a GPL key.\n     * It only runs when a specific license key is provided. If you are uncertain whether\n     * this applies to your installation, please contact our support team.\n     */\n    ReactIntegrationUsageDataPlugin\n  ]);\n}\nclass EditorWatchdogAdapter {\n  /**\n   * @param contextWatchdog The context watchdog instance that will be wrapped into editor watchdog API.\n   */\n  constructor(contextWatchdog) {\n    /**\n     * The context watchdog instance that will be wrapped into editor watchdog API.\n     */\n    __publicField(this, \"_contextWatchdog\");\n    /**\n     * A unique id for the adapter to distinguish editor items when using the context watchdog API.\n     */\n    __publicField(this, \"_id\");\n    /**\n     * A watchdog's editor creator function.\n     */\n    __publicField(this, \"_creator\");\n    this._contextWatchdog = contextWatchdog;\n    this._id = uid();\n  }\n  /**\n   *  @param creator A watchdog's editor creator function.\n   */\n  setCreator(creator) {\n    this._creator = creator;\n  }\n  create(sourceElementOrDataOrConfig, config) {\n    let watchdogItemConfiguration = {\n      creator: this._creator,\n      id: this._id,\n      type: \"editor\"\n    };\n    if (config) {\n      watchdogItemConfiguration = {\n        ...watchdogItemConfiguration,\n        sourceElementOrData: sourceElementOrDataOrConfig,\n        config\n      };\n    } else {\n      watchdogItemConfiguration = {\n        ...watchdogItemConfiguration,\n        config: sourceElementOrDataOrConfig\n      };\n    }\n    return this._contextWatchdog.add(watchdogItemConfiguration);\n  }\n  /**\n   * Creates a listener that is attached to context watchdog's item and run when the context watchdog fires.\n   * Currently works only for the `error` event.\n   */\n  on(_, callback) {\n    this._contextWatchdog.on(\"itemError\", (_2, { itemId, error }) => {\n      if (itemId === this._id) {\n        callback(null, { error, causesRestart: void 0 });\n      }\n    });\n  }\n  destroy() {\n    if (this._contextWatchdog.state === \"ready\") {\n      return this._contextWatchdog.remove(this._id);\n    }\n    return Promise.resolve();\n  }\n  /**\n   * An editor instance.\n   */\n  get editor() {\n    return this._contextWatchdog.getItem(this._id);\n  }\n}\nfunction normalizeClassList(classes) {\n  if (typeof classes === \"string\") {\n    return classes;\n  }\n  return (classes != null ? classes : []).join(\" \");\n}\nfunction normalizeStylesMap(styles) {\n  return mapObjectKeys(styles, (key) => {\n    if (key.startsWith(\"--\")) {\n      return key;\n    }\n    return kebabToCamelCase(key);\n  });\n}\nfunction normalizeEditorElementDefinition(definition) {\n  if (typeof HTMLElement !== \"undefined\" && definition instanceof HTMLElement) {\n    throw new Error(\n      \"An HTMLElement cannot be used as an editor element definition. Please pass a string, a React component, or an object definition.\"\n    );\n  }\n  if (typeof definition !== \"object\" || definition === null) {\n    return {\n      name: definition\n    };\n  }\n  return definition;\n}\nconst EditorElement = memo(forwardRef(({ definition }, ref) => {\n  const { name: Tag, classes, styles, attributes } = normalizeEditorElementDefinition(definition != null ? definition : {\n    name: \"div\"\n  });\n  return /* @__PURE__ */ React.createElement(\n    Tag,\n    {\n      ref,\n      ...attributes,\n      style: normalizeStylesMap(styles != null ? styles : {}),\n      className: normalizeClassList(classes)\n    }\n  );\n}));\nEditorElement.displayName = \"EditorElement\";\nconst REACT_INTEGRATION_READ_ONLY_LOCK_ID$1 = \"Lock from React integration (@ckeditor/ckeditor5-react)\";\nclass CKEditor extends React.Component {\n  constructor(props) {\n    super(props);\n    /**\n     * After mounting the editor, the variable will contain a reference to the created editor.\n     * @see: https://ckeditor.com/docs/ckeditor5/latest/api/module_core_editor_editor-Editor.html\n     */\n    __publicField(this, \"domContainer\", React.createRef());\n    /**\n     * Unlocks element in editor semaphore after destroy editor instance.\n     */\n    __publicField(this, \"editorSemaphore\", null);\n    assertMinimumSupportedVersion();\n  }\n  get _semaphoreValue() {\n    const { editorSemaphore } = this;\n    return editorSemaphore ? editorSemaphore.value : null;\n  }\n  /**\n   * An watchdog instance.\n   */\n  get watchdog() {\n    const { _semaphoreValue } = this;\n    return _semaphoreValue ? _semaphoreValue.watchdog : null;\n  }\n  /**\n   * An editor instance.\n   */\n  get editor() {\n    const { _semaphoreValue } = this;\n    return _semaphoreValue ? _semaphoreValue.instance : null;\n  }\n  /**\n   * The CKEditor component should not be updated by React itself.\n   * However, if the component identifier changes, the whole structure should be created once again.\n   */\n  shouldComponentUpdate(nextProps) {\n    const { props, editorSemaphore } = this;\n    if (nextProps.id !== props.id) {\n      return true;\n    }\n    if (nextProps.disableWatchdog !== props.disableWatchdog) {\n      return true;\n    }\n    if (editorSemaphore) {\n      editorSemaphore.runAfterMount(({ instance }) => {\n        if (shouldUpdateEditorData(props, nextProps, instance)) {\n          instance.data.set(nextProps.data);\n        }\n      });\n      if (\"disabled\" in nextProps) {\n        editorSemaphore.runAfterMount(({ instance }) => {\n          if (nextProps.disabled) {\n            instance.enableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID$1);\n          } else {\n            instance.disableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID$1);\n          }\n        });\n      }\n    }\n    return false;\n  }\n  /**\n   * Initialize the editor when the component is mounted.\n   */\n  componentDidMount() {\n    if (!isContextWatchdogInitializing(this.context)) {\n      this._initLifeCycleSemaphore();\n    }\n  }\n  /**\n   * Re-render the entire component once again. The old editor will be destroyed and the new one will be created.\n   */\n  componentDidUpdate() {\n    if (!isContextWatchdogInitializing(this.context)) {\n      this._initLifeCycleSemaphore();\n    }\n  }\n  /**\n   * Destroy the editor before unmounting the component.\n   */\n  componentWillUnmount() {\n    this._unlockLifeCycleSemaphore();\n  }\n  /**\n   * Async destroy attached editor and unlock element semaphore.\n   */\n  _unlockLifeCycleSemaphore() {\n    if (this.editorSemaphore) {\n      this.editorSemaphore.release();\n      this.editorSemaphore = null;\n    }\n  }\n  /**\n   * Unlocks previous editor semaphore and creates new one..\n   */\n  _initLifeCycleSemaphore() {\n    this._unlockLifeCycleSemaphore();\n    this.editorSemaphore = new LifeCycleElementSemaphore(this.domContainer.current, {\n      isValueValid: (value) => value && !!value.instance,\n      mount: async () => {\n        var _a, _b;\n        try {\n          return await this._initializeEditor();\n        } catch (error) {\n          (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a, error, { phase: \"initialization\", willEditorRestart: false });\n          throw error;\n        }\n      },\n      afterMount: ({ mountResult }) => {\n        const { onReady } = this.props;\n        if (onReady && this.domContainer.current !== null) {\n          onReady(mountResult.instance);\n        }\n      },\n      unmount: async ({ element, mountResult }) => {\n        const { onAfterDestroy } = this.props;\n        try {\n          await this._destroyEditor(mountResult);\n          element.innerHTML = \"\";\n        } finally {\n          if (onAfterDestroy) {\n            onAfterDestroy(mountResult.instance);\n          }\n        }\n      }\n    });\n  }\n  /**\n   * Render a <div> element which will be replaced by CKEditor.\n   */\n  render() {\n    const { editor: Editor, config = {} } = this.props;\n    const definition = getEditorElementDefinition(Editor, config);\n    return /* @__PURE__ */ React.createElement(\n      EditorElement,\n      {\n        ref: this.domContainer,\n        definition\n      }\n    );\n  }\n  /**\n   * Initializes the editor by creating a proper watchdog and initializing it with the editor's configuration.\n   */\n  async _initializeEditor() {\n    const supports = getInstalledCKBaseFeatures();\n    const {\n      editor: Editor,\n      disableWatchdog,\n      watchdogConfig\n    } = this.props;\n    const mergedConfig = this._getMergedConfig(true);\n    if (disableWatchdog) {\n      const instance = await this._createEditor(mergedConfig);\n      return {\n        instance,\n        watchdog: null\n      };\n    }\n    const watchdog = (() => {\n      if (isContextWatchdogReadyToUse(this.context)) {\n        return new EditorWatchdogAdapter(this.context.watchdog);\n      }\n      return new Editor.EditorWatchdog(Editor, watchdogConfig);\n    })();\n    watchdog.on(\"error\", (_, { error, causesRestart }) => {\n      var _a;\n      const onError = (_a = this.props.onError) != null ? _a : console.error;\n      onError(error, { phase: \"runtime\", willEditorRestart: causesRestart });\n    });\n    if (supports.elementConfigAttachment) {\n      watchdog.setCreator(async (config) => this._watchdogCreateEditor(watchdog, config));\n      await watchdog.create(mergedConfig);\n    } else {\n      watchdog.setCreator(async (_, config) => this._watchdogCreateEditor(watchdog, config));\n      await watchdog.create(this.domContainer.current, mergedConfig);\n    }\n    return {\n      watchdog,\n      instance: watchdog.editor\n    };\n  }\n  /**\n   * Creates editor in watchdog context.\n   *\n   * @param watchdog Watchdog adapter.\n   * @param config Editor configuration.\n   * @returns Editor instance.\n   */\n  async _watchdogCreateEditor(watchdog, config) {\n    const { editorSemaphore } = this;\n    const { onAfterDestroy, onReady } = this.props;\n    const nonFirstCreate = !!(editorSemaphore == null ? void 0 : editorSemaphore.value);\n    if (nonFirstCreate && onAfterDestroy) {\n      onAfterDestroy(editorSemaphore.value.instance);\n    }\n    const instance = await this._createEditor(config);\n    if (nonFirstCreate && editorSemaphore) {\n      editorSemaphore.unsafeSetValue({\n        instance,\n        watchdog\n      });\n      setTimeout(() => {\n        onReady == null ? void 0 : onReady(watchdog.editor);\n      });\n    }\n    return instance;\n  }\n  /**\n   * Creates an editor from the element and configuration.\n   *\n   * @param config CKEditor 5 editor configuration.\n   * @returns Editor instance.\n   */\n  async _createEditor(config) {\n    const { editor: Editor } = this.props;\n    const supports = getInstalledCKBaseFeatures();\n    const mergedConfig = this._getMergedConfig(false, config);\n    const editor = await /* istanbul ignore next -- @preserve */\n    (supports.elementConfigAttachment ? Editor.create(mergedConfig) : Editor.create(this.domContainer.current, mergedConfig));\n    if (this.props.disabled) {\n      editor.enableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID$1);\n    }\n    const modelDocument = editor.model.document;\n    const viewDocument = editor.editing.view.document;\n    modelDocument.on(\"change:data\", (event) => {\n      var _a, _b;\n      (_b = (_a = this.props).onChange) == null ? void 0 : _b.call(_a, event, editor);\n    });\n    viewDocument.on(\"focus\", (event) => {\n      var _a, _b;\n      (_b = (_a = this.props).onFocus) == null ? void 0 : _b.call(_a, event, editor);\n    });\n    viewDocument.on(\"blur\", (event) => {\n      var _a, _b;\n      (_b = (_a = this.props).onBlur) == null ? void 0 : _b.call(_a, event, editor);\n    });\n    return editor;\n  }\n  /**\n   * It gets an extended configuration containing the entries required for the integration configuration.\n   *\n   * @param resetData Assigns `data` prop value to the configuration if true.\n   * @param config The configuration of the editor.\n   * @returns Shallow copy of config.\n   */\n  _getMergedConfig(resetData, config) {\n    const { contextItemMetadata, editor: Editor } = this.props;\n    const supports = getInstalledCKBaseFeatures();\n    let mappedConfig = { ...config != null ? config : this.props.config };\n    if (contextItemMetadata) {\n      mappedConfig = withCKEditorReactContextMetadata(contextItemMetadata, mappedConfig);\n    }\n    mappedConfig = appendAllIntegrationPluginsToConfig(mappedConfig);\n    if (supports.elementConfigAttachment) {\n      mappedConfig = assignElementToEditorConfig(Editor, this.domContainer.current, mappedConfig);\n    }\n    if (resetData) {\n      mappedConfig = assignInitialDataToEditorConfig(mappedConfig, this.props.data || \"\");\n    }\n    return mappedConfig;\n  }\n  /**\n   * Destroys the editor by destroying the watchdog.\n   */\n  async _destroyEditor(initializeResult) {\n    const { watchdog, instance } = initializeResult;\n    return new Promise((resolve, reject) => {\n      setTimeout(async () => {\n        try {\n          if (watchdog) {\n            await watchdog.destroy();\n            return resolve();\n          }\n          if (instance) {\n            await instance.destroy();\n            return resolve();\n          }\n          resolve();\n        } catch (e) {\n          console.error(e);\n          reject(e);\n        }\n      });\n    });\n  }\n}\n__publicField(CKEditor, \"contextType\", ContextWatchdogContext);\nfunction getEditorElementDefinition(editor, config) {\n  var _a, _b, _c, _d, _e;\n  if (!editor.editorName || editor.editorName === \"ClassicEditor\") {\n    return \"div\";\n  }\n  return (_e = (_d = (_b = (_a = config.roots) == null ? void 0 : _a.main) == null ? void 0 : _b.element) != null ? _d : (_c = config.root) == null ? void 0 : _c.element) != null ? _e : \"div\";\n}\nfunction shouldUpdateEditorData(prevProps, nextProps, editor) {\n  if (prevProps.data === nextProps.data) {\n    return false;\n  }\n  if (editor.data.get() === nextProps.data) {\n    return false;\n  }\n  return true;\n}\nfunction assertMinimumSupportedVersion() {\n  switch (compareInstalledCKBaseVersion(\"42.0.0\")) {\n    case null:\n      console.warn('Cannot find the \"CKEDITOR_VERSION\" in the \"window\" scope.');\n      break;\n    case -1:\n      console.warn(\"The <CKEditor> component requires using CKEditor 5 in version 42+ or nightly build.\");\n      break;\n  }\n}\nconst useLifeCycleSemaphoreSyncRef = () => {\n  const semaphoreRef = useRef(null);\n  const [revision, setRevision] = useState(() => Date.now());\n  const pendingWaiters = useRef([]);\n  const refresh = () => {\n    setRevision(Date.now());\n  };\n  const release = (rerender = true) => {\n    var _a;\n    (_a = semaphoreRef.current) == null ? void 0 : _a.release();\n    semaphoreRef.current = null;\n    const waiters = pendingWaiters.current.splice(0);\n    waiters.forEach(({ reject }) => {\n      reject(new Error(\"CKEditor: editor was destroyed before initialization completed.\"));\n    });\n    if (rerender) {\n      setRevision(Date.now());\n    }\n  };\n  const unsafeSetValue = (value) => {\n    var _a;\n    (_a = semaphoreRef.current) == null ? void 0 : _a.unsafeSetValue(value);\n    const waiters = pendingWaiters.current.splice(0);\n    waiters.forEach(({ resolve }) => resolve(value));\n    refresh();\n  };\n  const runAfterMount = (callback) => {\n    var _a;\n    (_a = semaphoreRef.current) == null ? void 0 : _a.runAfterMount(callback);\n  };\n  const replace = (newSemaphore) => {\n    var _a;\n    (_a = semaphoreRef.current) == null ? void 0 : _a.release();\n    semaphoreRef.current = newSemaphore();\n    semaphoreRef.current.runAfterMount((value) => {\n      const waiters = pendingWaiters.current.splice(0);\n      waiters.forEach(({ resolve }) => resolve(value));\n    });\n    refresh();\n    runAfterMount(refresh);\n  };\n  const waitFor = () => {\n    var _a;\n    const currentValue = (_a = semaphoreRef.current) == null ? void 0 : _a.value;\n    if (currentValue) {\n      return Promise.resolve(currentValue);\n    }\n    return new Promise((resolve, reject) => {\n      pendingWaiters.current.push({ resolve, reject });\n    });\n  };\n  const createAttributeRef = (key) => ({\n    get current() {\n      if (!semaphoreRef.current || !semaphoreRef.current.value) {\n        return null;\n      }\n      return semaphoreRef.current.value[key];\n    }\n  });\n  return {\n    get current() {\n      return semaphoreRef.current;\n    },\n    revision,\n    createAttributeRef,\n    unsafeSetValue,\n    release,\n    replace,\n    runAfterMount,\n    waitFor\n  };\n};\nconst useInstantEffect = (fn, deps) => {\n  const [prevDeps, setDeps] = useState(null);\n  if (!shallowCompareArrays(prevDeps, deps)) {\n    fn();\n    setDeps([...deps]);\n  }\n};\nconst useInstantEditorEffect = (semaphore, fn, deps) => {\n  useInstantEffect(() => {\n    if (semaphore) {\n      semaphore.runAfterMount(fn);\n    }\n  }, [semaphore, ...deps]);\n};\nfunction mergeRefs(...refs) {\n  return (value) => {\n    refs.forEach((ref) => {\n      if (typeof ref === \"function\") {\n        ref(value);\n      } else if (ref != null) {\n        ref.current = value;\n      }\n    });\n  };\n}\nconst EditorToolbarWrapper = forwardRef(({ editor }, ref) => {\n  const toolbarRef = useRef(null);\n  useEffect(() => {\n    const toolbarContainer = toolbarRef.current;\n    if (!editor || !toolbarContainer) {\n      return void 0;\n    }\n    const element = editor.ui.view.toolbar.element;\n    toolbarContainer.appendChild(element);\n    return () => {\n      if (toolbarContainer.contains(element)) {\n        toolbarContainer.removeChild(element);\n      }\n    };\n  }, [editor]);\n  return /* @__PURE__ */ React.createElement(\"div\", { ref: mergeRefs(toolbarRef, ref) });\n});\nEditorToolbarWrapper.displayName = \"EditorToolbarWrapper\";\nconst ROOT_EDITABLE_OPTIONS_ATTRIBUTE = \"$rootEditableOptions\";\nconst EditorEditable = memo(forwardRef(({ id, editor, rootName }, ref) => {\n  var _a;\n  const innerRef = useRef(null);\n  const root = useMemo(() => editor == null ? void 0 : editor.model.document.getRoot(rootName), [editor, rootName]);\n  const rootEditableOptions = useMemo(() => {\n    if (!root) {\n      return null;\n    }\n    const options = root.getAttribute(ROOT_EDITABLE_OPTIONS_ATTRIBUTE);\n    return { ...options };\n  }, [root]);\n  useEffect(() => {\n    if (!editor || !root || !rootEditableOptions) {\n      return;\n    }\n    if (editor.ui.getEditableElement(rootName)) {\n      editor.detachEditable(root);\n    }\n    const editable = editor.ui.view.createEditable(rootName, innerRef.current, rootEditableOptions.label);\n    editable.isInlineRoot = !editor.model.schema.checkChild(root, \"$block\");\n    editor.ui.addEditable(editable, rootEditableOptions.placeholder);\n    editor.editing.view.forceRender();\n    return () => {\n      if (editor && editor.state !== \"destroyed\") {\n        const currentRoot = editor.model.document.getRoot(rootName);\n        if (currentRoot === root) {\n          editor.detachEditable(root);\n        }\n      }\n    };\n  }, [editor, root, rootEditableOptions]);\n  if (!rootEditableOptions) {\n    return null;\n  }\n  let normalizedDefinition = normalizeEditorElementDefinition((_a = rootEditableOptions == null ? void 0 : rootEditableOptions.element) != null ? _a : {\n    name: \"div\"\n  });\n  normalizedDefinition = {\n    ...normalizedDefinition,\n    attributes: {\n      ...normalizedDefinition.attributes,\n      id\n    }\n  };\n  return /* @__PURE__ */ React.createElement(\n    EditorElement,\n    {\n      key: editor == null ? void 0 : editor.id,\n      ref: mergeRefs(ref, innerRef),\n      definition: normalizedDefinition\n    }\n  );\n}));\nEditorEditable.displayName = \"EditorEditable\";\nconst REACT_INTEGRATION_READ_ONLY_LOCK_ID = \"Lock from React integration (@ckeditor/ckeditor5-react)\";\nconst useMultiRootEditor = (props) => {\n  const semaphoreElementRef = useRef(props.semaphoreElement || null);\n  const semaphore = useLifeCycleSemaphoreSyncRef();\n  const editorRefs = {\n    watchdog: semaphore.createAttributeRef(\"watchdog\"),\n    instance: semaphore.createAttributeRef(\"instance\")\n  };\n  const context = useContext(ContextWatchdogContext);\n  const [roots, setRoots] = useState(() => Object.keys(props.data));\n  const [data, setData] = useState({ ...props.data });\n  const [attributes, setAttributes] = useState({ ...props.rootsAttributes });\n  const shouldUpdateEditor = useRef(true);\n  const forceAssignFakeEditableElements = () => {\n    const editor = editorRefs.instance.current;\n    if (!editor) {\n      return;\n    }\n    const initializeEditableWithFakeElement = (editable) => {\n      if (editable.name && !editor.editing.view.getDomRoot(editable.name)) {\n        editor.editing.view.attachDomRoot(document.createElement(\"div\"), editable.name);\n      }\n    };\n    Object.values(editor.ui.view.editables).forEach(initializeEditableWithFakeElement);\n  };\n  useEffect(() => {\n    const semaphoreElement = semaphoreElementRef.current;\n    if (context && !isContextWatchdogReadyToUse(context)) {\n      return;\n    }\n    if (!semaphoreElement || props.isLayoutReady === false) {\n      return;\n    }\n    semaphore.replace(() => new LifeCycleElementSemaphore(semaphoreElement, {\n      mount: _initializeEditor,\n      afterMount: ({ mountResult }) => {\n        const { onReady } = props;\n        if (onReady && semaphoreElementRef.current !== null) {\n          onReady(mountResult.instance);\n        }\n      },\n      unmount: async ({ element, mountResult }) => {\n        const { onAfterDestroy } = props;\n        try {\n          await _destroyEditor(mountResult);\n          element.innerHTML = \"\";\n        } finally {\n          if (onAfterDestroy) {\n            onAfterDestroy(mountResult.instance);\n          }\n        }\n      }\n    }));\n    return () => {\n      forceAssignFakeEditableElements();\n      semaphore.release(false);\n    };\n  }, [props.id, props.isLayoutReady, context == null ? void 0 : context.status]);\n  const _getConfig = useRefSafeCallback(() => {\n    let mappedConfig = assignAttributesPropToMultiRootEditorConfig(attributes, props.config || {});\n    mappedConfig = appendAllIntegrationPluginsToConfig(mappedConfig);\n    return mappedConfig;\n  });\n  const onChangeData = useRefSafeCallback((editor, event) => {\n    const modelDocument = editor.model.document;\n    if (!props.disableTwoWayDataBinding) {\n      const newData = {};\n      const newAttributes = {};\n      modelDocument.differ.getChanges().forEach((change) => {\n        let root;\n        if (change.type == \"insert\" || change.type == \"remove\") {\n          root = change.position.root;\n        } else {\n          root = change.range.root;\n        }\n        if (!root.isAttached()) {\n          return;\n        }\n        const { rootName } = root;\n        newData[rootName] = editor.getData({ rootName });\n      });\n      modelDocument.differ.getChangedRoots().forEach((changedRoot) => {\n        if (changedRoot.state) {\n          if (newData[changedRoot.name] !== void 0) {\n            delete newData[changedRoot.name];\n          }\n          return;\n        }\n        const rootName = changedRoot.name;\n        newAttributes[rootName] = editor.getRootAttributes(rootName);\n      });\n      if (Object.keys(newData).length) {\n        setData((previousData) => ({ ...previousData, ...newData }));\n      }\n      if (Object.keys(newAttributes).length) {\n        setAttributes((previousAttributes) => ({ ...previousAttributes, ...newAttributes }));\n      }\n    }\n    if (props.onChange) {\n      props.onChange(event, editor);\n    }\n  });\n  const onAddRoot = useRefSafeCallback((editor, _evt, root) => {\n    const rootName = root.rootName;\n    if (!props.disableTwoWayDataBinding) {\n      setData(\n        (previousData) => ({ ...previousData, [rootName]: editor.getData({ rootName }) })\n      );\n      setAttributes(\n        (previousAttributes) => ({ ...previousAttributes, [rootName]: editor.getRootAttributes(rootName) })\n      );\n    }\n    setRoots((prevRoots) => uniq([...prevRoots, root.rootName]));\n  });\n  const onDetachRoot = useRefSafeCallback((_editor, _evt, root) => {\n    const rootName = root.rootName;\n    if (!props.disableTwoWayDataBinding) {\n      setData((previousData) => {\n        const { [rootName]: _, ...newData } = previousData;\n        return { ...newData };\n      });\n      setAttributes((previousAttributes) => {\n        const { [rootName]: _, ...newAttributes } = previousAttributes;\n        return { ...newAttributes };\n      });\n    }\n    setRoots((prevRoots) => prevRoots.filter((root2) => root2 !== rootName));\n  });\n  const _createEditor = useRefSafeCallback(async (initialData, config) => {\n    const Editor = props.editor;\n    overwriteObject({ ...props.rootsAttributes }, attributes);\n    overwriteObject({ ...props.data }, data);\n    overwriteArray(Object.keys(props.data), roots);\n    const { initialData: mergedInitialData, ...mergedConfig } = assignInitialDataToMultirootEditorConfig(initialData, config);\n    const supports = getInstalledCKBaseFeatures();\n    const editor = await /* istanbul ignore next -- @preserve */\n    (supports.elementConfigAttachment ? Editor.create({ ...mergedConfig, initialData: mergedInitialData }) : Editor.create(mergedInitialData, mergedConfig));\n    const editorData = editor.getFullData();\n    overwriteObject({ ...editorData }, data);\n    overwriteObject({ ...editor.getRootsAttributes() }, attributes);\n    overwriteArray(Object.keys(editorData), roots);\n    if (props.disabled) {\n      editor.enableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID);\n    }\n    const modelDocument = editor.model.document;\n    const viewDocument = editor.editing.view.document;\n    modelDocument.on(\"change:data\", (evt) => onChangeData(editor, evt));\n    editor.on(\"addRoot\", (evt, root) => onAddRoot(editor, evt, root));\n    editor.on(\"detachRoot\", (evt, root) => onDetachRoot(editor, evt, root));\n    viewDocument.on(\"focus\", (event) => {\n      if (props.onFocus) {\n        props.onFocus(event, editor);\n      }\n    });\n    viewDocument.on(\"blur\", (event) => {\n      if (props.onBlur) {\n        props.onBlur(event, editor);\n      }\n    });\n    return editor;\n  });\n  const _destroyEditor = (initializeResult) => {\n    const { watchdog, instance } = initializeResult;\n    return new Promise((resolve, reject) => {\n      setTimeout(async () => {\n        try {\n          if (watchdog) {\n            await watchdog.destroy();\n            return resolve();\n          }\n          if (instance) {\n            await instance.destroy();\n            return resolve();\n          }\n          resolve();\n        } catch (e) {\n          console.error(e);\n          reject(e);\n        }\n      });\n    });\n  };\n  const _initializeEditor = async () => {\n    const supports = getInstalledCKBaseFeatures();\n    if (props.disableWatchdog) {\n      const instance = await _createEditor(props.data, _getConfig());\n      return {\n        instance,\n        watchdog: null\n      };\n    }\n    const watchdog = (() => {\n      if (isContextWatchdogReadyToUse(context)) {\n        return new EditorWatchdogAdapter(context.watchdog);\n      }\n      return new props.editor.EditorWatchdog(props.editor, props.watchdogConfig);\n    })();\n    const totalRestartsRef = {\n      current: 0\n    };\n    const watchdogEditorCreator = async (config) => {\n      const { onAfterDestroy } = props;\n      if (totalRestartsRef.current > 0 && onAfterDestroy && editorRefs.instance.current) {\n        onAfterDestroy(editorRefs.instance.current);\n      }\n      const instance = await _createEditor(data, config);\n      if (totalRestartsRef.current > 0) {\n        semaphore.unsafeSetValue({\n          instance,\n          watchdog\n        });\n        setTimeout(() => {\n          if (props.onReady) {\n            props.onReady(watchdog.editor);\n          }\n        });\n      }\n      totalRestartsRef.current++;\n      return instance;\n    };\n    watchdog.on(\"error\", (_, { error, causesRestart }) => {\n      const onError = props.onError || console.error;\n      onError(error, { phase: \"runtime\", willEditorRestart: causesRestart });\n    });\n    try {\n      if (supports.elementConfigAttachment) {\n        watchdog.setCreator(watchdogEditorCreator);\n        await watchdog.create(_getConfig());\n      } else {\n        watchdog.setCreator(async (_, config) => watchdogEditorCreator(config));\n        await watchdog.create(data, _getConfig());\n      }\n    } catch (error) {\n      const onError = props.onError || console.error;\n      onError(error, { phase: \"initialization\", willEditorRestart: false });\n      throw error;\n    }\n    return {\n      watchdog,\n      instance: watchdog.editor\n    };\n  };\n  const _getStateDiff = (previousState, newState) => {\n    const previousStateKeys = Object.keys(previousState);\n    const newStateKeys = Object.keys(newState);\n    return {\n      addedKeys: newStateKeys.filter((key) => !previousStateKeys.includes(key)),\n      removedKeys: previousStateKeys.filter((key) => !newStateKeys.includes(key))\n    };\n  };\n  const _externalSetData = useCallback(\n    (newData) => {\n      semaphore.runAfterMount(() => {\n        shouldUpdateEditor.current = true;\n        setData(newData);\n      });\n    },\n    [setData]\n  );\n  const _externalSetAttributes = useCallback(\n    (newAttributes) => {\n      semaphore.runAfterMount(() => {\n        shouldUpdateEditor.current = true;\n        setAttributes(newAttributes);\n      });\n    },\n    [setAttributes]\n  );\n  useInstantEditorEffect(semaphore.current, ({ instance }) => {\n    if (props.disabled) {\n      instance.enableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID);\n    } else {\n      instance.disableReadOnlyMode(REACT_INTEGRATION_READ_ONLY_LOCK_ID);\n    }\n  }, [props.disabled]);\n  useInstantEditorEffect(semaphore.current, ({ instance }) => {\n    if (shouldUpdateEditor.current) {\n      shouldUpdateEditor.current = false;\n      const dataKeys = Object.keys(data);\n      const attributesKeys = Object.keys(attributes);\n      if (!dataKeys.every((key) => attributesKeys.includes(key))) {\n        console.error(\"`data` and `attributes` objects must have the same keys (roots).\");\n        throw new Error(\"`data` and `attributes` objects must have the same keys (roots).\");\n      }\n      const editorData = instance.getFullData();\n      const editorAttributes = instance.getRootsAttributes();\n      const {\n        addedKeys: newRoots,\n        removedKeys: removedRoots\n      } = _getStateDiff(\n        editorData,\n        data || /* istanbul ignore next -- @preserve: It should never happen, data should be always filled. */\n        {}\n      );\n      const modifiedRoots = dataKeys.filter(\n        (rootName) => editorData[rootName] !== void 0 && JSON.stringify(editorData[rootName]) !== JSON.stringify(data[rootName])\n      );\n      const rootsWithChangedAttributes = attributesKeys.filter((rootName) => JSON.stringify(editorAttributes[rootName]) !== JSON.stringify(attributes[rootName]));\n      const _handleNewRoots = (roots2) => {\n        const supports = getInstalledCKBaseFeatures();\n        for (const rootName of roots2) {\n          const rootAttributes = (attributes == null ? void 0 : attributes[rootName]) || {};\n          const rootData = data[rootName] || \"\";\n          for (const key of Object.keys(rootAttributes)) {\n            instance.registerRootAttribute(key);\n          }\n          let options = {\n            isUndoable: true\n          };\n          if (supports.rootsConfigEntry) {\n            options = {\n              ...options,\n              initialData: rootData,\n              modelAttributes: rootAttributes\n            };\n          } else {\n            options = {\n              ...options,\n              data: rootData,\n              attributes: rootAttributes\n            };\n          }\n          instance.addRoot(rootName, options);\n        }\n      };\n      const _handleRemovedRoots = (roots2) => {\n        roots2.forEach((rootName) => {\n          instance.detachRoot(rootName, true);\n        });\n      };\n      const _updateEditorData = (roots2) => {\n        const dataToUpdate = roots2.reduce(\n          (result, rootName) => ({ ...result, [rootName]: data[rootName] }),\n          /* @__PURE__ */ Object.create(null)\n        );\n        instance.data.set(dataToUpdate, { suppressErrorInCollaboration: true });\n      };\n      const _updateEditorAttributes = (writer, roots2) => {\n        for (const rootName of roots2) {\n          for (const key of Object.keys(attributes[rootName])) {\n            instance.registerRootAttribute(key);\n          }\n          const root = instance.model.document.getRoot(rootName);\n          for (const key of Object.keys(instance.getRootAttributes(rootName))) {\n            writer.removeAttribute(key, root);\n          }\n          writer.setAttributes(attributes[rootName], root);\n        }\n      };\n      setTimeout(() => {\n        instance.model.change((writer) => {\n          _handleNewRoots(newRoots);\n          _handleRemovedRoots(removedRoots);\n          if (modifiedRoots.length) {\n            _updateEditorData(modifiedRoots);\n          }\n          if (rootsWithChangedAttributes.length) {\n            _updateEditorAttributes(writer, rootsWithChangedAttributes);\n          }\n        });\n      });\n    }\n  }, [data, attributes]);\n  const toolbarElement = /* @__PURE__ */ React.createElement(\n    EditorToolbarWrapper,\n    {\n      ref: semaphoreElementRef,\n      editor: editorRefs.instance.current\n    }\n  );\n  const editableElements = roots.map(\n    (rootName) => /* @__PURE__ */ React.createElement(\n      EditorEditable,\n      {\n        key: rootName,\n        id: rootName,\n        rootName,\n        editor: editorRefs.instance.current\n      }\n    )\n  );\n  const removeRoot = async (rootName) => {\n    const { instance } = await semaphore.waitFor();\n    instance.model.change(() => {\n      instance.detachRoot(rootName, true);\n    });\n  };\n  const addRoot = async ({\n    name,\n    data: data2,\n    attributes: attributes2 = {},\n    editableOptions,\n    ...rootOptions\n  }) => {\n    const { instance } = await semaphore.waitFor();\n    const supports = getInstalledCKBaseFeatures();\n    instance.model.change(() => {\n      const mappedAttributes = {\n        ...attributes2,\n        ...!supports.rootsConfigEntry && editableOptions && {\n          [ROOT_EDITABLE_OPTIONS_ATTRIBUTE]: editableOptions\n        }\n      };\n      for (const key of Object.keys(mappedAttributes)) {\n        instance.registerRootAttribute(key);\n      }\n      let options = {\n        isUndoable: true,\n        ...rootOptions\n      };\n      if (supports.rootsConfigEntry) {\n        options = {\n          ...options,\n          ...editableOptions,\n          initialData: data2 || \"\",\n          modelAttributes: mappedAttributes\n        };\n      } else {\n        options = {\n          ...options,\n          data: data2 || \"\",\n          attributes: mappedAttributes\n        };\n      }\n      instance.addRoot(name, options);\n    });\n  };\n  return {\n    editor: editorRefs.instance.current,\n    editableElements,\n    toolbarElement,\n    data,\n    setData: _externalSetData,\n    attributes,\n    setAttributes: _externalSetAttributes,\n    removeRoot,\n    addRoot\n  };\n};\nconst useIsUnmountedRef = () => {\n  const mountedRef = useRef(false);\n  useEffect(() => {\n    mountedRef.current = false;\n    return () => {\n      mountedRef.current = true;\n    };\n  }, []);\n  return mountedRef;\n};\nconst useAsyncCallback = (callback) => {\n  const [asyncState, setAsyncState] = useState({\n    status: \"idle\"\n  });\n  const unmountedRef = useIsUnmountedRef();\n  const prevExecutionUIDRef = useRef(null);\n  const asyncExecutor = useRefSafeCallback(async (...args) => {\n    if (unmountedRef.current || isSSR()) {\n      return null;\n    }\n    const currentExecutionUUID = uid();\n    prevExecutionUIDRef.current = currentExecutionUUID;\n    try {\n      if (asyncState.status !== \"loading\") {\n        setAsyncState({\n          status: \"loading\"\n        });\n      }\n      const result = await callback(...args);\n      if (!unmountedRef.current && prevExecutionUIDRef.current === currentExecutionUUID) {\n        setAsyncState({\n          status: \"success\",\n          data: result\n        });\n      }\n      return result;\n    } catch (error) {\n      console.error(error);\n      if (!unmountedRef.current && prevExecutionUIDRef.current === currentExecutionUUID) {\n        setAsyncState({\n          status: \"error\",\n          error\n        });\n      }\n    }\n    return null;\n  });\n  return [asyncExecutor, asyncState];\n};\nconst useAsyncValue = (callback, deps) => {\n  const [asyncCallback, asyncState] = useAsyncCallback(callback);\n  useInstantEffect(asyncCallback, deps);\n  if (asyncState.status === \"idle\") {\n    return {\n      status: \"loading\"\n    };\n  }\n  return asyncState;\n};\nfunction useCKEditorCloud(config) {\n  const serializedConfigKey = JSON.stringify(config);\n  const result = useAsyncValue(\n    async () => loadCKEditorCloud(config),\n    [serializedConfigKey]\n  );\n  if (result.status === \"success\") {\n    return {\n      ...result.data,\n      status: \"success\"\n    };\n  }\n  return result;\n}\nconst withCKEditorCloud = (config) => (WrappedComponent) => {\n  const ComponentWithCKEditorCloud = (props) => {\n    var _a, _b;\n    const ckeditorCloudResult = useCKEditorCloud(config.cloud);\n    switch (ckeditorCloudResult.status) {\n      // An error occurred while fetching the cloud information.\n      case \"error\":\n        if (!config.renderError) {\n          return \"Unable to load CKEditor Cloud data!\";\n        }\n        return config.renderError(ckeditorCloudResult.error);\n      // The cloud information has been fetched successfully.\n      case \"success\":\n        return /* @__PURE__ */ React.createElement(WrappedComponent, { ...props, cloud: ckeditorCloudResult });\n      // The cloud information is being fetched.\n      default:\n        return (_b = (_a = config.renderLoader) == null ? void 0 : _a.call(config)) != null ? _b : null;\n    }\n  };\n  ComponentWithCKEditorCloud.displayName = \"ComponentWithCKEditorCloud\";\n  return ComponentWithCKEditorCloud;\n};\nexport {\n  CKEditor,\n  CKEditorContext,\n  ContextWatchdogContext,\n  loadCKEditorCloud2 as loadCKEditorCloud,\n  useCKEditorCloud,\n  useCKEditorWatchdogContext,\n  useMultiRootEditor,\n  withCKEditorCloud\n};\n//# sourceMappingURL=index.js.map\n"],"names":["__defProp","__defNormalProp","obj","key","value","__publicField","_LifeCycleElementSemaphore","element","lifecycle","once","_releaseLock","_state","_element","_lifecycle","error","callback","_value","_afterMountCallbacks","_semaphores","prevElementSemaphore","releaseLock","createDefer","newElementSemaphore","mountResult","LifeCycleElementSemaphore","ReactContextMetadataKey","withCKEditorReactContextMetadata","metadata","config","ContextWatchdogContext","React","isContextWatchdogValue","isContextWatchdogValueWithStatus","status","isContextWatchdogInitializing","isContextWatchdogReadyToUse","ReactIntegrationUsageDataPlugin","createIntegrationUsageDataPlugin","appendAllIntegrationPluginsToConfig","editorConfig","isCKEditorFreeLicense","appendExtraPluginsToEditorConfig","EditorWatchdogAdapter","contextWatchdog","uid","creator","sourceElementOrDataOrConfig","watchdogItemConfiguration","_","_2","itemId","normalizeClassList","classes","normalizeStylesMap","styles","mapObjectKeys","kebabToCamelCase","normalizeEditorElementDefinition","definition","EditorElement","memo","forwardRef","ref","Tag","attributes","REACT_INTEGRATION_READ_ONLY_LOCK_ID$1","CKEditor","props","assertMinimumSupportedVersion","editorSemaphore","_semaphoreValue","nextProps","instance","shouldUpdateEditorData","_a","_b","onReady","onAfterDestroy","Editor","getEditorElementDefinition","supports","getInstalledCKBaseFeatures","disableWatchdog","watchdogConfig","mergedConfig","watchdog","causesRestart","nonFirstCreate","editor","modelDocument","viewDocument","event","resetData","contextItemMetadata","mappedConfig","assignElementToEditorConfig","assignInitialDataToEditorConfig","initializeResult","resolve","reject","e","_c","_d","_e","prevProps","compareInstalledCKBaseVersion","mergeRefs","refs","EditorToolbarWrapper","toolbarRef","useRef","useEffect","toolbarContainer","ROOT_EDITABLE_OPTIONS_ATTRIBUTE","EditorEditable","id","rootName","innerRef","root","useMemo","rootEditableOptions","editable","normalizedDefinition"],"mappings":"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","x_google_ignoreList":[0]}