1135 lines
36 KiB
JavaScript
1135 lines
36 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 2a4e4dccbc3fdacb.bc4b655d5c.js
|
|
* Module id: 616777
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
e.i(23741);
|
|
var t = e.i(358379),
|
|
n = e.i(111558),
|
|
r = e.i(536379),
|
|
i = e.i(462214),
|
|
o = e.i(673654);
|
|
let { getOwnPropertyNames: s, getOwnPropertySymbols: l } = Object,
|
|
{ hasOwnProperty: a } = Object.prototype;
|
|
function d(e, t) {
|
|
return function (n, r, i) {
|
|
return e(n, r, i) && t(n, r, i);
|
|
};
|
|
}
|
|
function c(e) {
|
|
return function (t, n, r) {
|
|
if (!t || !n || "object" != typeof t || "object" != typeof n)
|
|
return e(t, n, r);
|
|
let { cache: i } = r,
|
|
o = i.get(t),
|
|
s = i.get(n);
|
|
if (o && s) return o === n && s === t;
|
|
i.set(t, n), i.set(n, t);
|
|
let l = e(t, n, r);
|
|
return i.delete(t), i.delete(n), l;
|
|
};
|
|
}
|
|
function h(e) {
|
|
return s(e).concat(l(e));
|
|
}
|
|
let p = Object.hasOwn || ((e, t) => a.call(e, t));
|
|
function u(e, t) {
|
|
return e === t || (!e && !t && e != e && t != t);
|
|
}
|
|
let { getOwnPropertyDescriptor: f, keys: m } = Object;
|
|
function g(e, t) {
|
|
return (
|
|
e.byteLength === t.byteLength && E(new Uint8Array(e), new Uint8Array(t))
|
|
);
|
|
}
|
|
function y(e, t, n) {
|
|
let r = e.length;
|
|
if (t.length !== r) return !1;
|
|
for (; r-- > 0; ) if (!n.equals(e[r], t[r], r, r, e, t, n)) return !1;
|
|
return !0;
|
|
}
|
|
function b(e, t) {
|
|
return (
|
|
e.byteLength === t.byteLength &&
|
|
E(
|
|
new Uint8Array(e.buffer, e.byteOffset, e.byteLength),
|
|
new Uint8Array(t.buffer, t.byteOffset, t.byteLength),
|
|
)
|
|
);
|
|
}
|
|
function k(e, t) {
|
|
return u(e.getTime(), t.getTime());
|
|
}
|
|
function v(e, t) {
|
|
return (
|
|
e.name === t.name &&
|
|
e.message === t.message &&
|
|
e.cause === t.cause &&
|
|
e.stack === t.stack
|
|
);
|
|
}
|
|
function w(e, t) {
|
|
return e === t;
|
|
}
|
|
function S(e, t, n) {
|
|
let r,
|
|
i,
|
|
o = e.size;
|
|
if (o !== t.size) return !1;
|
|
if (!o) return !0;
|
|
let s = Array(o),
|
|
l = e.entries(),
|
|
a = 0;
|
|
for (; (r = l.next()) && !r.done; ) {
|
|
let o = t.entries(),
|
|
l = !1,
|
|
d = 0;
|
|
for (; (i = o.next()) && !i.done; ) {
|
|
if (s[d]) {
|
|
d++;
|
|
continue;
|
|
}
|
|
let o = r.value,
|
|
c = i.value;
|
|
if (
|
|
n.equals(o[0], c[0], a, d, e, t, n) &&
|
|
n.equals(o[1], c[1], o[0], c[0], e, t, n)
|
|
) {
|
|
l = s[d] = !0;
|
|
break;
|
|
}
|
|
d++;
|
|
}
|
|
if (!l) return !1;
|
|
a++;
|
|
}
|
|
return !0;
|
|
}
|
|
function x(e, t, n) {
|
|
let r = m(e),
|
|
i = r.length;
|
|
if (m(t).length !== i) return !1;
|
|
for (; i-- > 0; ) if (!A(e, t, n, r[i])) return !1;
|
|
return !0;
|
|
}
|
|
function M(e, t, n) {
|
|
let r,
|
|
i,
|
|
o,
|
|
s = h(e),
|
|
l = s.length;
|
|
if (h(t).length !== l) return !1;
|
|
for (; l-- > 0; )
|
|
if (
|
|
!A(e, t, n, (r = s[l])) ||
|
|
((i = f(e, r)),
|
|
(o = f(t, r)),
|
|
(i || o) &&
|
|
(!i ||
|
|
!o ||
|
|
i.configurable !== o.configurable ||
|
|
i.enumerable !== o.enumerable ||
|
|
i.writable !== o.writable))
|
|
)
|
|
return !1;
|
|
return !0;
|
|
}
|
|
function C(e, t) {
|
|
return u(e.valueOf(), t.valueOf());
|
|
}
|
|
function T(e, t) {
|
|
return e.source === t.source && e.flags === t.flags;
|
|
}
|
|
function N(e, t, n) {
|
|
let r,
|
|
i,
|
|
o = e.size;
|
|
if (o !== t.size) return !1;
|
|
if (!o) return !0;
|
|
let s = Array(o),
|
|
l = e.values();
|
|
for (; (r = l.next()) && !r.done; ) {
|
|
let o = t.values(),
|
|
l = !1,
|
|
a = 0;
|
|
for (; (i = o.next()) && !i.done; ) {
|
|
if (!s[a] && n.equals(r.value, i.value, r.value, i.value, e, t, n)) {
|
|
l = s[a] = !0;
|
|
break;
|
|
}
|
|
a++;
|
|
}
|
|
if (!l) return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
function E(e, t) {
|
|
let n = e.byteLength;
|
|
if (t.byteLength !== n || e.byteOffset !== t.byteOffset) return !1;
|
|
for (; n-- > 0; ) if (e[n] !== t[n]) return !1;
|
|
return !0;
|
|
}
|
|
function O(e, t) {
|
|
return (
|
|
e.hostname === t.hostname &&
|
|
e.pathname === t.pathname &&
|
|
e.protocol === t.protocol &&
|
|
e.port === t.port &&
|
|
e.hash === t.hash &&
|
|
e.username === t.username &&
|
|
e.password === t.password
|
|
);
|
|
}
|
|
function A(e, t, n, r) {
|
|
return (
|
|
(("_owner" === r || "__o" === r || "__v" === r) &&
|
|
(!!e.$$typeof || !!t.$$typeof)) ||
|
|
(p(t, r) && n.equals(e[r], t[r], r, r, e, t, n))
|
|
);
|
|
}
|
|
let D = {
|
|
"[object Int8Array]": !0,
|
|
"[object Uint8Array]": !0,
|
|
"[object Uint8ClampedArray]": !0,
|
|
"[object Int16Array]": !0,
|
|
"[object Uint16Array]": !0,
|
|
"[object Int32Array]": !0,
|
|
"[object Uint32Array]": !0,
|
|
"[object Float16Array]": !0,
|
|
"[object Float32Array]": !0,
|
|
"[object Float64Array]": !0,
|
|
"[object BigInt64Array]": !0,
|
|
"[object BigUint64Array]": !0,
|
|
},
|
|
R = Object.prototype.toString,
|
|
I = P();
|
|
function P(e = {}) {
|
|
let {
|
|
circular: t = !1,
|
|
createInternalComparator: n,
|
|
createState: r,
|
|
strict: i = !1,
|
|
} = e,
|
|
o = (function ({
|
|
areArrayBuffersEqual: e,
|
|
areArraysEqual: t,
|
|
areDataViewsEqual: n,
|
|
areDatesEqual: r,
|
|
areErrorsEqual: i,
|
|
areFunctionsEqual: o,
|
|
areMapsEqual: s,
|
|
areNumbersEqual: l,
|
|
areObjectsEqual: a,
|
|
arePrimitiveWrappersEqual: d,
|
|
areRegExpsEqual: c,
|
|
areSetsEqual: h,
|
|
areTypedArraysEqual: p,
|
|
areUrlsEqual: u,
|
|
unknownTagComparators: f,
|
|
}) {
|
|
return function (m, g, y) {
|
|
if (m === g) return !0;
|
|
if (null == m || null == g) return !1;
|
|
let b = typeof m;
|
|
if (b !== typeof g) return !1;
|
|
if ("object" !== b)
|
|
return "number" === b
|
|
? l(m, g, y)
|
|
: "function" === b && o(m, g, y);
|
|
let k = m.constructor;
|
|
if (k !== g.constructor) return !1;
|
|
if (k === Object) return a(m, g, y);
|
|
if (Array.isArray(m)) return t(m, g, y);
|
|
if (k === Date) return r(m, g, y);
|
|
if (k === RegExp) return c(m, g, y);
|
|
if (k === Map) return s(m, g, y);
|
|
if (k === Set) return h(m, g, y);
|
|
let v = R.call(m);
|
|
if ("[object Date]" === v) return r(m, g, y);
|
|
if ("[object RegExp]" === v) return c(m, g, y);
|
|
if ("[object Map]" === v) return s(m, g, y);
|
|
if ("[object Set]" === v) return h(m, g, y);
|
|
if ("[object Object]" === v)
|
|
return (
|
|
"function" != typeof m.then &&
|
|
"function" != typeof g.then &&
|
|
a(m, g, y)
|
|
);
|
|
if ("[object URL]" === v) return u(m, g, y);
|
|
if ("[object Error]" === v) return i(m, g, y);
|
|
if ("[object Arguments]" === v) return a(m, g, y);
|
|
if (D[v]) return p(m, g, y);
|
|
if ("[object ArrayBuffer]" === v) return e(m, g, y);
|
|
if ("[object DataView]" === v) return n(m, g, y);
|
|
if (
|
|
"[object Boolean]" === v ||
|
|
"[object Number]" === v ||
|
|
"[object String]" === v
|
|
)
|
|
return d(m, g, y);
|
|
if (f) {
|
|
let e = f[v];
|
|
if (!e) {
|
|
let t = null != m ? m[Symbol.toStringTag] : void 0;
|
|
t && (e = f[t]);
|
|
}
|
|
if (e) return e(m, g, y);
|
|
}
|
|
return !1;
|
|
};
|
|
})(
|
|
(function ({ circular: e, createCustomConfig: t, strict: n }) {
|
|
let r = {
|
|
areArrayBuffersEqual: g,
|
|
areArraysEqual: n ? M : y,
|
|
areDataViewsEqual: b,
|
|
areDatesEqual: k,
|
|
areErrorsEqual: v,
|
|
areFunctionsEqual: w,
|
|
areMapsEqual: n ? d(S, M) : S,
|
|
areNumbersEqual: u,
|
|
areObjectsEqual: n ? M : x,
|
|
arePrimitiveWrappersEqual: C,
|
|
areRegExpsEqual: T,
|
|
areSetsEqual: n ? d(N, M) : N,
|
|
areTypedArraysEqual: n ? d(E, M) : E,
|
|
areUrlsEqual: O,
|
|
unknownTagComparators: void 0,
|
|
};
|
|
if ((t && (r = Object.assign({}, r, t(r))), e)) {
|
|
let e = c(r.areArraysEqual),
|
|
t = c(r.areMapsEqual),
|
|
n = c(r.areObjectsEqual),
|
|
i = c(r.areSetsEqual);
|
|
r = Object.assign({}, r, {
|
|
areArraysEqual: e,
|
|
areMapsEqual: t,
|
|
areObjectsEqual: n,
|
|
areSetsEqual: i,
|
|
});
|
|
}
|
|
return r;
|
|
})(e),
|
|
),
|
|
s = n
|
|
? n(o)
|
|
: function (e, t, n, r, i, s, l) {
|
|
return o(e, t, l);
|
|
};
|
|
return (function ({
|
|
circular: e,
|
|
comparator: t,
|
|
createState: n,
|
|
equals: r,
|
|
strict: i,
|
|
}) {
|
|
if (n)
|
|
return function (o, s) {
|
|
let { cache: l = e ? new WeakMap() : void 0, meta: a } = n();
|
|
return t(o, s, { cache: l, equals: r, meta: a, strict: i });
|
|
};
|
|
if (e)
|
|
return function (e, n) {
|
|
return t(e, n, {
|
|
cache: new WeakMap(),
|
|
equals: r,
|
|
meta: void 0,
|
|
strict: i,
|
|
});
|
|
};
|
|
let o = { cache: void 0, equals: r, meta: void 0, strict: i };
|
|
return function (e, n) {
|
|
return t(e, n, o);
|
|
};
|
|
})({ circular: t, comparator: o, createState: r, equals: s, strict: i });
|
|
}
|
|
P({ strict: !0 }),
|
|
P({ circular: !0 }),
|
|
P({ circular: !0, strict: !0 }),
|
|
P({ createInternalComparator: () => u }),
|
|
P({ strict: !0, createInternalComparator: () => u }),
|
|
P({ circular: !0, createInternalComparator: () => u }),
|
|
P({ circular: !0, createInternalComparator: () => u, strict: !0 });
|
|
var L = e.i(670986),
|
|
z = ({ contentComponent: e }) => {
|
|
let t = (0, r.useSyncExternalStore)(
|
|
e.subscribe,
|
|
e.getSnapshot,
|
|
e.getServerSnapshot,
|
|
);
|
|
return (0, i.jsx)(i.Fragment, { children: Object.values(t) });
|
|
},
|
|
B = class extends t.default.Component {
|
|
constructor(e) {
|
|
var n;
|
|
super(e),
|
|
(this.editorContentRef = t.default.createRef()),
|
|
(this.initialized = !1),
|
|
(this.state = {
|
|
hasContentComponentInitialized: !!(null == (n = e.editor)
|
|
? void 0
|
|
: n.contentComponent),
|
|
});
|
|
}
|
|
componentDidMount() {
|
|
this.init();
|
|
}
|
|
componentDidUpdate() {
|
|
this.init();
|
|
}
|
|
init() {
|
|
var e;
|
|
let t = this.props.editor;
|
|
if (
|
|
t &&
|
|
!t.isDestroyed &&
|
|
(null == (e = t.view.dom) ? void 0 : e.parentNode)
|
|
) {
|
|
let e, r;
|
|
if (t.contentComponent) return;
|
|
let i = this.editorContentRef.current;
|
|
i.append(...t.view.dom.parentNode.childNodes),
|
|
t.setOptions({ element: i }),
|
|
(e = new Set()),
|
|
(r = {}),
|
|
(t.contentComponent = {
|
|
subscribe: (t) => (
|
|
e.add(t),
|
|
() => {
|
|
e.delete(t);
|
|
}
|
|
),
|
|
getSnapshot: () => r,
|
|
getServerSnapshot: () => r,
|
|
setRenderer(t, i) {
|
|
(r = {
|
|
...r,
|
|
[t]: n.default.createPortal(i.reactElement, i.element, t),
|
|
}),
|
|
e.forEach((e) => e());
|
|
},
|
|
removeRenderer(t) {
|
|
let n = { ...r };
|
|
delete n[t], (r = n), e.forEach((e) => e());
|
|
},
|
|
}),
|
|
this.state.hasContentComponentInitialized ||
|
|
(this.unsubscribeToContentComponent =
|
|
t.contentComponent.subscribe(() => {
|
|
this.setState((e) =>
|
|
e.hasContentComponentInitialized
|
|
? e
|
|
: { hasContentComponentInitialized: !0 },
|
|
),
|
|
this.unsubscribeToContentComponent &&
|
|
this.unsubscribeToContentComponent();
|
|
})),
|
|
t.createNodeViews(),
|
|
(this.initialized = !0);
|
|
}
|
|
}
|
|
componentWillUnmount() {
|
|
var e;
|
|
let t = this.props.editor;
|
|
if (t) {
|
|
(this.initialized = !1),
|
|
t.isDestroyed || t.view.setProps({ nodeViews: {} }),
|
|
this.unsubscribeToContentComponent &&
|
|
this.unsubscribeToContentComponent(),
|
|
(t.contentComponent = null);
|
|
try {
|
|
if (!(null == (e = t.view.dom) ? void 0 : e.parentNode)) return;
|
|
let n = document.createElement("div");
|
|
n.append(...t.view.dom.parentNode.childNodes),
|
|
t.setOptions({ element: n });
|
|
} catch {}
|
|
}
|
|
}
|
|
render() {
|
|
let { editor: e, innerRef: t, ...n } = this.props;
|
|
return (0, i.jsxs)(i.Fragment, {
|
|
children: [
|
|
(0, i.jsx)("div", {
|
|
ref: (
|
|
(...e) =>
|
|
(t) => {
|
|
e.forEach((e) => {
|
|
"function" == typeof e ? e(t) : e && (e.current = t);
|
|
});
|
|
}
|
|
)(t, this.editorContentRef),
|
|
...n,
|
|
}),
|
|
(null == e ? void 0 : e.contentComponent) &&
|
|
(0, i.jsx)(z, { contentComponent: e.contentComponent }),
|
|
],
|
|
});
|
|
}
|
|
},
|
|
$ = (0, t.forwardRef)((e, n) => {
|
|
let r = t.default.useMemo(
|
|
() => Math.floor(0xffffffff * Math.random()).toString(),
|
|
[e.editor],
|
|
);
|
|
return t.default.createElement(B, { key: r, innerRef: n, ...e });
|
|
}),
|
|
j = t.default.memo($),
|
|
F = "u" > typeof window ? t.useLayoutEffect : t.useEffect,
|
|
V = class {
|
|
constructor(e) {
|
|
(this.transactionNumber = 0),
|
|
(this.lastTransactionNumber = 0),
|
|
(this.subscribers = new Set()),
|
|
(this.editor = e),
|
|
(this.lastSnapshot = { editor: e, transactionNumber: 0 }),
|
|
(this.getSnapshot = this.getSnapshot.bind(this)),
|
|
(this.getServerSnapshot = this.getServerSnapshot.bind(this)),
|
|
(this.watch = this.watch.bind(this)),
|
|
(this.subscribe = this.subscribe.bind(this));
|
|
}
|
|
getSnapshot() {
|
|
return (
|
|
this.transactionNumber === this.lastTransactionNumber ||
|
|
((this.lastTransactionNumber = this.transactionNumber),
|
|
(this.lastSnapshot = {
|
|
editor: this.editor,
|
|
transactionNumber: this.transactionNumber,
|
|
})),
|
|
this.lastSnapshot
|
|
);
|
|
}
|
|
getServerSnapshot() {
|
|
return { editor: null, transactionNumber: 0 };
|
|
}
|
|
subscribe(e) {
|
|
return (
|
|
this.subscribers.add(e),
|
|
() => {
|
|
this.subscribers.delete(e);
|
|
}
|
|
);
|
|
}
|
|
watch(e) {
|
|
if (((this.editor = e), this.editor)) {
|
|
let e = () => {
|
|
(this.transactionNumber += 1),
|
|
this.subscribers.forEach((e) => e());
|
|
},
|
|
t = this.editor;
|
|
return (
|
|
t.on("transaction", e),
|
|
() => {
|
|
t.off("transaction", e);
|
|
}
|
|
);
|
|
}
|
|
}
|
|
};
|
|
function H(e) {
|
|
var n;
|
|
let [r] = (0, t.useState)(() => new V(e.editor)),
|
|
i = (0, L.useSyncExternalStoreWithSelector)(
|
|
r.subscribe,
|
|
r.getSnapshot,
|
|
r.getServerSnapshot,
|
|
e.selector,
|
|
null != (n = e.equalityFn) ? n : I,
|
|
);
|
|
return (
|
|
F(() => r.watch(e.editor), [e.editor, r]), (0, t.useDebugValue)(i), i
|
|
);
|
|
}
|
|
var W = "u" < typeof window,
|
|
_ = W || !!("u" > typeof window && window.next),
|
|
q = class e {
|
|
constructor(e) {
|
|
(this.editor = null),
|
|
(this.subscriptions = new Set()),
|
|
(this.isComponentMounted = !1),
|
|
(this.previousDeps = null),
|
|
(this.instanceId = ""),
|
|
(this.options = e),
|
|
(this.subscriptions = new Set()),
|
|
this.setEditor(this.getInitialEditor()),
|
|
this.scheduleDestroy(),
|
|
(this.getEditor = this.getEditor.bind(this)),
|
|
(this.getServerSnapshot = this.getServerSnapshot.bind(this)),
|
|
(this.subscribe = this.subscribe.bind(this)),
|
|
(this.refreshEditorInstance =
|
|
this.refreshEditorInstance.bind(this)),
|
|
(this.scheduleDestroy = this.scheduleDestroy.bind(this)),
|
|
(this.onRender = this.onRender.bind(this)),
|
|
(this.createEditor = this.createEditor.bind(this));
|
|
}
|
|
setEditor(e) {
|
|
(this.editor = e),
|
|
(this.instanceId = Math.random().toString(36).slice(2, 9)),
|
|
this.subscriptions.forEach((e) => e());
|
|
}
|
|
getInitialEditor() {
|
|
return void 0 === this.options.current.immediatelyRender
|
|
? W || _
|
|
? null
|
|
: this.createEditor()
|
|
: (this.options.current.immediatelyRender,
|
|
this.options.current.immediatelyRender)
|
|
? this.createEditor()
|
|
: null;
|
|
}
|
|
createEditor() {
|
|
let e = {
|
|
...this.options.current,
|
|
onBeforeCreate: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onBeforeCreate)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onBlur: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onBlur)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onCreate: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onCreate)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onDestroy: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onDestroy)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onFocus: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onFocus)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onSelectionUpdate: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onSelectionUpdate)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onTransaction: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onTransaction)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onUpdate: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onUpdate)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onContentError: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onContentError)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onDrop: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onDrop)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onPaste: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onPaste)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
onDelete: (...e) => {
|
|
var t, n;
|
|
return null == (n = (t = this.options.current).onDelete)
|
|
? void 0
|
|
: n.call(t, ...e);
|
|
},
|
|
};
|
|
return new o.Editor(e);
|
|
}
|
|
getEditor() {
|
|
return this.editor;
|
|
}
|
|
getServerSnapshot() {
|
|
return null;
|
|
}
|
|
subscribe(e) {
|
|
return (
|
|
this.subscriptions.add(e),
|
|
() => {
|
|
this.subscriptions.delete(e);
|
|
}
|
|
);
|
|
}
|
|
static compareOptions(e, t) {
|
|
return Object.keys(e).every(
|
|
(n) =>
|
|
!![
|
|
"onCreate",
|
|
"onBeforeCreate",
|
|
"onDestroy",
|
|
"onUpdate",
|
|
"onTransaction",
|
|
"onFocus",
|
|
"onBlur",
|
|
"onSelectionUpdate",
|
|
"onContentError",
|
|
"onDrop",
|
|
"onPaste",
|
|
].includes(n) ||
|
|
("extensions" === n && e.extensions && t.extensions
|
|
? e.extensions.length === t.extensions.length &&
|
|
e.extensions.every((e, n) => {
|
|
var r;
|
|
return e === (null == (r = t.extensions) ? void 0 : r[n]);
|
|
})
|
|
: e[n] === t[n]),
|
|
);
|
|
}
|
|
onRender(t) {
|
|
return () => (
|
|
(this.isComponentMounted = !0),
|
|
clearTimeout(this.scheduledDestructionTimeout),
|
|
this.editor && !this.editor.isDestroyed && 0 === t.length
|
|
? e.compareOptions(this.options.current, this.editor.options) ||
|
|
this.editor.setOptions({
|
|
...this.options.current,
|
|
editable: this.editor.isEditable,
|
|
})
|
|
: this.refreshEditorInstance(t),
|
|
() => {
|
|
(this.isComponentMounted = !1), this.scheduleDestroy();
|
|
}
|
|
);
|
|
}
|
|
refreshEditorInstance(e) {
|
|
if (this.editor && !this.editor.isDestroyed) {
|
|
if (null === this.previousDeps) {
|
|
this.previousDeps = e;
|
|
return;
|
|
}
|
|
if (
|
|
this.previousDeps.length === e.length &&
|
|
this.previousDeps.every((t, n) => t === e[n])
|
|
)
|
|
return;
|
|
}
|
|
this.editor && !this.editor.isDestroyed && this.editor.destroy(),
|
|
this.setEditor(this.createEditor()),
|
|
(this.previousDeps = e);
|
|
}
|
|
scheduleDestroy() {
|
|
let e = this.instanceId,
|
|
t = this.editor;
|
|
this.scheduledDestructionTimeout = setTimeout(() => {
|
|
if (this.isComponentMounted && this.instanceId === e) {
|
|
t && t.setOptions(this.options.current);
|
|
return;
|
|
}
|
|
t &&
|
|
!t.isDestroyed &&
|
|
(t.destroy(), this.instanceId === e && this.setEditor(null));
|
|
}, 1);
|
|
}
|
|
};
|
|
function K(e = {}, n = []) {
|
|
let i = (0, t.useRef)(e);
|
|
i.current = e;
|
|
let [o] = (0, t.useState)(() => new q(i)),
|
|
s = (0, r.useSyncExternalStore)(
|
|
o.subscribe,
|
|
o.getEditor,
|
|
o.getServerSnapshot,
|
|
);
|
|
return (
|
|
(0, t.useDebugValue)(s),
|
|
(0, t.useEffect)(o.onRender(n)),
|
|
H({
|
|
editor: s,
|
|
selector: ({ transactionNumber: t }) =>
|
|
!1 === e.shouldRerenderOnTransaction ||
|
|
void 0 === e.shouldRerenderOnTransaction
|
|
? null
|
|
: e.immediatelyRender && 0 === t
|
|
? 0
|
|
: t + 1,
|
|
}),
|
|
s
|
|
);
|
|
}
|
|
var U = (0, t.createContext)({ editor: null });
|
|
U.Consumer;
|
|
var J = (0, t.createContext)({
|
|
onDragStart: () => {},
|
|
nodeViewContentChildren: void 0,
|
|
nodeViewContentRef: () => {},
|
|
}),
|
|
G = t.default.forwardRef((e, n) => {
|
|
let { onDragStart: r } = (0, t.useContext)(J),
|
|
o = e.as || "div";
|
|
return (0, i.jsx)(o, {
|
|
...e,
|
|
ref: n,
|
|
"data-node-view-wrapper": "",
|
|
onDragStart: r,
|
|
style: { whiteSpace: "normal", ...e.style },
|
|
});
|
|
});
|
|
function Y(e) {
|
|
return !!(
|
|
"function" == typeof e &&
|
|
e.prototype &&
|
|
e.prototype.isReactComponent
|
|
);
|
|
}
|
|
function Q(e) {
|
|
return !!(
|
|
"object" == typeof e &&
|
|
e.$$typeof &&
|
|
("Symbol(react.forward_ref)" === e.$$typeof.toString() ||
|
|
"react.forward_ref" === e.$$typeof.description)
|
|
);
|
|
}
|
|
var X = class {
|
|
constructor(
|
|
e,
|
|
{ editor: t, props: r = {}, as: i = "div", className: o = "" },
|
|
) {
|
|
(this.ref = null),
|
|
(this.destroyed = !1),
|
|
(this.id = Math.floor(0xffffffff * Math.random()).toString()),
|
|
(this.component = e),
|
|
(this.editor = t),
|
|
(this.props = r),
|
|
(this.element = document.createElement(i)),
|
|
this.element.classList.add("react-renderer"),
|
|
o && this.element.classList.add(...o.split(" ")),
|
|
this.editor.isInitialized
|
|
? (0, n.flushSync)(() => {
|
|
this.render();
|
|
})
|
|
: queueMicrotask(() => {
|
|
this.destroyed || this.render();
|
|
});
|
|
}
|
|
render() {
|
|
var e;
|
|
if (this.destroyed) return;
|
|
let n = this.component,
|
|
r = this.props,
|
|
o = this.editor,
|
|
s = (function () {
|
|
try {
|
|
if (t.version) return parseInt(t.version.split(".")[0], 10) >= 19;
|
|
} catch {}
|
|
return !1;
|
|
})(),
|
|
l = (function (e) {
|
|
if (Y(e) || Q(e)) return !0;
|
|
if (
|
|
"object" == typeof e &&
|
|
e.$$typeof &&
|
|
("Symbol(react.memo)" === e.$$typeof.toString() ||
|
|
"react.memo" === e.$$typeof.description)
|
|
) {
|
|
let t = e.type;
|
|
if (t) return Y(t) || Q(t);
|
|
}
|
|
return !1;
|
|
})(n),
|
|
a = { ...r };
|
|
a.ref && !(s || l) && delete a.ref,
|
|
!a.ref &&
|
|
(s || l) &&
|
|
(a.ref = (e) => {
|
|
this.ref = e;
|
|
}),
|
|
(this.reactElement = (0, i.jsx)(n, { ...a })),
|
|
null == (e = null == o ? void 0 : o.contentComponent) ||
|
|
e.setRenderer(this.id, this);
|
|
}
|
|
updateProps(e = {}) {
|
|
this.destroyed ||
|
|
((this.props = { ...this.props, ...e }), this.render());
|
|
}
|
|
destroy() {
|
|
var e;
|
|
this.destroyed = !0;
|
|
let t = this.editor;
|
|
null == (e = null == t ? void 0 : t.contentComponent) ||
|
|
e.removeRenderer(this.id);
|
|
try {
|
|
this.element &&
|
|
this.element.parentNode &&
|
|
this.element.parentNode.removeChild(this.element);
|
|
} catch {}
|
|
}
|
|
updateAttributes(e) {
|
|
Object.keys(e).forEach((t) => {
|
|
this.element.setAttribute(t, e[t]);
|
|
});
|
|
}
|
|
};
|
|
t.default.createContext({ markViewContentRef: () => {} }), o.MarkView;
|
|
var Z = class extends o.NodeView {
|
|
constructor(e, t, n) {
|
|
if (
|
|
(super(e, t, n),
|
|
(this.selectionRafId = null),
|
|
(this.cachedExtensionWithSyncedStorage = null),
|
|
!this.node.isLeaf)
|
|
) {
|
|
this.options.contentDOMElementTag
|
|
? (this.contentDOMElement = document.createElement(
|
|
this.options.contentDOMElementTag,
|
|
))
|
|
: (this.contentDOMElement = document.createElement(
|
|
this.node.isInline ? "span" : "div",
|
|
)),
|
|
(this.contentDOMElement.dataset.nodeViewContentReact = ""),
|
|
(this.contentDOMElement.dataset.nodeViewWrapper = ""),
|
|
(this.contentDOMElement.style.whiteSpace = "inherit");
|
|
const e = this.dom.querySelector("[data-node-view-content]");
|
|
if (!e) return;
|
|
e.appendChild(this.contentDOMElement);
|
|
}
|
|
}
|
|
get extensionWithSyncedStorage() {
|
|
if (!this.cachedExtensionWithSyncedStorage) {
|
|
let e = this.editor,
|
|
t = this.extension;
|
|
this.cachedExtensionWithSyncedStorage = new Proxy(t, {
|
|
get(n, r, i) {
|
|
var o;
|
|
return "storage" === r
|
|
? null != (o = e.storage[t.name])
|
|
? o
|
|
: {}
|
|
: Reflect.get(n, r, i);
|
|
},
|
|
});
|
|
}
|
|
return this.cachedExtensionWithSyncedStorage;
|
|
}
|
|
mount() {
|
|
let e = {
|
|
editor: this.editor,
|
|
node: this.node,
|
|
decorations: this.decorations,
|
|
innerDecorations: this.innerDecorations,
|
|
view: this.view,
|
|
selected: !1,
|
|
extension: this.extensionWithSyncedStorage,
|
|
HTMLAttributes: this.HTMLAttributes,
|
|
getPos: () => this.getPos(),
|
|
updateAttributes: (e = {}) => this.updateAttributes(e),
|
|
deleteNode: () => this.deleteNode(),
|
|
ref: (0, t.createRef)(),
|
|
};
|
|
if (!this.component.displayName) {
|
|
let e;
|
|
this.component.displayName =
|
|
(e = this.extension.name).charAt(0).toUpperCase() + e.substring(1);
|
|
}
|
|
let n = {
|
|
onDragStart: this.onDragStart.bind(this),
|
|
nodeViewContentRef: (e) => {
|
|
e &&
|
|
this.contentDOMElement &&
|
|
e.firstChild !== this.contentDOMElement &&
|
|
(e.hasAttribute("data-node-view-wrapper") &&
|
|
e.removeAttribute("data-node-view-wrapper"),
|
|
e.appendChild(this.contentDOMElement));
|
|
},
|
|
},
|
|
r = this.component,
|
|
o = (0, t.memo)((e) =>
|
|
(0, i.jsx)(J.Provider, {
|
|
value: n,
|
|
children: (0, t.createElement)(r, e),
|
|
}),
|
|
);
|
|
o.displayName = "ReactNodeView";
|
|
let s = this.node.isInline ? "span" : "div";
|
|
this.options.as && (s = this.options.as);
|
|
let { className: l = "" } = this.options;
|
|
(this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this)),
|
|
(this.renderer = new X(o, {
|
|
editor: this.editor,
|
|
props: e,
|
|
as: s,
|
|
className: `node-${this.node.type.name} ${l}`.trim(),
|
|
})),
|
|
this.editor.on("selectionUpdate", this.handleSelectionUpdate),
|
|
this.updateElementAttributes();
|
|
}
|
|
get dom() {
|
|
var e;
|
|
if (
|
|
this.renderer.element.firstElementChild &&
|
|
!(null == (e = this.renderer.element.firstElementChild)
|
|
? void 0
|
|
: e.hasAttribute("data-node-view-wrapper"))
|
|
)
|
|
throw Error(
|
|
"Please use the NodeViewWrapper component for your node view.",
|
|
);
|
|
return this.renderer.element;
|
|
}
|
|
get contentDOM() {
|
|
return this.node.isLeaf ? null : this.contentDOMElement;
|
|
}
|
|
handleSelectionUpdate() {
|
|
this.selectionRafId &&
|
|
(cancelAnimationFrame(this.selectionRafId),
|
|
(this.selectionRafId = null)),
|
|
(this.selectionRafId = requestAnimationFrame(() => {
|
|
this.selectionRafId = null;
|
|
let { from: e, to: t } = this.editor.state.selection,
|
|
n = this.getPos();
|
|
if ("number" == typeof n)
|
|
if (e <= n && t >= n + this.node.nodeSize) {
|
|
if (this.renderer.props.selected) return;
|
|
this.selectNode();
|
|
} else {
|
|
if (!this.renderer.props.selected) return;
|
|
this.deselectNode();
|
|
}
|
|
}));
|
|
}
|
|
update(e, t, n) {
|
|
let r = (e) => {
|
|
this.renderer.updateProps(e),
|
|
"function" == typeof this.options.attrs &&
|
|
this.updateElementAttributes();
|
|
};
|
|
if (e.type !== this.node.type) return !1;
|
|
if ("function" == typeof this.options.update) {
|
|
let i = this.node,
|
|
o = this.decorations,
|
|
s = this.innerDecorations;
|
|
return (
|
|
(this.node = e),
|
|
(this.decorations = t),
|
|
(this.innerDecorations = n),
|
|
this.options.update({
|
|
oldNode: i,
|
|
oldDecorations: o,
|
|
newNode: e,
|
|
newDecorations: t,
|
|
oldInnerDecorations: s,
|
|
innerDecorations: n,
|
|
updateProps: () =>
|
|
r({
|
|
node: e,
|
|
decorations: t,
|
|
innerDecorations: n,
|
|
extension: this.extensionWithSyncedStorage,
|
|
}),
|
|
})
|
|
);
|
|
}
|
|
return (
|
|
(e === this.node &&
|
|
this.decorations === t &&
|
|
this.innerDecorations === n) ||
|
|
((this.node = e),
|
|
(this.decorations = t),
|
|
(this.innerDecorations = n),
|
|
r({
|
|
node: e,
|
|
decorations: t,
|
|
innerDecorations: n,
|
|
extension: this.extensionWithSyncedStorage,
|
|
}),
|
|
!0)
|
|
);
|
|
}
|
|
selectNode() {
|
|
this.renderer.updateProps({ selected: !0 }),
|
|
this.renderer.element.classList.add("ProseMirror-selectednode");
|
|
}
|
|
deselectNode() {
|
|
this.renderer.updateProps({ selected: !1 }),
|
|
this.renderer.element.classList.remove("ProseMirror-selectednode");
|
|
}
|
|
destroy() {
|
|
this.renderer.destroy(),
|
|
this.editor.off("selectionUpdate", this.handleSelectionUpdate),
|
|
(this.contentDOMElement = null),
|
|
this.selectionRafId &&
|
|
(cancelAnimationFrame(this.selectionRafId),
|
|
(this.selectionRafId = null));
|
|
}
|
|
updateElementAttributes() {
|
|
if (this.options.attrs) {
|
|
let e = {};
|
|
if ("function" == typeof this.options.attrs) {
|
|
let t = this.editor.extensionManager.attributes,
|
|
n = (0, o.getRenderedAttributes)(this.node, t);
|
|
e = this.options.attrs({ node: this.node, HTMLAttributes: n });
|
|
} else e = this.options.attrs;
|
|
this.renderer.updateAttributes(e);
|
|
}
|
|
}
|
|
};
|
|
function ee(e, t) {
|
|
return (n) => (n.editor.contentComponent ? new Z(e, n, t) : {});
|
|
}
|
|
var et = (0, t.createContext)({
|
|
get editor() {
|
|
throw Error("useTiptap must be used within a <Tiptap> provider");
|
|
},
|
|
});
|
|
function en({ editor: e, instance: n, children: r }) {
|
|
let o = null != e ? e : n;
|
|
if (!o)
|
|
throw Error(
|
|
"Tiptap: An editor instance is required. Pass a non-null `editor` prop.",
|
|
);
|
|
let s = (0, t.useMemo)(() => ({ editor: o }), [o]),
|
|
l = (0, t.useMemo)(() => ({ editor: o }), [o]);
|
|
return (0, i.jsx)(U.Provider, {
|
|
value: l,
|
|
children: (0, i.jsx)(et.Provider, { value: s, children: r }),
|
|
});
|
|
}
|
|
function er({ ...e }) {
|
|
let { editor: n } = (0, t.useContext)(et);
|
|
return (0, i.jsx)(j, { editor: n, ...e });
|
|
}
|
|
(et.displayName = "TiptapContext"),
|
|
(en.displayName = "Tiptap"),
|
|
(er.displayName = "Tiptap.Content"),
|
|
Object.assign(en, { Content: er }),
|
|
e.s(
|
|
[
|
|
"EditorContent",
|
|
() => j,
|
|
"NodeViewWrapper",
|
|
() => G,
|
|
"ReactNodeViewRenderer",
|
|
() => ee,
|
|
"ReactRenderer",
|
|
() => X,
|
|
"useEditor",
|
|
() => K,
|
|
"useEditorState",
|
|
() => H,
|
|
],
|
|
616777,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|