laif-ds 0.2.85 → 0.2.86

package/dist/node_modules/@lexical/extension/dist/LexicalExtension.prod.js

@@ -0,0 +1,611 @@
+"use client";
+import { CLEAR_EDITOR_COMMAND as nt, COMMAND_PRIORITY_EDITOR as st, $getRoot as J, $getSelection as ot, $createParagraphNode as V, $isRangeSelection as rt, createEditor as at, mergeRegister as T, shallowMergeConfig as ct, $getEditor as dt, defineExtension as ht, RootNode as ft, TextNode as ut, LineBreakNode as lt, TabNode as gt, ParagraphNode as pt, safeCast as mt, $isEditorState as vt, HISTORY_MERGE_TAG as Et, $create as xt, DecoratorNode as yt, $getDocument as U, addClassNamesToElement as St } from "../../../lexical/dist/Lexical.prod.js";
+const bt = Symbol.for("preact-signals");
+function $() {
+  if (m > 1) return void m--;
+  let i, t = !1;
+  for (!(function() {
+    let e = C;
+    for (C = void 0; e !== void 0; ) e.S.v === e.v && (e.S.i = e.i), e = e.o;
+  })(); S !== void 0; ) {
+    let e = S;
+    for (S = void 0, D++; e !== void 0; ) {
+      const n = e.u;
+      if (e.u = void 0, e.f &= -3, !(8 & e.f) && Z(e)) try {
+        e.c();
+      } catch (o) {
+        t || (i = o, t = !0);
+      }
+      e = n;
+    }
+  }
+  if (D = 0, m--, t) throw i;
+}
+let a, S;
+function z(i) {
+  const t = a;
+  a = void 0;
+  try {
+    return i();
+  } finally {
+    a = t;
+  }
+}
+let C, m = 0, D = 0, L = 0, O = 0;
+function G(i) {
+  if (a === void 0) return;
+  let t = i.n;
+  return t === void 0 || t.t !== a ? (t = { i: 0, S: i, p: a.s, n: void 0, t: a, e: void 0, x: void 0, r: t }, a.s !== void 0 && (a.s.n = t), a.s = t, i.n = t, 32 & a.f && i.S(t), t) : t.i === -1 ? (t.i = 0, t.n !== void 0 && (t.n.p = t.p, t.p !== void 0 && (t.p.n = t.n), t.p = a.s, t.n = void 0, a.s.n = t, a.s = t), t) : void 0;
+}
+function f(i, t) {
+  this.v = i, this.i = 0, this.n = void 0, this.t = void 0, this.l = 0, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+function wt(i, t) {
+  return new f(i, t);
+}
+function Z(i) {
+  for (let t = i.s; t !== void 0; t = t.n) if (t.S.i !== t.i || !t.S.h() || t.S.i !== t.i) return !0;
+  return !1;
+}
+function K(i) {
+  for (let t = i.s; t !== void 0; t = t.n) {
+    const e = t.S.n;
+    if (e !== void 0 && (t.r = e), t.S.n = t, t.i = -1, t.n === void 0) {
+      i.s = t;
+      break;
+    }
+  }
+}
+function Q(i) {
+  let t, e = i.s;
+  for (; e !== void 0; ) {
+    const n = e.p;
+    e.i === -1 ? (e.S.U(e), n !== void 0 && (n.n = e.n), e.n !== void 0 && (e.n.p = n)) : t = e, e.S.n = e.r, e.r !== void 0 && (e.r = void 0), e = n;
+  }
+  i.s = t;
+}
+function v(i, t) {
+  f.call(this, void 0), this.x = i, this.s = void 0, this.g = O - 1, this.f = 4, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+function X(i) {
+  const t = i.m;
+  if (i.m = void 0, typeof t == "function") {
+    m++;
+    const e = a;
+    a = void 0;
+    try {
+      t();
+    } catch (n) {
+      throw i.f &= -2, i.f |= 8, A(i), n;
+    } finally {
+      a = e, $();
+    }
+  }
+}
+function A(i) {
+  for (let t = i.s; t !== void 0; t = t.n) t.S.U(t);
+  i.x = void 0, i.s = void 0, X(i);
+}
+function Nt(i) {
+  if (a !== this) throw new Error("Out-of-order effect");
+  Q(this), a = i, this.f &= -2, 8 & this.f && A(this), $();
+}
+function x(i, t) {
+  this.x = i, this.m = void 0, this.s = void 0, this.u = void 0, this.f = 32, this.name = t?.name;
+}
+function Rt(i, t) {
+  const e = new x(i, t);
+  try {
+    e.c();
+  } catch (o) {
+    throw e.d(), o;
+  }
+  const n = e.d.bind(e);
+  return n[Symbol.dispose] = n, n;
+}
+f.prototype.brand = bt, f.prototype.h = function() {
+  return !0;
+}, f.prototype.S = function(i) {
+  const t = this.t;
+  t !== i && i.e === void 0 && (i.x = t, this.t = i, t !== void 0 ? t.e = i : z(() => {
+    var e;
+    (e = this.W) == null || e.call(this);
+  }));
+}, f.prototype.U = function(i) {
+  if (this.t !== void 0) {
+    const t = i.e, e = i.x;
+    t !== void 0 && (t.x = e, i.e = void 0), e !== void 0 && (e.e = t, i.x = void 0), i === this.t && (this.t = e, e === void 0 && z(() => {
+      var n;
+      (n = this.Z) == null || n.call(this);
+    }));
+  }
+}, f.prototype.subscribe = function(i) {
+  return Rt(() => {
+    const t = this.value, e = a;
+    a = void 0;
+    try {
+      i(t);
+    } finally {
+      a = e;
+    }
+  }, { name: "sub" });
+}, f.prototype.valueOf = function() {
+  return this.value;
+}, f.prototype.toString = function() {
+  return this.value + "";
+}, f.prototype.toJSON = function() {
+  return this.value;
+}, f.prototype.peek = function() {
+  const i = a;
+  a = void 0;
+  try {
+    return this.value;
+  } finally {
+    a = i;
+  }
+}, Object.defineProperty(f.prototype, "value", { get() {
+  const i = G(this);
+  return i !== void 0 && (i.i = this.i), this.v;
+}, set(i) {
+  if (i !== this.v) {
+    if (D > 100) throw new Error("Cycle detected");
+    (function(t) {
+      m !== 0 && D === 0 && t.l !== L && (t.l = L, C = { S: t, v: t.v, i: t.i, o: C });
+    })(this), this.v = i, this.i++, O++, m++;
+    try {
+      for (let t = this.t; t !== void 0; t = t.x) t.t.N();
+    } finally {
+      $();
+    }
+  }
+} }), v.prototype = new f(), v.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === O)) return !0;
+  if (this.g = O, this.f |= 1, this.i > 0 && !Z(this)) return this.f &= -2, !0;
+  const i = a;
+  try {
+    K(this), a = this;
+    const t = this.x();
+    (16 & this.f || this.v !== t || this.i === 0) && (this.v = t, this.f &= -17, this.i++);
+  } catch (t) {
+    this.v = t, this.f |= 16, this.i++;
+  }
+  return a = i, Q(this), this.f &= -2, !0;
+}, v.prototype.S = function(i) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (let t = this.s; t !== void 0; t = t.n) t.S.S(t);
+  }
+  f.prototype.S.call(this, i);
+}, v.prototype.U = function(i) {
+  if (this.t !== void 0 && (f.prototype.U.call(this, i), this.t === void 0)) {
+    this.f &= -33;
+    for (let t = this.s; t !== void 0; t = t.n) t.S.U(t);
+  }
+}, v.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (let i = this.t; i !== void 0; i = i.x) i.t.N();
+  }
+}, Object.defineProperty(v.prototype, "value", { get() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  const i = G(this);
+  if (this.h(), i !== void 0 && (i.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} }), x.prototype.c = function() {
+  const i = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    const t = this.x();
+    typeof t == "function" && (this.m = t);
+  } finally {
+    i();
+  }
+}, x.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, X(this), K(this), m++;
+  const i = a;
+  return a = this, Nt.bind(this, i);
+}, x.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.u = S, S = this);
+}, x.prototype.d = function() {
+  this.f |= 8, 1 & this.f || A(this);
+}, x.prototype.dispose = function() {
+  this.d();
+};
+function Ot() {
+  const i = J(), t = ot(), e = V();
+  i.clear(), i.append(e), t !== null && e.select(), rt(t) && (t.format = 0);
+}
+function Ut(i, t = Ot) {
+  return i.registerCommand(nt, (e) => (i.update(t), !0), st);
+}
+function Ct(i) {
+  return (typeof i.nodes == "function" ? i.nodes() : i.nodes) || [];
+}
+function zt(i, t) {
+  let e;
+  return wt(i(), { unwatched() {
+    e && (e(), e = void 0);
+  }, watched() {
+    this.value = i(), e = t(this);
+  } });
+}
+function d(i, ...t) {
+  const e = new URL("https://lexical.dev/docs/error"), n = new URLSearchParams();
+  n.append("code", i);
+  for (const o of t) n.append("v", o);
+  throw e.search = n.toString(), Error(`Minified Lexical error #${i}; visit ${e.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
+}
+let Y;
+try {
+  Y = "0.47.0+prod.esm";
+} catch {
+}
+const Dt = Y ?? '"<unknown>+source"', Mt = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function q(i, t) {
+  if (i && t && !Array.isArray(t) && typeof i == "object" && typeof t == "object") {
+    const e = i, n = t;
+    for (const o in n) !Mt.has(o) && Object.prototype.hasOwnProperty.call(n, o) && (e[o] = q(e[o], n[o]));
+    return i;
+  }
+  return t;
+}
+const k = 0, j = 1, tt = 2, M = 3, N = 4, E = 5, _ = 6, y = 7;
+function I(i) {
+  return i.id === k;
+}
+function et(i) {
+  return i.id === tt;
+}
+function _t(i) {
+  return (function(t) {
+    return t.id === j;
+  })(i) || d(305, String(i.id), String(j)), Object.assign(i, { id: tt });
+}
+const It = /* @__PURE__ */ new Set();
+class Pt {
+  builder;
+  configs;
+  _dependency;
+  _peerNameSet;
+  extension;
+  state;
+  _signal;
+  constructor(t, e) {
+    this.builder = t, this.extension = e, this.configs = /* @__PURE__ */ new Set(), this.state = { id: k };
+  }
+  mergeConfigs() {
+    let t = this.extension.config || {};
+    const e = this.extension.mergeConfig ? this.extension.mergeConfig.bind(this.extension) : ct;
+    for (const n of this.configs) t = e(t, n);
+    return t;
+  }
+  init(t) {
+    const e = this.state;
+    et(e) || d(306, String(e.id));
+    const n = { getDependency: this.getInitDependency.bind(this), getDirectDependentNames: this.getDirectDependentNames.bind(this), getPeer: this.getInitPeer.bind(this), getPeerNameSet: this.getPeerNameSet.bind(this) }, o = { ...n, getDependency: this.getDependency.bind(this), getInitResult: this.getInitResult.bind(this), getPeer: this.getPeer.bind(this) }, s = (function(c, u, l) {
+      return Object.assign(c, { config: u, id: M, registerState: l });
+    })(e, this.mergeConfigs(), n);
+    let r;
+    this.state = s, this.extension.init && (r = this.extension.init(t, s.config, n)), this.state = (function(c, u, l) {
+      return Object.assign(c, { id: N, initResult: u, registerState: l });
+    })(s, r, o);
+  }
+  build(t) {
+    const e = this.state;
+    let n;
+    e.id !== N && d(307, String(e.id), String(E)), this.extension.build && (n = this.extension.build(t, e.config, e.registerState));
+    const o = { ...e.registerState, getOutput: () => n, getSignal: this.getSignal.bind(this) };
+    this.state = (function(s, r, c) {
+      return Object.assign(s, { id: E, output: r, registerState: c });
+    })(e, n, o);
+  }
+  register(t, e) {
+    this._signal = e;
+    const n = this.state;
+    n.id !== E && d(308, String(n.id), String(E));
+    const o = this.extension.register && this.extension.register(t, n.config, n.registerState);
+    return this.state = (function(s) {
+      return Object.assign(s, { id: _ });
+    })(n), () => {
+      const s = this.state;
+      s.id !== y && d(309, String(n.id), String(y)), this.state = (function(r) {
+        return Object.assign(r, { id: E });
+      })(s), o && o();
+    };
+  }
+  afterRegistration(t) {
+    const e = this.state;
+    let n;
+    return e.id !== _ && d(310, String(e.id), String(_)), this.extension.afterRegistration && (n = this.extension.afterRegistration(t, e.config, e.registerState)), this.state = (function(o) {
+      return Object.assign(o, { id: y });
+    })(e), n;
+  }
+  getSignal() {
+    return this._signal === void 0 && d(311), this._signal;
+  }
+  getInitResult() {
+    this.extension.init === void 0 && d(312, this.extension.name);
+    const t = this.state;
+    return (function(e) {
+      return e.id >= N;
+    })(t) || d(313, String(t.id), String(N)), t.initResult;
+  }
+  getInitPeer(t) {
+    const e = this.builder.extensionNameMap.get(t);
+    return e ? e.getExtensionInitDependency() : void 0;
+  }
+  getExtensionInitDependency() {
+    const t = this.state;
+    return (function(e) {
+      return e.id >= M;
+    })(t) || d(314, String(t.id), String(M)), { config: t.config };
+  }
+  getPeer(t) {
+    const e = this.builder.extensionNameMap.get(t);
+    return e ? e.getExtensionDependency() : void 0;
+  }
+  getInitDependency(t) {
+    const e = this.builder.getExtensionRep(t);
+    return e === void 0 && d(315, this.extension.name, t.name), e.getExtensionInitDependency();
+  }
+  getDependency(t) {
+    const e = this.builder.getExtensionRep(t);
+    return e === void 0 && d(315, this.extension.name, t.name), e.getExtensionDependency();
+  }
+  getState() {
+    const t = this.state;
+    return (function(e) {
+      return e.id >= y;
+    })(t) || d(316, String(t.id), String(y)), t;
+  }
+  getDirectDependentNames() {
+    return this.builder.incomingEdges.get(this.extension.name) || It;
+  }
+  getPeerNameSet() {
+    let t = this._peerNameSet;
+    return t || (t = new Set((this.extension.peerDependencies || []).map(([e]) => e)), this._peerNameSet = t), t;
+  }
+  getExtensionDependency() {
+    if (!this._dependency) {
+      const t = this.state;
+      (function(e) {
+        return e.id >= E;
+      })(t) || d(317, this.extension.name), this._dependency = { config: t.config, init: t.initResult, output: t.output };
+    }
+    return this._dependency;
+  }
+}
+const B = { tag: Et };
+function jt() {
+  const i = J();
+  i.isEmpty() && i.append(V());
+}
+const $t = /* @__PURE__ */ ht({ config: /* @__PURE__ */ mt({ setOptions: B, updateOptions: B }), init: ({ $initialEditorState: i = jt }) => ({ $initialEditorState: i, initialized: !1 }), afterRegistration(i, { updateOptions: t, setOptions: e }, n) {
+  const o = n.getInitResult();
+  if (!o.initialized) {
+    o.initialized = !0;
+    const { $initialEditorState: s } = o;
+    if (vt(s)) i.setEditorState(s, e);
+    else if (typeof s == "function") i.update(() => {
+      s(i);
+    }, t);
+    else if (s && (typeof s == "string" || typeof s == "object")) {
+      const r = i.parseEditorState(s);
+      i.setEditorState(r, e);
+    }
+  }
+  return () => {
+  };
+}, name: "@lexical/extension/InitialState", nodes: [ft, ut, lt, gt, pt] }), F = Symbol.for("@lexical/extension/LexicalBuilder");
+function H() {
+}
+function At(i) {
+  throw i;
+}
+function R(i) {
+  return Array.isArray(i) ? i : [i];
+}
+const P = Dt;
+class b {
+  roots;
+  extensionNameMap;
+  outgoingConfigEdges;
+  incomingEdges;
+  conflicts;
+  _sortedExtensionReps;
+  PACKAGE_VERSION;
+  constructor(t) {
+    this.outgoingConfigEdges = /* @__PURE__ */ new Map(), this.incomingEdges = /* @__PURE__ */ new Map(), this.extensionNameMap = /* @__PURE__ */ new Map(), this.conflicts = /* @__PURE__ */ new Map(), this.PACKAGE_VERSION = P, this.roots = t;
+    for (const e of t) this.addExtension(e);
+  }
+  static fromExtensions(t) {
+    const e = [R($t)];
+    for (const n of t) e.push(R(n));
+    return new b(e);
+  }
+  static maybeFromEditor(t) {
+    const e = t[F];
+    return e && (e.PACKAGE_VERSION !== P && d(292, e.PACKAGE_VERSION, P), e instanceof b || d(293)), e;
+  }
+  static fromEditor(t) {
+    const e = b.maybeFromEditor(t);
+    return e === void 0 && d(294), e;
+  }
+  constructEditor() {
+    const { $initialEditorState: t, onError: e, onWarn: n, ...o } = this.buildCreateEditorArgs(), s = Object.assign(at({ ...o, ...e ? { onError: (r) => {
+      e(r, s);
+    } } : {}, ...n ? { onWarn: (r) => {
+      n(r, s);
+    } } : {} }), { [F]: this });
+    for (const r of this.sortedExtensionReps()) r.build(s);
+    return s;
+  }
+  buildEditor() {
+    let t = H;
+    function e() {
+      try {
+        t();
+      } finally {
+        t = H;
+      }
+    }
+    const n = Object.assign(this.constructEditor(), { dispose: e, [Symbol.dispose]: e });
+    return t = T(this.registerEditor(n), () => n.setRootElement(null)), n;
+  }
+  hasExtensionByName(t) {
+    return this.extensionNameMap.has(t);
+  }
+  getExtensionRep(t) {
+    const e = this.extensionNameMap.get(t.name);
+    if (e) return e.extension !== t && d(295, t.name), e;
+  }
+  addEdge(t, e, n) {
+    const o = this.outgoingConfigEdges.get(t);
+    o ? o.set(e, n) : this.outgoingConfigEdges.set(t, /* @__PURE__ */ new Map([[e, n]]));
+    const s = this.incomingEdges.get(e);
+    s ? s.add(t) : this.incomingEdges.set(e, /* @__PURE__ */ new Set([t]));
+  }
+  addExtension(t) {
+    this._sortedExtensionReps !== void 0 && d(296);
+    const e = R(t), [n] = e;
+    typeof n.name != "string" && d(297, typeof n.name);
+    let o = this.extensionNameMap.get(n.name);
+    if (o !== void 0 && o.extension !== n && d(298, n.name), !o) {
+      o = new Pt(this, n), this.extensionNameMap.set(n.name, o);
+      const s = this.conflicts.get(n.name);
+      typeof s == "string" && d(299, n.name, s);
+      for (const r of n.conflictsWith || []) this.extensionNameMap.has(r) && d(299, n.name, r), this.conflicts.set(r, n.name);
+      for (const r of n.dependencies || []) {
+        const c = R(r);
+        this.addEdge(n.name, c[0].name, c.slice(1)), this.addExtension(c);
+      }
+      for (const [r, c] of n.peerDependencies || []) this.addEdge(n.name, r, c ? [c] : []);
+    }
+  }
+  sortedExtensionReps() {
+    if (this._sortedExtensionReps) return this._sortedExtensionReps;
+    const t = [], e = (n, o) => {
+      let s = n.state;
+      if (et(s)) return;
+      const r = n.extension.name;
+      var c;
+      I(s) || d(300, r, o || "[unknown]"), I(c = s) || d(304, String(c.id), String(k)), s = Object.assign(c, { id: j }), n.state = s;
+      const u = this.outgoingConfigEdges.get(r);
+      if (u) for (const l of u.keys()) {
+        const g = this.extensionNameMap.get(l);
+        g && e(g, r);
+      }
+      s = _t(s), n.state = s, t.push(n);
+    };
+    for (const n of this.extensionNameMap.values()) I(n.state) && e(n);
+    for (const n of t) for (const [o, s] of this.outgoingConfigEdges.get(n.extension.name) || []) if (s.length > 0) {
+      const r = this.extensionNameMap.get(o);
+      if (r) for (const c of s) r.configs.add(c);
+    }
+    for (const [n, ...o] of this.roots) if (o.length > 0) {
+      const s = this.extensionNameMap.get(n.name);
+      s === void 0 && d(301, n.name);
+      for (const r of o) s.configs.add(r);
+    }
+    return this._sortedExtensionReps = t, this._sortedExtensionReps;
+  }
+  registerEditor(t) {
+    const e = this.sortedExtensionReps(), n = new AbortController(), o = [() => n.abort()], s = n.signal;
+    for (const r of e) {
+      const c = r.register(t, s);
+      c && o.push(c);
+    }
+    for (const r of e) {
+      const c = r.afterRegistration(t);
+      c && o.push(c);
+    }
+    return T(...o);
+  }
+  buildCreateEditorArgs() {
+    const t = {}, e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = {}, r = {}, c = this.sortedExtensionReps();
+    for (const g of c) {
+      const { extension: h } = g;
+      if (h.onError !== void 0 && (t.onError = h.onError), h.onWarn !== void 0 && (t.onWarn = h.onWarn), h.disableEvents !== void 0 && (t.disableEvents = h.disableEvents), h.parentEditor !== void 0 && (t.parentEditor = h.parentEditor), h.editable !== void 0 && (t.editable = h.editable), h.namespace !== void 0 && (t.namespace = h.namespace), h.$initialEditorState !== void 0 && (t.$initialEditorState = h.$initialEditorState), h.nodes) for (const p of Ct(h)) {
+        if (typeof p != "function") {
+          const w = n.get(p.replace);
+          w && d(302, h.name, p.replace.name, w.extension.name), n.set(p.replace, g);
+        }
+        e.add(p);
+      }
+      if (h.html) {
+        if (h.html.export) for (const [p, w] of h.html.export.entries()) o.set(p, w);
+        h.html.import && Object.assign(s, h.html.import);
+      }
+      h.theme && q(r, h.theme);
+    }
+    Object.keys(r).length > 0 && (t.theme = r), e.size && (t.nodes = [...e]);
+    const u = Object.keys(s).length > 0, l = o.size > 0;
+    (u || l) && (t.html = {}, u && (t.html.import = s), l && (t.html.export = o));
+    for (const g of c) g.init(t);
+    return t.onError || (t.onError = At), t;
+  }
+}
+function kt(i, t) {
+  const e = b.maybeFromEditor(i);
+  if (!e) return;
+  const n = e.extensionNameMap.get(t);
+  return n ? n.getExtensionDependency() : void 0;
+}
+function Lt(i) {
+  return kt(dt(), i);
+}
+class W extends yt {
+  static getType() {
+    return "horizontalrule";
+  }
+  static clone(t) {
+    return new W(t.__key);
+  }
+  static importJSON(t) {
+    return it().updateFromJSON(t);
+  }
+  static importDOM() {
+    return { hr: () => ({ conversion: Wt, priority: 0 }) };
+  }
+  exportDOM() {
+    return { element: U().createElement("hr") };
+  }
+  createDOM(t) {
+    const e = U().createElement("hr");
+    return St(e, t.theme.hr), e;
+  }
+  getTextContent() {
+    return `
+`;
+  }
+  isInline() {
+    return !1;
+  }
+  updateDOM() {
+    return !1;
+  }
+}
+function Wt() {
+  return { node: it() };
+}
+function it() {
+  return xt(W);
+}
+export {
+  it as $createHorizontalRuleNode,
+  Lt as $getPeerDependency,
+  W as HorizontalRuleNode,
+  $t as InitialStateExtension,
+  b as LexicalBuilder,
+  ht as defineExtension,
+  Rt as effect,
+  kt as getPeerDependencyFromEditor,
+  Ut as registerClearEditor,
+  mt as safeCast,
+  ct as shallowMergeConfig,
+  wt as signal,
+  z as untracked,
+  zt as watchedSignal
+};

package/dist/node_modules/@lexical/history/dist/LexicalHistory.prod.js

@@ -0,0 +1,96 @@
+"use client";
+import { mergeRegister as P, CAN_REDO_COMMAND as k, CAN_UNDO_COMMAND as E, CLEAR_HISTORY_COMMAND as U, COMMAND_PRIORITY_EDITOR as R, CLEAR_EDITOR_COMMAND as v, REDO_COMMAND as w, HISTORIC_TAG as z, UNDO_COMMAND as J, COMPOSITION_START_TAG as L, COMPOSITION_END_TAG as Y, PASTE_TAG as b, CUT_TAG as $, HISTORY_PUSH_TAG as Q, HISTORY_MERGE_TAG as X, $isRangeSelection as D, $isTextNode as N, $isRootNode as Z } from "../../../lexical/dist/Lexical.prod.js";
+function j(t, o, C, l, p) {
+  if (t === null || C.size === 0 && l.size === 0 && !p) return 0;
+  const i = o._selection, h = t._selection;
+  if (p) return 1;
+  if (!(D(i) && D(h) && h.isCollapsed() && i.isCollapsed())) return 0;
+  const s = (function(_, m, A) {
+    const T = _._nodeMap, y = [];
+    for (const O of m) {
+      const S = T.get(O);
+      S !== void 0 && y.push(S);
+    }
+    for (const [O, S] of A) {
+      if (!S) continue;
+      const M = T.get(O);
+      M === void 0 || Z(M) || y.push(M);
+    }
+    return y;
+  })(o, C, l);
+  if (s.length === 0) return 0;
+  if (s.length > 1) {
+    const _ = o._nodeMap, m = _.get(i.anchor.key), A = _.get(h.anchor.key);
+    return m && A && !t._nodeMap.has(m.__key) && N(m) && m.__text.length === 1 && i.anchor.offset === 1 ? 2 : 0;
+  }
+  const e = s[0], d = t._nodeMap.get(e.__key);
+  if (!N(d) || !N(e) || d.__mode !== e.__mode) return 0;
+  const u = d.__text, a = e.__text;
+  if (u === a) return 0;
+  const r = i.anchor, n = h.anchor;
+  if (r.key !== n.key || r.type !== "text") return 0;
+  const c = r.offset, f = n.offset, g = a.length - u.length;
+  return g === 1 && f === c - 1 ? 2 : g === -1 && f === c + 1 ? 3 : g === -1 && f === c ? 4 : 0;
+}
+function q(t, o, C) {
+  let l = C(), p = 0, i = l, h = 0, s = null;
+  return (e, d, u, a, r, n) => {
+    const c = C();
+    if (n.has(L) && (i = l, h = p, s = e), n.has(z)) return p = 0, l = c, 2;
+    n.has(Y) && s && (l = i, p = h, e = s);
+    const f = n.has(b) || n.has($) ? 0 : j(e, d, a, r, t.isComposing()), g = (() => {
+      const _ = u === null || u.editor === t, m = n.has(Q);
+      if (!m && _ && n.has(X)) return 0;
+      if (f === 1) return 2;
+      if (e === null) return 1;
+      const A = d._selection;
+      if (!(a.size > 0 || r.size > 0)) return A !== null ? 0 : 2;
+      const T = typeof o == "number" ? o : o.peek();
+      return m === !1 && f !== 0 && f === p && c < l + T && _ || a.size === 1 && (function(y, O, S) {
+        const M = O._nodeMap.get(y), I = S._nodeMap.get(y), x = O._selection, G = S._selection;
+        return !(D(x) && D(G) && x.anchor.type === "element" && x.focus.type === "element" && G.anchor.type === "text" && G.focus.type === "text" || !N(M) || !N(I) || M.__parent !== I.__parent) && JSON.stringify(O.read(() => M.exportJSON())) === JSON.stringify(S.read(() => I.exportJSON()));
+      })(Array.from(a)[0], e, d) ? 0 : 1;
+    })();
+    return l = c, p = f, g;
+  };
+}
+function H(t, o) {
+  t.undoStack = [], t.redoStack = [], t.current = null;
+}
+function F(t, o, C, l = Date.now, p, i = null) {
+  const h = q(t, C, l);
+  return P(t.registerCommand(J, () => ((function(s, e, d) {
+    const u = e.redoStack, a = e.undoStack;
+    if (a.length !== 0) {
+      const r = e.current, n = a.pop();
+      r !== null && (u.push(r), s.dispatchCommand(k, !0)), a.length === 0 && s.dispatchCommand(E, !1), e.current = n || null, n && n.editor.setEditorState(n.editorState, { tag: z });
+    }
+  })(t, o), !0), R), t.registerCommand(w, () => ((function(s, e, d) {
+    const u = e.redoStack, a = e.undoStack;
+    if (u.length !== 0) {
+      const r = e.current;
+      r !== null && (a.push(r), s.dispatchCommand(E, !0));
+      const n = u.pop();
+      u.length === 0 && s.dispatchCommand(k, !1), e.current = n || null, n && n.editor.setEditorState(n.editorState, { tag: z });
+    }
+  })(t, o), !0), R), t.registerCommand(v, () => (H(o), !1), R), t.registerCommand(U, () => (H(o), t.dispatchCommand(k, !1), t.dispatchCommand(E, !1), !0), R), t.registerUpdateListener(({ editorState: s, prevEditorState: e, dirtyLeaves: d, dirtyElements: u, tags: a }) => {
+    const r = o.current, n = o.redoStack, c = o.undoStack, f = r === null ? null : r.editorState;
+    if (r !== null && s === f) return;
+    const g = h(e, s, r, d, u, a);
+    if (g === 1) {
+      if (n.length !== 0 && (o.redoStack = [], t.dispatchCommand(k, !1)), r !== null) {
+        c.push({ ...r });
+        const _ = typeof i == "number" || i === null ? i : i.peek();
+        _ !== null && c.length > _ && c.splice(0, c.length - _), t.dispatchCommand(E, !0);
+      }
+    } else if (g === 2) return;
+    o.current = { editor: t, editorState: s };
+  }));
+}
+function K() {
+  return { current: null, redoStack: [], undoStack: [] };
+}
+export {
+  K as createEmptyHistoryState,
+  F as registerHistory
+};