ckeditor5-livewire 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1146 @@
+class P {
+  constructor(t) {
+    this.livewireComponent = t;
+  }
+  /**
+   * The current state of the hook.
+   */
+  state = "mounting";
+  /**
+   * The ephemeral snapshot of the Livewire component.
+   */
+  get ephemeral() {
+    return this.livewireComponent.ephemeral;
+  }
+  /**
+   * The root HTML element of the Livewire component.
+   */
+  get element() {
+    return this.livewireComponent.el;
+  }
+  /**
+   * The wire interface for the Livewire component.
+   */
+  get $wire() {
+    return this.livewireComponent.$wire;
+  }
+  /**
+   * Checks if the hook is in the process of being destroyed.
+   */
+  isBeingDestroyed() {
+    return ["destroyed", "destroying"].includes(this.state);
+  }
+}
+function _(r, t) {
+  window.Livewire.hook("component.init", async ({ component: e, cleanup: i }) => {
+    if (e.name !== r)
+      return;
+    const a = new t(e);
+    i(async () => {
+      a.state = "destroying", await a.destroyed(), a.state = "destroyed";
+    }), await a.mounted(), a.state = "mounted";
+  });
+}
+class H {
+  /**
+   * 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), s = this.initializationErrors.get(t);
+    return s ? (i?.(s), Promise.reject(s)) : a ? Promise.resolve(e(a)) : new Promise((n, o) => {
+      const c = this.getPendingCallbacks(t);
+      c.success.push(async (u) => {
+        n(await e(u));
+      }), i ? c.error.push(i) : c.error.push(o);
+    });
+  }
+  /**
+   * 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.
+   * @returns A promise that resolves with the item instance.
+   */
+  waitFor(t) {
+    return new Promise((e, i) => {
+      this.execute(t, e, i);
+    });
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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 D(r, t) {
+  let e = null;
+  return (...i) => {
+    e && clearTimeout(e), e = setTimeout(() => {
+      t(...i);
+    }, r);
+  };
+}
+function G(r, t) {
+  const e = Object.entries(r).filter(([i, a]) => t(a, i));
+  return Object.fromEntries(e);
+}
+function W(r) {
+  return Object.keys(r).length === 0 && r.constructor === Object;
+}
+function $(r, t) {
+  const e = Object.entries(r).map(([i, a]) => [i, t(a, i)]);
+  return Object.fromEntries(e);
+}
+function K() {
+  return Math.random().toString(36).substring(2);
+}
+function Y(r, {
+  timeOutAfter: t = 500,
+  retryAfter: e = 100
+} = {}) {
+  return new Promise((i, a) => {
+    const s = Date.now();
+    let n = null;
+    const o = setTimeout(() => {
+      a(n ?? new Error("Timeout"));
+    }, t), c = async () => {
+      try {
+        const u = await r();
+        clearTimeout(o), i(u);
+      } catch (u) {
+        n = u, Date.now() - s > t ? a(u) : setTimeout(c, e);
+      }
+    };
+    c();
+  });
+}
+const x = Symbol.for("context-editor-watchdog");
+async function X({ element: r, context: t, creator: e, config: i }) {
+  const a = K();
+  await t.add({
+    creator: (c, u) => e.create(c, u),
+    id: a,
+    sourceElementOrData: r,
+    type: "editor",
+    config: i
+  });
+  const s = t.getItem(a), n = {
+    state: "available",
+    editorContextId: a,
+    context: t
+  };
+  s[x] = n;
+  const o = t.destroy.bind(t);
+  return t.destroy = async () => (n.state = "unavailable", o()), {
+    ...n,
+    editor: s
+  };
+}
+function J(r) {
+  return x in r ? r[x] : null;
+}
+function Q(r) {
+  return r.model.document.getRootNames().reduce((e, i) => (e[i] = r.getData({ rootName: i }), e), /* @__PURE__ */ Object.create({}));
+}
+function b(r) {
+  return ["inline", "classic", "balloon", "decoupled"].includes(r);
+}
+async function Z(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 Error(`Unsupported editor type: ${r}`);
+  return i;
+}
+class z {
+  static the = new z();
+  /**
+   * 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 Error(`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 Error(`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 q(r) {
+  const t = await import("ckeditor5");
+  let e = null;
+  const i = r.map(async (a) => {
+    const s = await z.the.get(a);
+    if (s)
+      return s;
+    const { [a]: n } = t;
+    if (n)
+      return n;
+    if (!e)
+      try {
+        e = await import("ckeditor5-premium-features");
+      } catch (c) {
+        console.error(`Failed to load premium package: ${c}`);
+      }
+    const { [a]: o } = e || {};
+    if (o)
+      return o;
+    throw new Error(`Plugin "${a}" not found in base or premium packages.`);
+  });
+  return {
+    loadedPlugins: await Promise.all(i),
+    hasPremium: !!e
+  };
+}
+async function B(r, t) {
+  const e = [r.ui, r.content];
+  return await Promise.all(
+    [
+      A("ckeditor5", e),
+      /* v8 ignore next */
+      t && A("ckeditor5-premium-features", e)
+    ].filter((a) => !!a)
+  ).then((a) => a.flat());
+}
+async function A(r, t) {
+  return await Promise.all(
+    t.filter((e) => e !== "en").map(async (e) => {
+      const i = await tt(r, e);
+      return i?.default ?? i;
+    }).filter(Boolean)
+  );
+}
+async function tt(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 F(r) {
+  return $(r, (t) => ({
+    dictionary: t
+  }));
+}
+function M(r) {
+  return window.Livewire.all().filter(({ name: t, ephemeral: e }) => t === "ckeditor5-editable" && e.editorId === r).reduce((t, { ephemeral: e, el: i }) => ({
+    ...t,
+    [e.rootName]: {
+      element: i.querySelector("[data-cke-editable-content]"),
+      content: e.content
+    }
+  }), /* @__PURE__ */ Object.create({}));
+}
+function I(r, t) {
+  if (t === "decoupled") {
+    const { element: i } = N(r);
+    return i;
+  }
+  if (b(t))
+    return document.getElementById(`${r}_editor`);
+  const e = M(r);
+  return $(e, ({ element: i }) => i);
+}
+function j(r, t) {
+  if (t === "decoupled") {
+    const { content: a } = N(r);
+    if (typeof a == "string")
+      return {
+        main: a
+      };
+  }
+  const e = M(r), i = $(e, ({ content: a }) => a);
+  return G(i, (a) => typeof a == "string");
+}
+function N(r) {
+  const t = M(r).main;
+  if (!t)
+    throw new Error(`No "main" editable found for editor with ID "${r}".`);
+  return t;
+}
+function T(r) {
+  if (!r || typeof r != "object")
+    return r;
+  if (Array.isArray(r))
+    return r.map((i) => T(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] = T(a);
+  return e;
+}
+function et(r, t) {
+  const { editing: e } = r;
+  e.view.change((i) => {
+    i.setStyle("height", `${t}px`, e.view.document.getRoot());
+  });
+}
+const O = Symbol.for("elixir-editor-watchdog");
+async function rt(r) {
+  const { EditorWatchdog: t } = await import("ckeditor5"), e = new t(r);
+  return e.setCreator(async (...i) => {
+    const a = await r.create(...i);
+    return a[O] = e, a;
+  }), {
+    watchdog: e,
+    Constructor: {
+      create: async (...i) => (await e.create(...i), e.editor)
+    }
+  };
+}
+function it(r) {
+  return O in r ? r[O] : null;
+}
+class f extends H {
+  static the = new f();
+}
+class at extends P {
+  /**
+   * The promise that resolves to the context instance.
+   */
+  contextPromise = null;
+  /**
+   * Mounts the context component.
+   */
+  async mounted() {
+    const { contextId: t, language: e, context: i } = this.ephemeral, { customTranslations: a, watchdogConfig: s, config: { plugins: n, ...o } } = i, { loadedPlugins: c, hasPremium: u } = await q(n ?? []), l = [
+      ...await B(e, u),
+      F(a || {})
+    ].filter((d) => !W(d));
+    this.contextPromise = (async () => {
+      const { ContextWatchdog: d, Context: v } = await import("ckeditor5"), w = new d(v, {
+        crashNumberLimit: 10,
+        ...s
+      });
+      return await w.create({
+        ...o,
+        language: e,
+        plugins: c,
+        ...l.length && {
+          translations: l
+        }
+      }), w.on("itemError", (...g) => {
+        console.error("Context item error:", ...g);
+      }), w;
+    })();
+    const h = await this.contextPromise;
+    this.isBeingDestroyed() || f.the.register(t, h);
+  }
+  /**
+   * Destroys the context component. Unmounts root from the editor.
+   */
+  async destroyed() {
+    const { contextId: t } = this.ephemeral;
+    this.element.style.display = "none";
+    try {
+      await (await this.contextPromise)?.destroy();
+    } finally {
+      this.contextPromise = null, f.the.hasItem(t) && f.the.unregister(t);
+    }
+  }
+}
+class p extends H {
+  static the = new p();
+}
+class nt extends P {
+  /**
+   * The promise that resolves when the editable is mounted.
+   */
+  editorPromise = null;
+  /**
+   * Mounts the editable component.
+   */
+  mounted() {
+    const { editorId: t, rootName: e, content: i, saveDebounceMs: a } = this.ephemeral, s = this.element.querySelector("input");
+    this.editorPromise = p.the.execute(t, (n) => {
+      const { ui: o, editing: c, model: u } = n;
+      if (u.document.getRoot(e)) {
+        if (i !== null) {
+          const d = n.getData({ rootName: e });
+          d && d !== i && n.setData({
+            [e]: i
+          });
+        }
+        return n;
+      }
+      n.addRoot(e, {
+        isUndoable: !1,
+        ...i !== null && {
+          data: i
+        }
+      });
+      const k = this.element.querySelector("[data-cke-editable-content]"), l = o.view.createEditable(e, k);
+      o.addEditable(l), c.view.forceRender();
+      const h = () => {
+        const d = n.getData({ rootName: e });
+        s && (s.value = d), this.$wire.set("content", d);
+      };
+      return n.model.document.on("change:data", D(a, h)), h(), n;
+    });
+  }
+  /**
+   * Destroys the editable component. Unmounts root from the editor.
+   */
+  async destroyed() {
+    const { rootName: t } = this.ephemeral;
+    this.element.style.display = "none";
+    const e = await this.editorPromise;
+    if (this.editorPromise = null, e && e.state !== "destroyed") {
+      const i = e.model.document.getRoot(t);
+      i && "detachEditable" in e && (e.detachEditable(i), e.detachRoot(t, !1));
+    }
+  }
+}
+async function st({
+  emit: r,
+  saveDebounceMs: t,
+  $wire: e
+}) {
+  const { Plugin: i } = await import("ckeditor5");
+  return class extends i {
+    /**
+     * The name of the plugin.
+     */
+    static get pluginName() {
+      return "LivewireSync";
+    }
+    /**
+     * Initializes the plugin.
+     */
+    init() {
+      r.change && this.setupTypingContentPush(), r.focus && this.setupFocusableEventPush();
+    }
+    /**
+     * Setups the content push event for the editor.
+     */
+    setupTypingContentPush() {
+      const { model: s } = this.editor, n = () => {
+        e.set("content", this.getEditorRootsValues());
+      };
+      s.document.on("change:data", D(t, n)), n();
+    }
+    /**
+     * Setups the event push for the editor.
+     */
+    setupFocusableEventPush() {
+      const { ui: s } = this.editor, n = () => {
+        e.set("focused", s.focusTracker.isFocused), e.set("content", this.getEditorRootsValues());
+      };
+      s.focusTracker.on("change:isFocused", n);
+    }
+    /**
+     * Gets the current values of all editor roots.
+     */
+    getEditorRootsValues() {
+      return Q(this.editor);
+    }
+  };
+}
+async function ot(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, s = i.sourceElement.id.replace(/_editor$/, "");
+      this.input = document.getElementById(`${s}_input`), this.input && (i.model.document.on("change:data", D(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 = () => {
+      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 ct extends P {
+  /**
+   * The promise that resolves to the editor instance.
+   */
+  editorPromise = null;
+  /**
+   * @inheritdoc
+   */
+  async mounted() {
+    const { editorId: t } = this.ephemeral;
+    p.the.resetErrors(t);
+    try {
+      this.editorPromise = this.createEditor();
+      const e = await this.editorPromise;
+      this.isBeingDestroyed() || (p.the.register(t, e), e.once("destroy", () => {
+        p.the.hasItem(t) && p.the.unregister(t);
+      }));
+    } catch (e) {
+      this.editorPromise = null, p.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 destroyed() {
+    this.element.style.display = "none";
+    try {
+      const t = await this.editorPromise;
+      if (!t)
+        return;
+      const e = J(t), i = it(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 {
+      preset: t,
+      editorId: e,
+      contextId: i,
+      editableHeight: a,
+      emit: s,
+      saveDebounceMs: n,
+      language: o,
+      watchdog: c,
+      content: u
+    } = this.ephemeral, {
+      customTranslations: k,
+      editorType: l,
+      licenseKey: h,
+      config: { plugins: d, ...v }
+    } = t;
+    let w = await Z(l);
+    const g = await (i ? f.the.waitFor(i) : null);
+    if (c && !g) {
+      const m = await rt(w);
+      ({ Constructor: w } = m), m.watchdog.on("restart", () => {
+        const E = m.watchdog.editor;
+        this.editorPromise = Promise.resolve(E), p.the.register(e, E);
+      });
+    }
+    const { loadedPlugins: C, hasPremium: U } = await q(d);
+    C.push(
+      await st(
+        {
+          emit: s,
+          saveDebounceMs: n,
+          $wire: this.$wire
+        }
+      )
+    ), b(l) && C.push(
+      await ot(n)
+    );
+    const S = [
+      ...await B(o, U),
+      F(k || {})
+    ].filter((m) => !W(m));
+    let y = {
+      ...u,
+      ...j(e, l)
+    };
+    b(l) && (y = y.main || "");
+    const R = await (async () => {
+      let m = I(e, l);
+      if (lt(m, l)) {
+        const L = Object.keys(y);
+        V(m, L) || (m = await ut(e, l, L), y = {
+          ...u,
+          ...j(e, l)
+        });
+      }
+      const E = {
+        ...T(v),
+        initialData: y,
+        licenseKey: h,
+        plugins: C,
+        language: o,
+        ...S.length && {
+          translations: S
+        }
+      };
+      return !g || !(m instanceof HTMLElement) ? w.create(m, E) : (await X({
+        context: g,
+        element: m,
+        creator: w,
+        config: E
+      })).editor;
+    })();
+    return b(l) && a && et(R, a), R;
+  }
+}
+function V(r, t) {
+  return t.every((e) => r[e]);
+}
+async function ut(r, t, e) {
+  return await Y(
+    () => {
+      const i = I(r, t);
+      if (!V(i, e))
+        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: ${e.filter((a) => !i[a]).join(", ")}.`
+        );
+      return !0;
+    },
+    { timeOutAfter: 2e3, retryAfter: 100 }
+  ), I(r, t);
+}
+function lt(r, t) {
+  return !b(t) && typeof r == "object" && !(r instanceof HTMLElement);
+}
+class mt extends P {
+  /**
+   * The promise that resolves when the UI part is mounted.
+   */
+  mountedPromise = null;
+  /**
+   * Mounts the UI part component.
+   */
+  async mounted() {
+    const { editorId: t, name: e } = this.ephemeral;
+    this.mountedPromise = p.the.execute(t, (i) => {
+      const { ui: a } = i, s = dt(e), n = a.view[s];
+      if (!n) {
+        console.error(`Unknown UI part name: "${e}". Supported names are "toolbar" and "menubar".`);
+        return;
+      }
+      this.element.appendChild(n.element);
+    });
+  }
+  /**
+   * Destroys the UI part component. Unmounts UI parts from the editor.
+   */
+  async destroyed() {
+    this.element.style.display = "none", await this.mountedPromise, this.mountedPromise = null, this.element.innerHTML = "";
+  }
+}
+function dt(r) {
+  switch (r) {
+    case "toolbar":
+      return "toolbar";
+    case "menubar":
+      return "menuBarView";
+    default:
+      return null;
+  }
+}
+const pt = {
+  ckeditor5: ct,
+  "ckeditor5-context": at,
+  "ckeditor5-ui-part": mt,
+  "ckeditor5-editable": nt
+};
+function wt() {
+  for (const [r, t] of Object.entries(pt))
+    _(r, t);
+}
+wt();
+//# sourceMappingURL=index.mjs.map