reactjs-tiptap-editor 0.2.29 → 0.3.0

package/lib/{index-CO-iymkb.js → index-D9llIWB5.js}

@@ -1,9 +1,8 @@
-var p = Object.defineProperty;
-var s = (e, t, o) => t in e ? p(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
-var a = (e, t, o) => s(e, typeof t != "symbol" ? t + "" : t, o);
-import { useMemo as m, useEffect as g } from "react";
-import { aj as u, ak as c } from "./vendor-BbgkyoD-.js";
-const h = "en", b = 200, E = b - 80, L = 20, S = 1e5, w = 16, B = 10, R = 10, I = 2, W = [
+var D = Object.defineProperty;
+var S = (t, o, n) => o in t ? D(t, o, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[o] = n;
+var F = (t, o, n) => S(t, typeof o != "symbol" ? o + "" : o, n);
+import { useSyncExternalStore as y, useMemo as E, useEffect as L } from "react";
+const w = "en", B = 200, it = B - 80, rt = 20, lt = 1e5, dt = 16, at = 10, nt = 10, st = 2, pt = [
   "#000000",
   "#262626",
   "#595959",
@@ -74,7 +73,7 @@ const h = "en", b = 200, E = b - 80, L = 20, S = 1e5, w = 16, B = 10, R = 10, I
   "#061178",
   "#22075E",
   "#780650"
-], U = [
+], ut = [
   "Inter",
   "Comic Sans MS, Comic Sans",
   "serif",
@@ -90,7 +89,7 @@ const h = "en", b = 200, E = b - 80, L = 20, S = 1e5, w = 16, B = 10, R = 10, I
   "Lucida Console",
   "Monaco",
   "monospace"
-], j = [
+], gt = [
   "10px",
   "11px",
   "12px",
@@ -105,9 +104,9 @@ const h = "en", b = 200, E = b - 80, L = 20, S = 1e5, w = 16, B = 10, R = 10, I
   "36px",
   "48px",
   "72px"
-], P = "default";
-var f = /* @__PURE__ */ ((e) => (e[e["size-small"] = 200] = "size-small", e[e["size-medium"] = 500] = "size-medium", e["size-large"] = "100%", e))(f || {}), k = /* @__PURE__ */ ((e) => (e[e["size-small"] = 480] = "size-small", e[e["size-medium"] = 640] = "size-medium", e["size-large"] = "100%", e))(k || {});
-const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
+], mt = "default";
+var R = /* @__PURE__ */ ((t) => (t[t["size-small"] = 200] = "size-small", t[t["size-medium"] = 500] = "size-medium", t["size-large"] = "100%", t))(R || {}), I = /* @__PURE__ */ ((t) => (t[t["size-small"] = 480] = "size-small", t[t["size-medium"] = 640] = "size-medium", t["size-large"] = "100%", t))(I || {});
+const ct = ["100%", "115%", "150%", "200%", "250%", "300%"], ht = "1", ft = [
   "bold",
   "italic",
   "underline",
@@ -118,7 +117,348 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "color",
   "highlight",
   "textAlign"
-], F = {
+];
+function W({
+  updateComputed: t,
+  notifyEffect: o
+}) {
+  let n, s;
+  return {
+    /**
+     * Links a given dependency and subscriber if they are not already linked.
+     * 
+     * @param dep - The dependency to be linked.
+     * @param sub - The subscriber that depends on this dependency.
+     * @returns The newly created link object if the two are not already linked; otherwise `undefined`.
+     */
+    link(e, i) {
+      const r = i.depsTail;
+      if (r !== void 0 && r.dep === e)
+        return;
+      const d = r !== void 0 ? r.nextDep : i.deps;
+      if (d !== void 0 && d.dep === e) {
+        i.depsTail = d;
+        return;
+      }
+      const l = e.subsTail;
+      if (!(l !== void 0 && l.sub === i && h(l, i)))
+        return p(e, i, d, r);
+    },
+    /**
+     * Traverses and marks subscribers starting from the provided link.
+     * 
+     * It sets flags (e.g., Dirty, PendingComputed, PendingEffect) on each subscriber
+     * to indicate which ones require re-computation or effect processing. 
+     * This function should be called after a signal's value changes.
+     * 
+     * @param link - The starting link from which propagation begins.
+     */
+    propagate(e) {
+      let i = 32, r = e, d = 0;
+      t: do {
+        const l = e.sub, a = l.flags;
+        if (!(a & 244) && (l.flags = a | i | 8, !0) || a & 16 && !(a & 4) && (l.flags = a & -17 | i | 8, !0) || !(a & 224) && h(e, l) && (l.flags = a | 16 | i | 8, l.subs !== void 0)) {
+          const g = l.subs;
+          if (g !== void 0) {
+            g.nextSub !== void 0 ? (g.prevSub = r, e = r = g, i = 64, ++d) : (e = g, i = a & 2 ? 128 : 64);
+            continue;
+          }
+          a & 2 && (s !== void 0 ? s.depsTail.nextDep = l.deps : n = l, s = l);
+        } else a & (4 | i) ? !(a & i) && a & 224 && h(e, l) && (l.flags = a | i) : (l.flags = a | i | 8, (a & 10) === 2 && (s !== void 0 ? s.depsTail.nextDep = l.deps : n = l, s = l));
+        if ((e = r.nextSub) !== void 0) {
+          r = e, i = d ? 64 : 32;
+          continue;
+        }
+        for (; d; ) {
+          --d;
+          const x = r.dep.subs;
+          if (r = x.prevSub, x.prevSub = void 0, (e = r.nextSub) !== void 0) {
+            r = e, i = d ? 64 : 32;
+            continue t;
+          }
+        }
+        break;
+      } while (!0);
+    },
+    /**
+     * Prepares the given subscriber to track new dependencies.
+     * 
+     * It resets the subscriber's internal pointers (e.g., depsTail) and
+     * sets its flags to indicate it is now tracking dependency links.
+     * 
+     * @param sub - The subscriber to start tracking.
+     */
+    startTracking(e) {
+      e.depsTail = void 0, e.flags = e.flags & -249 | 4;
+    },
+    /**
+     * Concludes tracking of dependencies for the specified subscriber.
+     * 
+     * It clears or unlinks any tracked dependency information, then
+     * updates the subscriber's flags to indicate tracking is complete.
+     * 
+     * @param sub - The subscriber whose tracking is ending.
+     */
+    endTracking(e) {
+      const i = e.depsTail;
+      if (i !== void 0) {
+        const r = i.nextDep;
+        r !== void 0 && (T(r), i.nextDep = void 0);
+      } else e.deps !== void 0 && (T(e.deps), e.deps = void 0);
+      e.flags &= -5;
+    },
+    /**
+     * Updates the dirty flag for the given subscriber based on its dependencies.
+     * 
+     * If the subscriber has any pending computeds, this function sets the Dirty flag
+     * and returns `true`. Otherwise, it clears the PendingComputed flag and returns `false`.
+     * 
+     * @param sub - The subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     * @returns `true` if the subscriber is marked as Dirty; otherwise `false`.
+     */
+    updateDirtyFlag(e, i) {
+      return v(e.deps) ? (e.flags = i | 32, !0) : (e.flags = i & -65, !1);
+    },
+    /**
+     * Updates the computed subscriber if necessary before its value is accessed.
+     * 
+     * If the subscriber is marked Dirty or PendingComputed, this function runs
+     * the provided updateComputed logic and triggers a shallowPropagate for any
+     * downstream subscribers if an actual update occurs.
+     * 
+     * @param computed - The computed subscriber to update.
+     * @param flags - The current flag set for this subscriber.
+     */
+    processComputedUpdate(e, i) {
+      if ((i & 32 || (v(e.deps) || (e.flags = i & -65, !1))) && t(e)) {
+        const r = e.subs;
+        r !== void 0 && c(r);
+      }
+    },
+    /**
+     * Ensures all pending internal effects for the given subscriber are processed.
+     * 
+     * This should be called after an effect decides not to re-run itself but may still
+     * have dependencies flagged with PendingEffect. If the subscriber is flagged with
+     * PendingEffect, this function clears that flag and invokes `notifyEffect` on any
+     * related dependencies marked as Effect and Propagated, processing pending effects.
+     * 
+     * @param sub - The subscriber which may have pending effects.
+     * @param flags - The current flags on the subscriber to check.
+     */
+    processPendingInnerEffects(e, i) {
+      if (i & 128) {
+        e.flags = i & -129;
+        let r = e.deps;
+        do {
+          const d = r.dep;
+          "flags" in d && d.flags & 2 && d.flags & 224 && o(d), r = r.nextDep;
+        } while (r !== void 0);
+      }
+    },
+    /**
+     * Processes queued effect notifications after a batch operation finishes.
+     * 
+     * Iterates through all queued effects, calling notifyEffect on each.
+     * If an effect remains partially handled, its flags are updated, and future
+     * notifications may be triggered until fully handled.
+     */
+    processEffectNotifications() {
+      for (; n !== void 0; ) {
+        const e = n, i = e.depsTail, r = i.nextDep;
+        r !== void 0 ? (i.nextDep = void 0, n = r.sub) : (n = void 0, s = void 0), o(e) || (e.flags &= -9);
+      }
+    }
+  };
+  function p(e, i, r, d) {
+    const l = {
+      dep: e,
+      sub: i,
+      nextDep: r,
+      prevSub: void 0,
+      nextSub: void 0
+    };
+    if (d === void 0 ? i.deps = l : d.nextDep = l, e.subs === void 0)
+      e.subs = l;
+    else {
+      const a = e.subsTail;
+      l.prevSub = a, a.nextSub = l;
+    }
+    return i.depsTail = l, e.subsTail = l, l;
+  }
+  function v(e) {
+    let i = 0, r;
+    t: do {
+      r = !1;
+      const d = e.dep;
+      if ("flags" in d) {
+        const l = d.flags;
+        if ((l & 33) === 33) {
+          if (t(d)) {
+            const a = d.subs;
+            a.nextSub !== void 0 && c(a), r = !0;
+          }
+        } else if ((l & 65) === 65) {
+          const a = d.subs;
+          a.nextSub !== void 0 && (a.prevSub = e), e = d.deps, ++i;
+          continue;
+        }
+      }
+      if (!r && e.nextDep !== void 0) {
+        e = e.nextDep;
+        continue;
+      }
+      if (i) {
+        let l = e.sub;
+        do {
+          --i;
+          const a = l.subs;
+          if (r) {
+            if (t(l)) {
+              (e = a.prevSub) !== void 0 ? (a.prevSub = void 0, c(l.subs), l = e.sub) : l = a.sub;
+              continue;
+            }
+          } else
+            l.flags &= -65;
+          if ((e = a.prevSub) !== void 0) {
+            if (a.prevSub = void 0, e.nextDep !== void 0) {
+              e = e.nextDep;
+              continue t;
+            }
+            l = e.sub;
+          } else {
+            if ((e = a.nextDep) !== void 0)
+              continue t;
+            l = a.sub;
+          }
+          r = !1;
+        } while (i);
+      }
+      return r;
+    } while (!0);
+  }
+  function c(e) {
+    do {
+      const i = e.sub, r = i.flags;
+      (r & 96) === 64 && (i.flags = r | 32 | 8, (r & 10) === 2 && (s !== void 0 ? s.depsTail.nextDep = i.deps : n = i, s = i)), e = e.nextSub;
+    } while (e !== void 0);
+  }
+  function h(e, i) {
+    const r = i.depsTail;
+    if (r !== void 0) {
+      let d = i.deps;
+      do {
+        if (d === e)
+          return !0;
+        if (d === r)
+          break;
+        d = d.nextDep;
+      } while (d !== void 0);
+    }
+    return !1;
+  }
+  function T(e) {
+    do {
+      const i = e.dep, r = e.nextDep, d = e.nextSub, l = e.prevSub;
+      if (d !== void 0 ? d.prevSub = l : i.subsTail = l, l !== void 0 ? l.nextSub = d : i.subs = d, i.subs === void 0 && "deps" in i) {
+        const a = i.flags;
+        a & 32 || (i.flags = a | 32);
+        const g = i.deps;
+        if (g !== void 0) {
+          e = g, i.depsTail.nextDep = r, i.deps = void 0, i.depsTail = void 0;
+          continue;
+        }
+      }
+      e = r;
+    } while (e !== void 0);
+  }
+}
+var {
+  link: C,
+  propagate: N,
+  updateDirtyFlag: P,
+  startTracking: b,
+  endTracking: k,
+  processEffectNotifications: U,
+  processComputedUpdate: bt,
+  processPendingInnerEffects: _
+} = W({
+  updateComputed(t) {
+    const o = u;
+    u = t, b(t);
+    try {
+      const n = t.currentValue, s = t.getter(n);
+      return n !== s ? (t.currentValue = s, !0) : !1;
+    } finally {
+      u = o, k(t);
+    }
+  },
+  notifyEffect(t) {
+    return "isScope" in t ? H(t) : q(t);
+  }
+}), u;
+function j(t) {
+  return K.bind({
+    currentValue: t,
+    subs: void 0,
+    subsTail: void 0
+  });
+}
+function M(t) {
+  const o = {
+    fn: t,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: 2
+    /* Effect */
+  };
+  return u !== void 0 && C(o, u), z(o), O.bind(o);
+}
+function z(t) {
+  const o = u;
+  u = t, b(t);
+  try {
+    t.fn();
+  } finally {
+    u = o, k(t);
+  }
+}
+function q(t) {
+  const o = t.flags;
+  return o & 32 || o & 64 && P(t, o) ? z(t) : _(t, t.flags), !0;
+}
+function H(t) {
+  return t.flags & 128 ? (_(t, t.flags), !0) : !1;
+}
+function K(...t) {
+  if (t.length) {
+    if (this.currentValue !== (this.currentValue = t[0])) {
+      const o = this.subs;
+      o !== void 0 && (N(o), U());
+    }
+  } else
+    return u !== void 0 && C(this, u), this.currentValue;
+}
+function O() {
+  b(this), k(this);
+}
+function G(t) {
+  return j(t);
+}
+function V(t) {
+  return [y((o) => {
+    let n = M(() => {
+      t(), o();
+    });
+    return () => n();
+  }, () => t(), () => t()), (o) => {
+    t(typeof o == "function" ? o(t()) : o);
+  }];
+}
+const X = {
   "editor.remove": "Remove",
   "editor.copy": "Copy",
   "editor.words": "WORDS",
@@ -288,7 +628,7 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "editor.twitter.tooltip": "Twitter",
   "editor.tooltip.flipX": "Flip Horizontal",
   "editor.tooltip.flipY": "Flip Vertical"
-}, C = {
+}, $ = {
   "editor.remove": "Remover",
   "editor.copy": "Copiar",
   "editor.words": "PALAVRAS",
@@ -458,7 +798,7 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "editor.twitter.tooltip": "Twitter",
   "editor.tooltip.flipX": "Inverter Horizontal",
   "editor.tooltip.flipY": "Inverter Vertical"
-}, T = {
+}, Y = {
   "editor.remove": "Xóa",
   "editor.copy": "Sao chép",
   "editor.words": "TỪ",
@@ -628,7 +968,7 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "editor.twitter.tooltip": "Twitter",
   "editor.tooltip.flipX": "Lật Ngang",
   "editor.tooltip.flipY": "Lật Dọc"
-}, x = {
+}, J = {
   "editor.remove": "移除",
   "editor.copy": "复制",
   "editor.words": "字数",
@@ -798,7 +1138,7 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "editor.twitter.tooltip": "Twitter",
   "editor.tooltip.flipX": "水平翻转",
   "editor.tooltip.flipY": "垂直翻转"
-}, _ = {
+}, Q = {
   "editor.remove": "Eltávolítás",
   "editor.copy": "Másolás",
   "editor.words": "SZAVAK",
@@ -969,12 +1309,12 @@ const N = ["100%", "115%", "150%", "200%", "250%", "300%"], M = "1", H = [
   "editor.tooltip.flipX": "Vízszintes tükrözés",
   "editor.tooltip.flipY": "Függőleges tükrözés"
 };
-function v(e) {
-  return e = e || /* @__PURE__ */ new Map(), {
+function Z(t) {
+  return t = t || /* @__PURE__ */ new Map(), {
     /**
      * A Map of event names to registered handler functions.
      */
-    all: e,
+    all: t,
     /**
      * Register an event handler for the given type.
      * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
@@ -982,9 +1322,9 @@ function v(e) {
      * @memberOf mitt
      */
     //@ts-expect-error
-    on(t, o) {
-      const i = e.get(t);
-      i ? i.push(o) : e.set(t, [o]);
+    on(o, n) {
+      const s = t.get(o);
+      s ? s.push(n) : t.set(o, [n]);
     },
     /**
      * Remove an event handler for the given type.
@@ -994,9 +1334,9 @@ function v(e) {
      * @memberOf mitt
      */
     //@ts-expect-error
-    off(t, o) {
-      const i = e.get(t);
-      i && (o ? i.splice(i.indexOf(o) >>> 0, 1) : e.set(t, []));
+    off(o, n) {
+      const s = t.get(o);
+      s && (n ? s.splice(s.indexOf(n) >>> 0, 1) : t.set(o, []));
     },
     /**
      * Invoke all handlers for the given type.
@@ -1008,126 +1348,127 @@ function v(e) {
      * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
      * @memberOf mitt
      */
-    emit(t, o) {
-      let i = e.get(t);
-      i && [...i].map((r) => {
-        r(o);
-      }), i = e.get("*"), i && [...i].map((r) => {
-        r(t, o);
+    emit(o, n) {
+      let s = t.get(o);
+      s && [...s].map((p) => {
+        p(n);
+      }), s = t.get("*"), s && [...s].map((p) => {
+        p(o, n);
       });
     }
   };
 }
-const l = {
-  lang: h,
+const m = {
+  lang: w,
   message: {
-    en: F,
-    hu_HU: _,
-    vi: T,
-    zh_CN: x,
-    pt_BR: C
+    en: X,
+    hu_HU: Q,
+    vi: Y,
+    zh_CN: J,
+    pt_BR: $
   }
 };
-class z {
+class tt {
   constructor() {
-    a(this, "emitter");
-    this.emitter = v();
+    F(this, "emitter");
+    this.emitter = Z();
   }
   // Getter and setter for current language
   get lang() {
-    return l.lang;
+    return m.lang;
   }
-  set lang(t) {
-    if (!this.isLangSupported(t)) {
+  set lang(o) {
+    if (!this.isLangSupported(o)) {
       console.warn(
-        `Can't find the current language "${t}", Using language "${l.lang}" by default`
+        `Can't find the current language "${o}", Using language "${m.lang}" by default`
       );
       return;
     }
-    l.lang = t, this.emitter.emit("lang", t);
+    m.lang = o, this.emitter.emit("lang", o);
   }
   // Getter and setter for messages
   get message() {
-    return l.message;
+    return m.message;
   }
-  set message(t) {
-    l.message = t;
+  set message(o) {
+    m.message = o;
   }
   // Load messages for a specific language
-  loadLangMessage(t) {
-    return this.message[t];
+  loadLangMessage(o) {
+    return this.message[o];
   }
   // Check if a language is supported
-  isLangSupported(t) {
-    return Object.keys(this.message).includes(t);
+  isLangSupported(o) {
+    return Object.keys(this.message).includes(o);
   }
   // Set the current language
-  setLang(t) {
-    this.lang = t;
+  setLang(o) {
+    this.lang = o;
   }
   // Register a language change watcher
-  registerWatchLang(t) {
-    return this.emitter.on("lang", t), {
+  registerWatchLang(o) {
+    return this.emitter.on("lang", o), {
       unsubscribe: () => {
-        this.emitter.off("lang", t);
+        this.emitter.off("lang", o);
       }
     };
   }
   // Set messages for a specific language
-  setMessage(t, o) {
-    this.message[t] = o;
+  setMessage(o, n) {
+    this.message[o] = n;
   }
   // Build a translation function for a given language
-  buildLocalesHandler(t) {
-    t || (t = this.lang);
-    const o = this.loadLangMessage(t);
-    return function(r) {
-      return o[r] || r;
+  buildLocalesHandler(o) {
+    o || (o = this.lang);
+    const n = this.loadLangMessage(o);
+    return function(p) {
+      return n[p] || p;
     };
   }
 }
-const d = new z(), n = c(l.lang);
-function q() {
-  const [e, t] = u(n), o = m(() => d.buildLocalesHandler(e), [e]);
-  return g(() => {
-    const i = d.registerWatchLang((r) => {
-      t(r);
+const f = new tt(), A = G(m.lang);
+function kt() {
+  const [t, o] = V(A), n = E(() => f.buildLocalesHandler(t), [t]);
+  return L(() => {
+    const s = f.registerWatchLang((p) => {
+      o(p);
     });
     return () => {
-      i.unsubscribe();
+      s.unsubscribe();
     };
   }, []), {
-    lang: e,
-    t: o
+    lang: t,
+    t: n
   };
 }
-const K = {
-  t: (e) => d.buildLocalesHandler(n())(e)
+const vt = {
+  t: (t) => f.buildLocalesHandler(A())(t)
 };
 export {
-  H as B,
-  W as C,
-  U as D,
-  E,
-  S as I,
-  R as T,
-  k as V,
-  F as a,
-  _ as b,
-  T as c,
-  x as d,
-  C as e,
-  j as f,
-  P as g,
-  K as h,
-  M as i,
-  N as j,
-  B as k,
-  d as l,
-  I as m,
-  w as n,
-  L as o,
-  v as p,
-  f as q,
-  q as u
+  ft as B,
+  pt as C,
+  gt as D,
+  it as E,
+  lt as I,
+  nt as T,
+  I as V,
+  X as a,
+  Q as b,
+  Y as c,
+  J as d,
+  $ as e,
+  mt as f,
+  ut as g,
+  ht as h,
+  ct as i,
+  rt as j,
+  dt as k,
+  f as l,
+  vt as m,
+  Z as n,
+  at as o,
+  st as p,
+  R as q,
+  G as r,
+  kt as u
 };