ckeditor5-blazor 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1400 @@
+class b extends Error {
+  constructor(t) {
+    super(t), this.name = "CKEditor5BlazorError";
+  }
+}
+class j {
+  /**
+   * Map of registered items.
+   */
+  items = /* @__PURE__ */ new Map();
+  /**
+   * Map of initialization errors for items that failed to register.
+   */
+  initializationErrors = /* @__PURE__ */ new Map();
+  /**
+   * Map of pending callbacks waiting for items to be registered or fail.
+   */
+  pendingCallbacks = /* @__PURE__ */ new Map();
+  /**
+   * Set of watchers that observe changes to the registry.
+   */
+  watchers = /* @__PURE__ */ new Set();
+  /**
+   * Executes a function on an item.
+   * If the item is not yet registered, it will wait for it to be registered.
+   *
+   * @param id The ID of the item.
+   * @param onSuccess The function to execute.
+   * @param onError Optional error callback.
+   * @returns A promise that resolves with the result of the function.
+   */
+  execute(t, e, i) {
+    const a = this.items.get(t), n = this.initializationErrors.get(t);
+    return n ? (i?.(n), Promise.reject(n)) : a ? Promise.resolve(e(a)) : new Promise((o, c) => {
+      const u = this.getPendingCallbacks(t);
+      u.success.push(async (s) => {
+        o(await e(s));
+      }), i ? u.error.push(i) : u.error.push(c);
+    });
+  }
+  /**
+   * Registers an item.
+   *
+   * @param id The ID of the item.
+   * @param item The item instance.
+   */
+  register(t, e) {
+    if (this.items.has(t))
+      throw new Error(`Item with ID "${t}" is already registered.`);
+    this.resetErrors(t), this.items.set(t, e);
+    const i = this.pendingCallbacks.get(t);
+    i && (i.success.forEach((a) => a(e)), this.pendingCallbacks.delete(t)), this.registerAsDefault(t, e), this.notifyWatchers();
+  }
+  /**
+   * Registers an error for an item.
+   *
+   * @param id The ID of the item.
+   * @param error The error to register.
+   */
+  error(t, e) {
+    this.items.delete(t), this.initializationErrors.set(t, e);
+    const i = this.pendingCallbacks.get(t);
+    i && (i.error.forEach((a) => a(e)), this.pendingCallbacks.delete(t)), this.initializationErrors.size === 1 && !this.items.size && this.error(null, e), this.notifyWatchers();
+  }
+  /**
+   * Resets errors for an item.
+   *
+   * @param id The ID of the item.
+   */
+  resetErrors(t) {
+    const { initializationErrors: e } = this;
+    e.has(null) && e.get(null) === e.get(t) && e.delete(null), e.delete(t);
+  }
+  /**
+   * Un-registers an item.
+   *
+   * @param id The ID of the item.
+   */
+  unregister(t) {
+    if (!this.items.has(t))
+      throw new Error(`Item with ID "${t}" is not registered.`);
+    t && this.items.get(null) === this.items.get(t) && this.unregister(null), this.items.delete(t), this.pendingCallbacks.delete(t), this.notifyWatchers();
+  }
+  /**
+   * Gets all registered items.
+   *
+   * @returns An array of all registered items.
+   */
+  getItems() {
+    return Array.from(this.items.values());
+  }
+  /**
+   * Checks if an item with the given ID is registered.
+   *
+   * @param id The ID of the item.
+   * @returns `true` if the item is registered, `false` otherwise.
+   */
+  hasItem(t) {
+    return this.items.has(t);
+  }
+  /**
+   * Gets a promise that resolves with the item instance for the given ID.
+   * If the item is not registered yet, it will wait for it to be registered.
+   *
+   * @param id The ID of the item.
+   * @param timeout Optional timeout in milliseconds.
+   * @returns A promise that resolves with the item instance.
+   */
+  waitFor(t, e) {
+    return new Promise((i, a) => {
+      let n = !1, o = null;
+      this.execute(
+        t,
+        (c) => {
+          n || (o !== null && clearTimeout(o), i(c));
+        },
+        (c) => {
+          n || (o !== null && clearTimeout(o), a(c));
+        }
+      ), e && (o = setTimeout(() => {
+        n = !0, a(new Error(`Timeout waiting for item with ID "${t}" to be registered.`));
+      }, e));
+    });
+  }
+  /**
+   * Destroys all registered items and clears the registry.
+   * This will call the `destroy` method on each item.
+   */
+  async destroyAll() {
+    const t = Array.from(new Set(this.items.values())).map((e) => e.destroy());
+    this.items.clear(), this.pendingCallbacks.clear(), await Promise.all(t), this.notifyWatchers();
+  }
+  /**
+   * Registers a watcher that will be called whenever the registry changes.
+   *
+   * @param watcher The watcher function to register.
+   * @returns A function to unregister the watcher.
+   */
+  watch(t) {
+    return this.watchers.add(t), t(
+      new Map(this.items),
+      new Map(this.initializationErrors)
+    ), this.unwatch.bind(this, t);
+  }
+  /**
+   * Un-registers a watcher.
+   *
+   * @param watcher The watcher function to unregister.
+   */
+  unwatch(t) {
+    this.watchers.delete(t);
+  }
+  /**
+   * Resets the registry by clearing all items, errors, and pending callbacks.
+   */
+  reset() {
+    this.items.clear(), this.initializationErrors.clear(), this.pendingCallbacks.clear(), this.notifyWatchers();
+  }
+  /**
+   * Notifies all watchers about changes to the registry.
+   */
+  notifyWatchers() {
+    this.watchers.forEach(
+      (t) => t(
+        new Map(this.items),
+        new Map(this.initializationErrors)
+      )
+    );
+  }
+  /**
+   * Gets or creates pending callbacks for a specific ID.
+   *
+   * @param id The ID of the item.
+   * @returns The pending callbacks structure.
+   */
+  getPendingCallbacks(t) {
+    let e = this.pendingCallbacks.get(t);
+    return e || (e = { success: [], error: [] }, this.pendingCallbacks.set(t, e)), e;
+  }
+  /**
+   * Registers an item as the default (null ID) item if it's the first one.
+   *
+   * @param id The ID of the item being registered.
+   * @param item The item instance.
+   */
+  registerAsDefault(t, e) {
+    this.items.size === 1 && t !== null && this.register(null, e);
+  }
+}
+function z(r, t) {
+  let e = null;
+  return (...i) => {
+    e && clearTimeout(e), e = setTimeout(() => {
+      t(...i);
+    }, r);
+  };
+}
+function et(r, t) {
+  const e = Object.entries(r).filter(([i, a]) => t(a, i));
+  return Object.fromEntries(e);
+}
+function B(r) {
+  return Object.keys(r).length === 0 && r.constructor === Object;
+}
+function V(r, t) {
+  const e = Object.entries(r).map(([i, a]) => [i, t(a, i)]);
+  return Object.fromEntries(e);
+}
+function rt(r, t) {
+  if (r === t)
+    return !0;
+  const e = Object.keys(r), i = Object.keys(t);
+  if (e.length !== i.length)
+    return !1;
+  for (const a of e)
+    if (r[a] !== t[a] || !Object.prototype.hasOwnProperty.call(t, a))
+      return !1;
+  return !0;
+}
+function it() {
+  return Math.random().toString(36).substring(2);
+}
+function at(r, {
+  timeOutAfter: t = 500,
+  retryAfter: e = 100
+} = {}) {
+  return new Promise((i, a) => {
+    const n = Date.now();
+    let o = null;
+    const c = setTimeout(() => {
+      a(o ?? new Error("Timeout"));
+    }, t), u = async () => {
+      try {
+        const s = await r();
+        clearTimeout(c), i(s);
+      } catch (s) {
+        o = s, Date.now() - n > t ? a(s) : setTimeout(u, e);
+      }
+    };
+    u();
+  });
+}
+function I() {
+  return new Promise((r) => {
+    switch (document.readyState) {
+      case "loading":
+        document.addEventListener("DOMContentLoaded", () => r(), { once: !0 });
+        break;
+      case "interactive":
+      case "complete":
+        setTimeout(r, 0);
+        break;
+      default:
+        console.warn("Unexpected document.readyState:", document.readyState), setTimeout(r, 0);
+    }
+  });
+}
+function M(r) {
+  if (r.hasAttribute("data-cke-interactive"))
+    return { promise: Promise.resolve(), disconnect: () => {
+    } };
+  let t;
+  return {
+    promise: new Promise((i) => {
+      t = new MutationObserver((a) => {
+        for (const n of a)
+          if (n.type === "attributes" && n.attributeName === "data-cke-interactive" && r.hasAttribute("data-cke-interactive")) {
+            t.disconnect(), i();
+            break;
+          }
+      }), t.observe(r, { attributes: !0 });
+    }),
+    disconnect: () => t?.disconnect()
+  };
+}
+function D(r) {
+  r.setAttribute("data-cke-interactive", "true");
+}
+const x = /* @__PURE__ */ Symbol.for("context-editor-watchdog");
+async function nt({ element: r, context: t, creator: e, config: i }) {
+  const a = it();
+  await t.add({
+    creator: (u, s) => e.create(u, s),
+    id: a,
+    sourceElementOrData: r,
+    type: "editor",
+    config: i
+  });
+  const n = t.getItem(a), o = {
+    state: "available",
+    editorContextId: a,
+    context: t
+  };
+  n[x] = o;
+  const c = t.destroy.bind(t);
+  return t.destroy = async () => (o.state = "unavailable", c()), {
+    ...o,
+    editor: n
+  };
+}
+function ot(r) {
+  return x in r ? r[x] : null;
+}
+function H(r) {
+  return Array.from(r.model.document.getRoots()).reduce((t, e) => (e.rootName === "$graveyard" || (t[e.rootName] = r.getData({ rootName: e.rootName })), t), /* @__PURE__ */ Object.create({}));
+}
+function A(r) {
+  return ["inline", "classic", "balloon", "decoupled"].includes(r);
+}
+async function L(r) {
+  const t = await import("ckeditor5"), i = {
+    inline: t.InlineEditor,
+    balloon: t.BalloonEditor,
+    classic: t.ClassicEditor,
+    decoupled: t.DecoupledEditor,
+    multiroot: t.MultiRootEditor
+  }[r];
+  if (!i)
+    throw new b(`Unsupported editor type: ${r}`);
+  return i;
+}
+class $ {
+  static the = new $();
+  /**
+   * Map of registered custom plugins.
+   */
+  plugins = /* @__PURE__ */ new Map();
+  /**
+   * Private constructor to enforce singleton pattern.
+   */
+  constructor() {
+  }
+  /**
+   * Registers a custom plugin for the CKEditor.
+   *
+   * @param name The name of the plugin.
+   * @param reader The plugin reader function that returns the plugin constructor.
+   * @returns A function to unregister the plugin.
+   */
+  register(t, e) {
+    if (this.plugins.has(t))
+      throw new b(`Plugin with name "${t}" is already registered.`);
+    return this.plugins.set(t, e), this.unregister.bind(this, t);
+  }
+  /**
+   * Removes a custom plugin by its name.
+   *
+   * @param name The name of the plugin to unregister.
+   * @throws Will throw an error if the plugin is not registered.
+   */
+  unregister(t) {
+    if (!this.plugins.has(t))
+      throw new b(`Plugin with name "${t}" is not registered.`);
+    this.plugins.delete(t);
+  }
+  /**
+   * Removes all custom editor plugins.
+   * This is useful for cleanup in tests or when reloading plugins.
+   */
+  unregisterAll() {
+    this.plugins.clear();
+  }
+  /**
+   * Retrieves a custom plugin by its name.
+   *
+   * @param name The name of the plugin.
+   * @returns The plugin constructor or undefined if not found.
+   */
+  async get(t) {
+    return this.plugins.get(t)?.();
+  }
+  /**
+   * Checks if a plugin with the given name is registered.
+   *
+   * @param name The name of the plugin.
+   * @returns `true` if the plugin is registered, `false` otherwise.
+   */
+  has(t) {
+    return this.plugins.has(t);
+  }
+}
+async function J(r) {
+  const t = await import("ckeditor5");
+  let e = null;
+  const i = r.map(async (a) => {
+    const n = await $.the.get(a);
+    if (n)
+      return n;
+    const { [a]: o } = t;
+    if (o)
+      return o;
+    if (!e)
+      try {
+        e = await import("ckeditor5-premium-features");
+      } catch (u) {
+        throw console.error(`Failed to load premium package: ${u}`), new b(`Plugin "${a}" not found in base package and failed to load premium package.`);
+      }
+    const { [a]: c } = e || {};
+    if (c)
+      return c;
+    throw new b(`Plugin "${a}" not found in base or premium packages.`);
+  });
+  return {
+    loadedPlugins: await Promise.all(i),
+    hasPremium: !!e
+  };
+}
+async function U(r, t) {
+  const e = [r.ui, r.content];
+  return await Promise.all(
+    [
+      F("ckeditor5", e),
+      /* v8 ignore next -- @preserve */
+      t && F("ckeditor5-premium-features", e)
+    ].filter((a) => !!a)
+  ).then((a) => a.flat());
+}
+async function F(r, t) {
+  return await Promise.all(
+    t.filter((e) => e !== "en").map(async (e) => {
+      const i = await st(r, e);
+      return i?.default ?? i;
+    }).filter(Boolean)
+  );
+}
+async function st(r, t) {
+  try {
+    if (r === "ckeditor5")
+      switch (t) {
+        case "af":
+          return await import("ckeditor5/translations/af.js");
+        case "ar":
+          return await import("ckeditor5/translations/ar.js");
+        case "ast":
+          return await import("ckeditor5/translations/ast.js");
+        case "az":
+          return await import("ckeditor5/translations/az.js");
+        case "bg":
+          return await import("ckeditor5/translations/bg.js");
+        case "bn":
+          return await import("ckeditor5/translations/bn.js");
+        case "bs":
+          return await import("ckeditor5/translations/bs.js");
+        case "ca":
+          return await import("ckeditor5/translations/ca.js");
+        case "cs":
+          return await import("ckeditor5/translations/cs.js");
+        case "da":
+          return await import("ckeditor5/translations/da.js");
+        case "de":
+          return await import("ckeditor5/translations/de.js");
+        case "de-ch":
+          return await import("ckeditor5/translations/de-ch.js");
+        case "el":
+          return await import("ckeditor5/translations/el.js");
+        case "en":
+          return await import("ckeditor5/translations/en.js");
+        case "en-au":
+          return await import("ckeditor5/translations/en-au.js");
+        case "en-gb":
+          return await import("ckeditor5/translations/en-gb.js");
+        case "eo":
+          return await import("ckeditor5/translations/eo.js");
+        case "es":
+          return await import("ckeditor5/translations/es.js");
+        case "es-co":
+          return await import("ckeditor5/translations/es-co.js");
+        case "et":
+          return await import("ckeditor5/translations/et.js");
+        case "eu":
+          return await import("ckeditor5/translations/eu.js");
+        case "fa":
+          return await import("ckeditor5/translations/fa.js");
+        case "fi":
+          return await import("ckeditor5/translations/fi.js");
+        case "fr":
+          return await import("ckeditor5/translations/fr.js");
+        case "gl":
+          return await import("ckeditor5/translations/gl.js");
+        case "gu":
+          return await import("ckeditor5/translations/gu.js");
+        case "he":
+          return await import("ckeditor5/translations/he.js");
+        case "hi":
+          return await import("ckeditor5/translations/hi.js");
+        case "hr":
+          return await import("ckeditor5/translations/hr.js");
+        case "hu":
+          return await import("ckeditor5/translations/hu.js");
+        case "hy":
+          return await import("ckeditor5/translations/hy.js");
+        case "id":
+          return await import("ckeditor5/translations/id.js");
+        case "it":
+          return await import("ckeditor5/translations/it.js");
+        case "ja":
+          return await import("ckeditor5/translations/ja.js");
+        case "jv":
+          return await import("ckeditor5/translations/jv.js");
+        case "kk":
+          return await import("ckeditor5/translations/kk.js");
+        case "km":
+          return await import("ckeditor5/translations/km.js");
+        case "kn":
+          return await import("ckeditor5/translations/kn.js");
+        case "ko":
+          return await import("ckeditor5/translations/ko.js");
+        case "ku":
+          return await import("ckeditor5/translations/ku.js");
+        case "lt":
+          return await import("ckeditor5/translations/lt.js");
+        case "lv":
+          return await import("ckeditor5/translations/lv.js");
+        case "ms":
+          return await import("ckeditor5/translations/ms.js");
+        case "nb":
+          return await import("ckeditor5/translations/nb.js");
+        case "ne":
+          return await import("ckeditor5/translations/ne.js");
+        case "nl":
+          return await import("ckeditor5/translations/nl.js");
+        case "no":
+          return await import("ckeditor5/translations/no.js");
+        case "oc":
+          return await import("ckeditor5/translations/oc.js");
+        case "pl":
+          return await import("ckeditor5/translations/pl.js");
+        case "pt":
+          return await import("ckeditor5/translations/pt.js");
+        case "pt-br":
+          return await import("ckeditor5/translations/pt-br.js");
+        case "ro":
+          return await import("ckeditor5/translations/ro.js");
+        case "ru":
+          return await import("ckeditor5/translations/ru.js");
+        case "si":
+          return await import("ckeditor5/translations/si.js");
+        case "sk":
+          return await import("ckeditor5/translations/sk.js");
+        case "sl":
+          return await import("ckeditor5/translations/sl.js");
+        case "sq":
+          return await import("ckeditor5/translations/sq.js");
+        case "sr":
+          return await import("ckeditor5/translations/sr.js");
+        case "sr-latn":
+          return await import("ckeditor5/translations/sr-latn.js");
+        case "sv":
+          return await import("ckeditor5/translations/sv.js");
+        case "th":
+          return await import("ckeditor5/translations/th.js");
+        case "tk":
+          return await import("ckeditor5/translations/tk.js");
+        case "tr":
+          return await import("ckeditor5/translations/tr.js");
+        case "tt":
+          return await import("ckeditor5/translations/tt.js");
+        case "ug":
+          return await import("ckeditor5/translations/ug.js");
+        case "uk":
+          return await import("ckeditor5/translations/uk.js");
+        case "ur":
+          return await import("ckeditor5/translations/ur.js");
+        case "uz":
+          return await import("ckeditor5/translations/uz.js");
+        case "vi":
+          return await import("ckeditor5/translations/vi.js");
+        case "zh":
+          return await import("ckeditor5/translations/zh.js");
+        case "zh-cn":
+          return await import("ckeditor5/translations/zh-cn.js");
+        default:
+          return console.warn(`Language ${t} not found in ckeditor5 translations`), null;
+      }
+    else
+      switch (t) {
+        case "af":
+          return await import("ckeditor5-premium-features/translations/af.js");
+        case "ar":
+          return await import("ckeditor5-premium-features/translations/ar.js");
+        case "ast":
+          return await import("ckeditor5-premium-features/translations/ast.js");
+        case "az":
+          return await import("ckeditor5-premium-features/translations/az.js");
+        case "bg":
+          return await import("ckeditor5-premium-features/translations/bg.js");
+        case "bn":
+          return await import("ckeditor5-premium-features/translations/bn.js");
+        case "bs":
+          return await import("ckeditor5-premium-features/translations/bs.js");
+        case "ca":
+          return await import("ckeditor5-premium-features/translations/ca.js");
+        case "cs":
+          return await import("ckeditor5-premium-features/translations/cs.js");
+        case "da":
+          return await import("ckeditor5-premium-features/translations/da.js");
+        case "de":
+          return await import("ckeditor5-premium-features/translations/de.js");
+        case "de-ch":
+          return await import("ckeditor5-premium-features/translations/de-ch.js");
+        case "el":
+          return await import("ckeditor5-premium-features/translations/el.js");
+        case "en":
+          return await import("ckeditor5-premium-features/translations/en.js");
+        case "en-au":
+          return await import("ckeditor5-premium-features/translations/en-au.js");
+        case "en-gb":
+          return await import("ckeditor5-premium-features/translations/en-gb.js");
+        case "eo":
+          return await import("ckeditor5-premium-features/translations/eo.js");
+        case "es":
+          return await import("ckeditor5-premium-features/translations/es.js");
+        case "es-co":
+          return await import("ckeditor5-premium-features/translations/es-co.js");
+        case "et":
+          return await import("ckeditor5-premium-features/translations/et.js");
+        case "eu":
+          return await import("ckeditor5-premium-features/translations/eu.js");
+        case "fa":
+          return await import("ckeditor5-premium-features/translations/fa.js");
+        case "fi":
+          return await import("ckeditor5-premium-features/translations/fi.js");
+        case "fr":
+          return await import("ckeditor5-premium-features/translations/fr.js");
+        case "gl":
+          return await import("ckeditor5-premium-features/translations/gl.js");
+        case "gu":
+          return await import("ckeditor5-premium-features/translations/gu.js");
+        case "he":
+          return await import("ckeditor5-premium-features/translations/he.js");
+        case "hi":
+          return await import("ckeditor5-premium-features/translations/hi.js");
+        case "hr":
+          return await import("ckeditor5-premium-features/translations/hr.js");
+        case "hu":
+          return await import("ckeditor5-premium-features/translations/hu.js");
+        case "hy":
+          return await import("ckeditor5-premium-features/translations/hy.js");
+        case "id":
+          return await import("ckeditor5-premium-features/translations/id.js");
+        case "it":
+          return await import("ckeditor5-premium-features/translations/it.js");
+        case "ja":
+          return await import("ckeditor5-premium-features/translations/ja.js");
+        case "jv":
+          return await import("ckeditor5-premium-features/translations/jv.js");
+        case "kk":
+          return await import("ckeditor5-premium-features/translations/kk.js");
+        case "km":
+          return await import("ckeditor5-premium-features/translations/km.js");
+        case "kn":
+          return await import("ckeditor5-premium-features/translations/kn.js");
+        case "ko":
+          return await import("ckeditor5-premium-features/translations/ko.js");
+        case "ku":
+          return await import("ckeditor5-premium-features/translations/ku.js");
+        case "lt":
+          return await import("ckeditor5-premium-features/translations/lt.js");
+        case "lv":
+          return await import("ckeditor5-premium-features/translations/lv.js");
+        case "ms":
+          return await import("ckeditor5-premium-features/translations/ms.js");
+        case "nb":
+          return await import("ckeditor5-premium-features/translations/nb.js");
+        case "ne":
+          return await import("ckeditor5-premium-features/translations/ne.js");
+        case "nl":
+          return await import("ckeditor5-premium-features/translations/nl.js");
+        case "no":
+          return await import("ckeditor5-premium-features/translations/no.js");
+        case "oc":
+          return await import("ckeditor5-premium-features/translations/oc.js");
+        case "pl":
+          return await import("ckeditor5-premium-features/translations/pl.js");
+        case "pt":
+          return await import("ckeditor5-premium-features/translations/pt.js");
+        case "pt-br":
+          return await import("ckeditor5-premium-features/translations/pt-br.js");
+        case "ro":
+          return await import("ckeditor5-premium-features/translations/ro.js");
+        case "ru":
+          return await import("ckeditor5-premium-features/translations/ru.js");
+        case "si":
+          return await import("ckeditor5-premium-features/translations/si.js");
+        case "sk":
+          return await import("ckeditor5-premium-features/translations/sk.js");
+        case "sl":
+          return await import("ckeditor5-premium-features/translations/sl.js");
+        case "sq":
+          return await import("ckeditor5-premium-features/translations/sq.js");
+        case "sr":
+          return await import("ckeditor5-premium-features/translations/sr.js");
+        case "sr-latn":
+          return await import("ckeditor5-premium-features/translations/sr-latn.js");
+        case "sv":
+          return await import("ckeditor5-premium-features/translations/sv.js");
+        case "th":
+          return await import("ckeditor5-premium-features/translations/th.js");
+        case "tk":
+          return await import("ckeditor5-premium-features/translations/tk.js");
+        case "tr":
+          return await import("ckeditor5-premium-features/translations/tr.js");
+        case "tt":
+          return await import("ckeditor5-premium-features/translations/tt.js");
+        case "ug":
+          return await import("ckeditor5-premium-features/translations/ug.js");
+        case "uk":
+          return await import("ckeditor5-premium-features/translations/uk.js");
+        case "ur":
+          return await import("ckeditor5-premium-features/translations/ur.js");
+        case "uz":
+          return await import("ckeditor5-premium-features/translations/uz.js");
+        case "vi":
+          return await import("ckeditor5-premium-features/translations/vi.js");
+        case "zh":
+          return await import("ckeditor5-premium-features/translations/zh.js");
+        case "zh-cn":
+          return await import("ckeditor5-premium-features/translations/zh-cn.js");
+        default:
+          return console.warn(`Language ${t} not found in premium translations`), await import("ckeditor5-premium-features/translations/en.js");
+      }
+  } catch (e) {
+    return console.error(`Failed to load translation for ${r}/${t}:`, e), null;
+  }
+}
+function K(r) {
+  return V(r, (t) => ({
+    dictionary: t
+  }));
+}
+function G() {
+  return Array.from(document.querySelectorAll("cke5-editor")).map((r) => r.getAttribute("data-cke-editor-id")).filter((r) => r !== null);
+}
+function Y(r) {
+  const t = X(r);
+  return V(t, ({ element: e }) => e);
+}
+function _(r) {
+  const t = X(r), e = V(t, ({ content: i }) => i);
+  return et(e, (i) => typeof i == "string");
+}
+function X(r) {
+  const t = Array.from(document.querySelectorAll(`cke5-editable[data-cke-editor-id="${r}"]`)).reduce((o, c) => {
+    const u = c.getAttribute("data-cke-root-name"), s = c.getAttribute("data-cke-content");
+    return o[u] = {
+      element: c.querySelector("[data-cke-editable-content]"),
+      content: s
+    }, o;
+  }, /* @__PURE__ */ Object.create({})), e = document.querySelector(`cke5-editor[data-cke-editor-id="${r}"]`);
+  if (!e)
+    return t;
+  const i = t.main, a = JSON.parse(e.getAttribute("data-cke-content")), n = document.querySelector(`#${r}_editor `);
+  return i && a?.main ? {
+    ...t,
+    main: {
+      ...i,
+      content: i.content || a.main
+    }
+  } : n ? {
+    ...t,
+    main: {
+      element: n,
+      content: a?.main || null
+    }
+  } : t;
+}
+function P(r) {
+  if (!r || typeof r != "object")
+    return r;
+  if (Array.isArray(r))
+    return r.map((i) => P(i));
+  const t = r;
+  if (t.$element && typeof t.$element == "string") {
+    const i = document.querySelector(t.$element);
+    return i || console.warn(`Element not found for selector: ${t.$element}`), i || null;
+  }
+  const e = /* @__PURE__ */ Object.create(null);
+  for (const [i, a] of Object.entries(r))
+    e[i] = P(a);
+  return e;
+}
+function T(r, t, e) {
+  if (!e || typeof e != "object")
+    return e;
+  if (Array.isArray(e))
+    return e.map((n) => T(r, t, n));
+  const i = e;
+  if (i.$translation && typeof i.$translation == "string") {
+    const n = i.$translation, o = ct(r, n, t);
+    return o === void 0 && console.warn(`Translation not found for key: ${n}`), o !== void 0 ? o : null;
+  }
+  const a = /* @__PURE__ */ Object.create(null);
+  for (const [n, o] of Object.entries(e))
+    a[n] = T(r, t, o);
+  return a;
+}
+function ct(r, t, e) {
+  for (const i of r) {
+    const a = i[e];
+    if (a?.dictionary && t in a.dictionary)
+      return a.dictionary[t];
+  }
+}
+function ut(r, t) {
+  const { editing: e } = r;
+  e.view.change((i) => {
+    i.setStyle("height", `${t}px`, e.view.document.getRoot());
+  });
+}
+const N = /* @__PURE__ */ Symbol.for("elixir-editor-watchdog");
+async function lt(r) {
+  const { EditorWatchdog: t } = await import("ckeditor5"), e = new t(r);
+  return e.setCreator(async (...i) => {
+    const a = await r.create(...i);
+    return a[N] = e, a;
+  }), {
+    watchdog: e,
+    Constructor: {
+      create: async (...i) => (await e.create(...i), e.editor)
+    }
+  };
+}
+function dt(r) {
+  return N in r ? r[N] : null;
+}
+class v extends j {
+  static the = new v();
+}
+class mt extends HTMLElement {
+  /**
+   * The promise that resolves to the context instance.
+   */
+  contextPromise = null;
+  /**
+   * Wait result for the interactive attribute.
+   */
+  interactiveWait;
+  /**
+   * Mounts the context component.
+   */
+  async connectedCallback() {
+    await I(), this.interactiveWait = M(this), await this.interactiveWait.promise, await this.initializeContext();
+  }
+  /**
+   * Initializes the context component.
+   */
+  async initializeContext() {
+    const t = this.getAttribute("data-cke-context-id"), e = JSON.parse(this.getAttribute("data-cke-language")), i = JSON.parse(this.getAttribute("data-cke-context")), { customTranslations: a, watchdogConfig: n, config: { plugins: o, ...c } } = i, { loadedPlugins: u, hasPremium: s } = await J(o ?? []), p = [
+      ...await U(e, s),
+      K(a || {})
+    ].filter((f) => !B(f));
+    this.contextPromise = (async () => {
+      const { ContextWatchdog: f, Context: w } = await import("ckeditor5"), h = new f(w, {
+        crashNumberLimit: 10,
+        ...n
+      });
+      let y = P(c);
+      return y = T([...p].reverse(), e.ui, y), await h.create({
+        ...y,
+        language: e,
+        plugins: u,
+        ...p.length && {
+          translations: p
+        }
+      }), h.on("itemError", (...O) => {
+        console.error("Context item error:", ...O);
+      }), h;
+    })();
+    const E = await this.contextPromise;
+    this.isConnected && v.the.register(t, E);
+  }
+  /**
+   * Destroys the context component. Unmounts root from the editor.
+   */
+  async disconnectedCallback() {
+    this.interactiveWait?.disconnect();
+    const t = this.getAttribute("data-cke-context-id");
+    this.style.display = "none";
+    try {
+      await (await this.contextPromise)?.destroy();
+    } finally {
+      this.contextPromise = null, t && v.the.hasItem(t) && v.the.unregister(t);
+    }
+  }
+}
+class m extends j {
+  static the = new m();
+}
+class ht extends HTMLElement {
+  /**
+   * The promise that resolves when the editable is mounted.
+   */
+  editorPromise = null;
+  /**
+   * Wait result for the interactive attribute.
+   */
+  interactiveWait;
+  /**
+   * Callbacks to be invoked before the editable is destroyed.
+   */
+  beforeDestroyCallbacks = [];
+  /**
+   * Registers a callback to be called before the editable is destroyed.
+   */
+  onBeforeDestroy(t) {
+    this.beforeDestroyCallbacks.push(t);
+  }
+  /**
+   * Mounts the editable component.
+   */
+  async connectedCallback() {
+    await I(), this.interactiveWait = M(this), await this.interactiveWait.promise, await this.initializeEditable();
+  }
+  /**
+   * Initializes the editable instance.
+   */
+  async initializeEditable() {
+    this.hasAttribute("data-cke-editor-id") || this.setAttribute("data-cke-editor-id", G()[0]);
+    const t = this.getAttribute("data-cke-editor-id"), e = this.getAttribute("data-cke-root-name"), i = this.getAttribute("data-cke-content"), a = Number.parseInt(this.getAttribute("data-cke-save-debounce-ms"), 10);
+    if (!t || !e)
+      throw new b("Editor ID or Root Name is missing.");
+    this.style.display = "block", this.editorPromise = m.the.execute(t, async (n) => {
+      if (!this.isConnected)
+        return null;
+      const { ui: o, editing: c, model: u } = n, s = this.querySelector("input");
+      if (u.document.getRoot(e)?.isAttached()) {
+        if (i !== null) {
+          const h = n.getData({ rootName: e });
+          h && h !== i && n.setData({
+            [e]: i
+          });
+        }
+        return n;
+      }
+      n.addRoot(e, {
+        isUndoable: !1,
+        ...i !== null && {
+          data: i
+        }
+      });
+      const p = this.querySelector("[data-cke-editable-content]"), E = o.view.createEditable(e, p);
+      o.addEditable(E), c.view.forceRender();
+      const f = () => {
+        if (!u.document.getRoot(e)?.isAttached())
+          return;
+        const h = n.getData({ rootName: e });
+        s && (s.value = h, s.dispatchEvent(new Event("input"))), this.dispatchEvent(new CustomEvent("change", {
+          detail: {
+            value: h
+          }
+        }));
+      }, w = z(a, f);
+      return n.model.document.on("change:data", w), this.onBeforeDestroy(() => n.model.document.off("change:data", w)), f(), n;
+    });
+  }
+  /**
+   * Destroys the editable component. Unmounts root from the editor.
+   */
+  async disconnectedCallback() {
+    this.interactiveWait?.disconnect();
+    const t = this.getAttribute("data-cke-root-name");
+    this.style.display = "none";
+    const e = await this.editorPromise;
+    this.editorPromise = null;
+    for (const i of this.beforeDestroyCallbacks)
+      i();
+    if (this.beforeDestroyCallbacks = [], e && e.state !== "destroyed" && t) {
+      const i = e.model.document.getRoot(t);
+      if (i && "detachEditable" in e) {
+        try {
+          e.ui.view.editables[t] && e.detachEditable(i);
+        } catch (a) {
+          console.error("Unable unmount editable from root:", a);
+        }
+        i.isAttached() && e.detachRoot(t, !1);
+      }
+    }
+  }
+}
+async function pt({
+  saveDebounceMs: r,
+  editorId: t,
+  targetElement: e
+}) {
+  const { Plugin: i } = await import("ckeditor5");
+  return class extends i {
+    /**
+     * The name of the plugin.
+     */
+    static get pluginName() {
+      return "DispatchEditorRootsChangeEvent";
+    }
+    /**
+     * Initializes the plugin.
+     */
+    afterInit() {
+      const { editor: n } = this, o = z(r, this.dispatch);
+      n.model.document.on("change:data", o), n.once("ready", this.dispatch);
+    }
+    /**
+     * Dispatches a custom event with all roots data.
+     */
+    dispatch = () => {
+      const { editor: n } = this;
+      e.dispatchEvent(
+        new g({
+          editorId: t,
+          editor: n,
+          roots: H(n)
+        })
+      );
+    };
+  };
+}
+class g extends CustomEvent {
+  static EVENT_NAME = "ckeditor5:change:data";
+  constructor(t) {
+    super(g.EVENT_NAME, {
+      detail: t,
+      bubbles: !0
+    });
+  }
+}
+async function wt(r) {
+  const { Plugin: t } = await import("ckeditor5");
+  return class extends t {
+    /**
+     * The input element to synchronize with.
+     */
+    input = null;
+    /**
+     * The form element reference for cleanup.
+     */
+    form = null;
+    /**
+     * The name of the plugin.
+     */
+    static get pluginName() {
+      return "SyncEditorWithInput";
+    }
+    /**
+     * Initializes the plugin.
+     */
+    afterInit() {
+      const { editor: i } = this, n = i.sourceElement.id.replace(/_editor$/, "");
+      this.input = document.getElementById(`${n}_input`), this.input && (i.model.document.on("change:data", z(r, () => this.sync())), i.once("ready", this.sync), this.form = this.input.closest("form"), this.form?.addEventListener("submit", this.sync));
+    }
+    /**
+     * Synchronizes the editor's content with the input field.
+     */
+    sync = () => {
+      if (this.input) {
+        const i = this.editor.getData();
+        this.input.value = i, this.input.dispatchEvent(new Event("input", { bubbles: !0 }));
+      }
+    };
+    /**
+     * Destroys the plugin.
+     */
+    destroy() {
+      this.form && this.form.removeEventListener("submit", this.sync), this.input = null, this.form = null;
+    }
+  };
+}
+class ft extends HTMLElement {
+  /**
+   * The promise that resolves to the editor instance.
+   */
+  editorPromise = null;
+  /**
+   * Wait result for the interactive attribute.
+   */
+  interactiveWait;
+  /**
+   * Mounts the editor component.
+   */
+  async connectedCallback() {
+    await I(), this.interactiveWait = M(this), L("classic"), await this.interactiveWait.promise, await this.initializeEditor();
+  }
+  /**
+   * Initializes the editor instance.
+   */
+  async initializeEditor() {
+    const t = this.getAttribute("data-cke-editor-id");
+    m.the.resetErrors(t);
+    try {
+      this.style.display = "block", this.editorPromise = this.createEditor();
+      const e = await this.editorPromise;
+      this.isConnected && (m.the.register(t, e), e.once("destroy", () => {
+        m.the.hasItem(t) && m.the.unregister(t);
+      }));
+    } catch (e) {
+      console.error(`Error initializing CKEditor5 instance with ID "${t}":`, e), this.editorPromise = null, m.the.error(t, e);
+    }
+  }
+  /**
+   * Destroys the editor instance when the component is destroyed.
+   * This is important to prevent memory leaks and ensure that the editor is properly cleaned up.
+   */
+  async disconnectedCallback() {
+    this.interactiveWait?.disconnect(), this.style.display = "none";
+    try {
+      const t = await this.editorPromise;
+      if (!t)
+        return;
+      const e = ot(t), i = dt(t);
+      e ? e.state !== "unavailable" && await e.context.remove(e.editorContextId) : i ? await i.destroy() : await t.destroy();
+    } finally {
+      this.editorPromise = null;
+    }
+  }
+  /**
+   * Creates the CKEditor instance.
+   */
+  async createEditor() {
+    const t = this.getAttribute("data-cke-editor-id"), e = JSON.parse(this.getAttribute("data-cke-preset")), i = this.getAttribute("data-cke-context-id"), a = this.getAttribute("data-cke-editable-height") ? Number.parseInt(this.getAttribute("data-cke-editable-height"), 10) : null, n = Number.parseInt(this.getAttribute("data-cke-save-debounce-ms"), 10), o = JSON.parse(this.getAttribute("data-cke-language")), c = this.hasAttribute("data-cke-watchdog"), u = JSON.parse(this.getAttribute("data-cke-content")), {
+      customTranslations: s,
+      editorType: l,
+      licenseKey: p,
+      config: { plugins: E, ...f }
+    } = e;
+    let w = await L(l);
+    const h = await (i ? v.the.waitFor(i) : null);
+    if (c && !h) {
+      const d = await lt(w);
+      ({ Constructor: w } = d), d.watchdog.on("restart", () => {
+        const k = d.watchdog.editor;
+        this.editorPromise = Promise.resolve(k), m.the.register(t, k);
+      });
+    }
+    const { loadedPlugins: y, hasPremium: O } = await J(E);
+    y.push(
+      await pt({
+        saveDebounceMs: n,
+        editorId: t,
+        targetElement: this
+      })
+    ), A(l) && y.push(
+      await wt(n)
+    );
+    const S = [
+      ...await U(o, O),
+      K(s || {})
+    ].filter((d) => !B(d));
+    let C = {
+      ...u,
+      ..._(t)
+    };
+    A(l) && (C = C.main || "");
+    const R = await (async () => {
+      let d = Y(t);
+      if (!d.main) {
+        const q = A(l) ? ["main"] : Object.keys(C);
+        Q(d, q) || (d = await gt(t, q), C = {
+          ...u,
+          ..._(t)
+        });
+      }
+      A(l) && "main" in d && (d = d.main);
+      let k = P(f);
+      k = T([...S].reverse(), o.ui, k);
+      const W = {
+        ...k,
+        initialData: C,
+        licenseKey: p,
+        plugins: y,
+        language: o,
+        ...S.length && {
+          translations: S
+        }
+      };
+      return !h || !(d instanceof HTMLElement) ? w.create(d, W) : (await nt({
+        context: h,
+        element: d,
+        creator: w,
+        config: W
+      })).editor;
+    })();
+    return A(l) && a && ut(R, a), R;
+  }
+}
+function Q(r, t) {
+  return t.every((e) => r[e]);
+}
+async function gt(r, t) {
+  return at(
+    () => {
+      const e = Y(r);
+      if (!Q(e, t))
+        throw new Error(
+          `It looks like not all required root elements are present yet.
+* If you want to wait for them, ensure they are registered before editor initialization.
+* If you want lazy initialize roots, consider removing root values from the \`initialData\` config and assign initial data in editable components.
+Missing roots: ${t.filter((i) => !e[i]).join(", ")}.`
+        );
+      return e;
+    },
+    { timeOutAfter: 2e3, retryAfter: 100 }
+  );
+}
+class yt extends HTMLElement {
+  /**
+   * The promise that resolves when the UI part is mounted.
+   */
+  mountedPromise = null;
+  /**
+   * Mounts the UI part component.
+   */
+  async connectedCallback() {
+    await I();
+    const t = this.getAttribute("data-cke-editor-id") || G()[0], e = this.getAttribute("data-cke-name");
+    !t || !e || (this.style.display = "block", this.mountedPromise = m.the.execute(t, (i) => {
+      if (!this.isConnected)
+        return;
+      const { ui: a } = i, n = bt(e), o = a.view[n];
+      if (!o)
+        throw new b(`Unknown UI part name: "${e}". Supported names are "toolbar" and "menubar".`);
+      this.appendChild(o.element);
+    }));
+  }
+  /**
+   * Destroys the UI part component. Unmounts UI parts from the editor.
+   */
+  async disconnectedCallback() {
+    this.style.display = "none", await this.mountedPromise, this.mountedPromise = null, this.innerHTML = "";
+  }
+}
+function bt(r) {
+  switch (r) {
+    case "toolbar":
+      return "toolbar";
+    case "menubar":
+      return "menuBarView";
+    /* v8 ignore next -- @preserve */
+    default:
+      return null;
+  }
+}
+const Et = {
+  "cke5-editor": ft,
+  "cke5-context": mt,
+  "cke5-ui-part": yt,
+  "cke5-editable": ht
+};
+function kt() {
+  for (const [r, t] of Object.entries(Et))
+    window.customElements.get(r) || window.customElements.define(r, t);
+}
+function Tt(r) {
+  return D(r), {
+    unmount() {
+    }
+  };
+}
+function Z(r, t) {
+  const e = {
+    /** Value received from Blazor while the editor was focused, pending application on blur. */
+    pendingValue: null,
+    /** The last value sent to or received from Blazor to prevent circular updates. */
+    lastSyncedValue: null
+  }, i = () => {
+    e.pendingValue = null;
+  }, a = (n, o, c) => {
+    if (c || e.pendingValue === null)
+      return;
+    const u = t.getCurrentValue();
+    t.isEqual(u, e.pendingValue) || t.applyValue(e.pendingValue), e.pendingValue = null;
+  };
+  return r.model.document.on("change:data", i), r.ui.focusTracker.on("change:isFocused", a), {
+    /**
+     * Removes all editor listeners registered by this sync instance.
+     * Call this when the Blazor component is disposed.
+     */
+    unmount() {
+      r.model.document.off("change:data", i), r.ui.focusTracker.off("change:isFocused", a);
+    },
+    /**
+     * Checks whether the given value differs from the last synced value and, if so,
+     * updates `lastSyncedValue` and returns `true` to signal that Blazor should be notified.
+     *
+     * Call this from the `CKEditor5ChangeDataEvent` handler to conditionally invoke
+     * the .NET interop method.
+     */
+    shouldNotify(n) {
+      return e.lastSyncedValue !== null && t.isEqual(e.lastSyncedValue, n) ? !1 : (e.lastSyncedValue = n, !0);
+    },
+    /**
+     * Pushes a new value from Blazor into the editor.
+     * If the editor is currently focused, the update is deferred until blur.
+     * If the value matches the last synced state, the update is skipped entirely.
+     */
+    setValue(n) {
+      if (r.ui.focusTracker.isFocused) {
+        e.pendingValue = n;
+        return;
+      }
+      e.lastSyncedValue !== null && t.isEqual(e.lastSyncedValue, n) || (e.lastSyncedValue = n, t.applyValue(n));
+    }
+  };
+}
+function tt() {
+  return {
+    unmount() {
+    },
+    shouldNotify(r) {
+      return !1;
+    },
+    setValue(r) {
+    }
+  };
+}
+function It(r, t) {
+  const e = r.getAttribute("data-cke-editor-id"), i = r.getAttribute("data-cke-root-name") ?? "main";
+  let a = !1, n = tt(), o = null;
+  const c = (s) => {
+    if (!(s instanceof g) || s.detail.editorId !== e)
+      return;
+    const l = s.detail.roots[i];
+    l !== void 0 && n.shouldNotify(l) && t.invokeMethodAsync("OnChangeEditableData", o, l);
+  };
+  return (async () => {
+    const s = await m.the.waitFor(e);
+    o = DotNet.createJSObjectReference(s), n = Z(s, {
+      getCurrentValue: () => s.getData({ rootName: i }) ?? "",
+      applyValue: (l) => s.setData({ [i]: l }),
+      isEqual: (l, p) => l === p
+    });
+  })(), document.body.addEventListener(g.EVENT_NAME, c), D(r), {
+    /**
+     * Cleans up all event listeners when the Blazor component is disposed.
+     */
+    unmount() {
+      a || (document.body.removeEventListener(g.EVENT_NAME, c), n.unmount(), o && (DotNet.disposeJSObjectReference(o), o = null), a = !0);
+    },
+    /**
+     * Updates this editable root's data from Blazor.
+     * If the editor is focused, the update is deferred until blur to avoid interrupting the user.
+     */
+    setValue: async (s) => {
+      a || (await m.the.waitFor(e), n.setValue(s));
+    }
+  };
+}
+function Dt(r, t) {
+  const e = r.getAttribute("data-cke-editor-id");
+  let i = !1, a = null, n = tt(), o = null;
+  const c = (s) => {
+    !(s instanceof g) || s.detail.editorId !== e || n.shouldNotify(s.detail.roots) && t.invokeMethodAsync("OnChangeEditorData", o, s.detail.roots);
+  };
+  return (async () => {
+    const s = await m.the.waitFor(e);
+    o = globalThis.DotNet.createJSObjectReference(s), n = Z(s, {
+      getCurrentValue: () => H(s),
+      applyValue: (p) => s.setData(p),
+      isEqual: rt
+    });
+    const l = (p, E, f) => {
+      const w = f ? "OnEditorFocus" : "OnEditorBlur";
+      t.invokeMethodAsync(w, o);
+    };
+    s.ui.focusTracker.on("change:isFocused", l), t.invokeMethodAsync("OnEditorReady", o), a = () => {
+      s.ui.focusTracker.off("change:isFocused", l);
+    };
+  })(), document.body.addEventListener(g.EVENT_NAME, c), kt(), D(r), {
+    /**
+     * Updates the editor data from Blazor. If the editor is focused, the update is deferred until blur to avoid interrupting the user.
+     */
+    setValue: async (s) => {
+      i || (await m.the.waitFor(e), n.setValue(s));
+    },
+    /**
+     * Cleans up all event listeners when the Blazor component is disposed.
+     */
+    unmount() {
+      i || (document.body.removeEventListener(g.EVENT_NAME, c), n.unmount(), a?.(), o && (globalThis.DotNet.disposeJSObjectReference(o), o = null), i = !0);
+    }
+  };
+}
+function Ot(r) {
+  return D(r), {
+    unmount() {
+    }
+  };
+}
+export {
+  b as CKEditor5BlazorError,
+  g as CKEditor5ChangeDataEvent,
+  v as ContextsRegistry,
+  $ as CustomEditorPluginsRegistry,
+  ht as EditableComponentElement,
+  ft as EditorComponentElement,
+  m as EditorsRegistry,
+  yt as UIPartComponentElement,
+  Tt as createContextBlazorInterop,
+  It as createEditableBlazorInterop,
+  Dt as createEditorBlazorInterop,
+  Ot as createUIPartBlazorInterop,
+  kt as ensureEditorElementsRegistered
+};
+//# sourceMappingURL=index.mjs.map