@lofcz/platejs-core 53.4.7 → 53.4.8

package/dist/react/index.js

@@ -5,17 +5,16 @@ import { NodeApi, PathApi, createEditor } from "@platejs/slate";
 import { isDefined } from "@udecode/utils";
 import { DefaultPlaceholder, Editable, Slate, useComposing, useFocused, useReadOnly, useSelected, useSlateStatic, withReact } from "slate-react";
 import { c } from "react-compiler-runtime";
-import React, { useEffect, useId, useRef } from "react";
+import React, { useEffect, useId, useMemo, useRef } from "react";
 import { Key, useHotkeys } from "@udecode/react-hotkeys";
-import { atom, atom as atom$1 } from "jotai";
-import { createAtomStore, useAtomStoreSet, useAtomStoreState, useAtomStoreValue, useStoreAtomState, useStoreAtomValue, useStoreAtomValue as useStoreAtomValue$1, useStoreSetAtom } from "jotai-x";
+import { atom, atom as atom$1, getDefaultStore, useAtomValueRawSync, useSetAtom } from "jotai";
+import { createStore } from "jotai/vanilla";
+import { selectAtom, useHydrateAtoms } from "jotai/utils";
 import { createZustandStore, createZustandStore as createZustandStore$1, useStoreSelect, useStoreSelect as useStoreSelect$1, useStoreState, useStoreValue, useStoreValue as useStoreValue$1, useTracked, useTrackedStore } from "zustand-x";
 import clsx$1, { clsx } from "clsx";
 import omit from "lodash/omit.js";
 import { useDeepCompareMemo } from "use-deep-compare";
 import { useComposedRef, useStableFn } from "@udecode/react-utils";
-import { createStore } from "jotai/vanilla";
-import { selectAtom } from "jotai/utils";
 import { focusAtom } from "jotai-optics";
 
 //#region src/react/components/ContentVisibilityChunk.tsx
@@ -41,6 +40,476 @@ const ContentVisibilityChunk = (t0) => {
 	return t2;
 };
 
+//#endregion
+//#region ../udecode/jotai-x/src/atomWithFn.ts
+const wrapFn = (fnOrValue) => typeof fnOrValue === "function" ? { __fn: fnOrValue } : fnOrValue;
+const unwrapFn = (wrappedFnOrValue) => wrappedFnOrValue && typeof wrappedFnOrValue === "object" && "__fn" in wrappedFnOrValue ? wrappedFnOrValue.__fn : wrappedFnOrValue;
+/**
+* Jotai atoms don't allow functions as values by default. This function is a
+* drop-in replacement for `atom` that wraps functions in an object while
+* leaving non-functions unchanged. The wrapper object should be completely
+* invisible to consumers of the atom.
+*/
+const atomWithFn = (initialValue) => {
+	const baseAtom = atom$1(wrapFn(initialValue));
+	return atom$1((get) => unwrapFn(get(baseAtom)), (_get, set, value) => set(baseAtom, wrapFn(value)));
+};
+
+//#endregion
+//#region ../udecode/jotai-x/src/useHydrateStore.ts
+/**
+* Hydrate atoms with initial values for SSR.
+*/
+const useHydrateStore = (atoms, initialValues, t0) => {
+	const $ = c(5);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const options = t1;
+	let nextValues;
+	if ($[2] !== atoms || $[3] !== initialValues) {
+		nextValues = [];
+		for (const key of Object.keys(atoms)) {
+			const initialValue = initialValues[key];
+			if (initialValue !== void 0) nextValues.push([atoms[key], initialValue]);
+		}
+		$[2] = atoms;
+		$[3] = initialValues;
+		$[4] = nextValues;
+	} else nextValues = $[4];
+	useHydrateAtoms(nextValues, options);
+};
+/**
+* Update atoms with new values on changes.
+*/
+const useSyncStore = (atoms, values, t0) => {
+	const $ = c(12);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { skipInitialValues, store: storeOption } = t1;
+	let t2;
+	if ($[2] !== atoms) {
+		t2 = Object.entries(atoms);
+		$[2] = atoms;
+		$[3] = t2;
+	} else t2 = $[3];
+	const atomEntries = t2;
+	let t3;
+	if ($[4] !== atomEntries) {
+		t3 = atom$1(null, (_get, set, nextValues) => {
+			const previousValues = nextValues.previousValues;
+			for (const [key, writableAtom] of atomEntries) {
+				const value = nextValues.values[key];
+				if (value === void 0 || value === null) continue;
+				if (previousValues && Object.is(previousValues[key], value)) continue;
+				set(writableAtom, value);
+			}
+		});
+		$[4] = atomEntries;
+		$[5] = t3;
+	} else t3 = $[5];
+	const syncAtom = t3;
+	let t4;
+	if ($[6] !== storeOption) {
+		t4 = { store: storeOption };
+		$[6] = storeOption;
+		$[7] = t4;
+	} else t4 = $[7];
+	const syncValues = useSetAtom(syncAtom, t4);
+	const previousValuesRef = React.useRef(skipInitialValues);
+	let t5;
+	let t6;
+	if ($[8] !== syncValues || $[9] !== values) {
+		t5 = () => {
+			syncValues({
+				previousValues: previousValuesRef.current,
+				values
+			});
+			previousValuesRef.current = values;
+		};
+		t6 = [syncValues, values];
+		$[8] = syncValues;
+		$[9] = values;
+		$[10] = t5;
+		$[11] = t6;
+	} else {
+		t5 = $[10];
+		t6 = $[11];
+	}
+	React.useEffect(t5, t6);
+};
+
+//#endregion
+//#region ../udecode/jotai-x/src/createAtomProvider.tsx
+const getFullyQualifiedScope = (storeName, scope) => `${storeName}:${scope}`;
+/**
+* Context mapping store name and scope to store. The 'provider' scope is used
+* to reference any provider belonging to the store, regardless of scope.
+*/
+const PROVIDER_SCOPE = "provider";
+const AtomStoreContext = React.createContext(/* @__PURE__ */ new Map());
+/**
+* Tries to find a store in each of the following places, in order:
+* 1. The store context, matching the store name and scope
+* 2. The store context, matching the store name and 'provider' scope
+* 3. Otherwise, return undefined
+*/
+const useAtomStore = (storeName, t0, t1) => {
+	const $ = c(4);
+	const scope = t0 === void 0 ? PROVIDER_SCOPE : t0;
+	const warnIfUndefined = t1 === void 0 ? true : t1;
+	const storeContext = React.useContext(AtomStoreContext);
+	let t2;
+	if ($[0] !== scope || $[1] !== storeContext || $[2] !== storeName) {
+		t2 = storeContext.get(getFullyQualifiedScope(storeName, scope)) ?? storeContext.get(getFullyQualifiedScope(storeName, PROVIDER_SCOPE));
+		$[0] = scope;
+		$[1] = storeContext;
+		$[2] = storeName;
+		$[3] = t2;
+	} else t2 = $[3];
+	const store = t2;
+	if (!store && warnIfUndefined) console.warn(`Tried to access jotai store '${storeName}' outside of a matching provider.`);
+	return store;
+};
+const HydrateAtoms = (t0) => {
+	const $ = c(16);
+	let atoms;
+	let children;
+	let initialValues;
+	let props;
+	let store;
+	if ($[0] !== t0) {
+		({initialValues, children, store, atoms, ...props} = t0);
+		$[0] = t0;
+		$[1] = atoms;
+		$[2] = children;
+		$[3] = initialValues;
+		$[4] = props;
+		$[5] = store;
+	} else {
+		atoms = $[1];
+		children = $[2];
+		initialValues = $[3];
+		props = $[4];
+		store = $[5];
+	}
+	let t1;
+	if ($[6] !== initialValues || $[7] !== props) {
+		t1 = {
+			...initialValues,
+			...props
+		};
+		$[6] = initialValues;
+		$[7] = props;
+		$[8] = t1;
+	} else t1 = $[8];
+	const hydratedValues = t1;
+	let t2;
+	if ($[9] !== store) {
+		t2 = { store };
+		$[9] = store;
+		$[10] = t2;
+	} else t2 = $[10];
+	useHydrateStore(atoms, hydratedValues, t2);
+	const t3 = props;
+	let t4;
+	if ($[11] !== store || $[12] !== t3) {
+		t4 = {
+			store,
+			skipInitialValues: t3
+		};
+		$[11] = store;
+		$[12] = t3;
+		$[13] = t4;
+	} else t4 = $[13];
+	useSyncStore(atoms, props, t4);
+	let t5;
+	if ($[14] !== children) {
+		t5 = /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+		$[14] = children;
+		$[15] = t5;
+	} else t5 = $[15];
+	return t5;
+};
+/**
+* Creates a generic provider for a jotai store.
+* - `initialValues`: Initial values for the store.
+* - `props`: Dynamic values for the store.
+*/
+const createAtomProvider = (storeScope, atoms, options = {}) => {
+	const Effect = options.effect;
+	return ({ store, scope, children, resetKey, ...props }) => {
+		const [storeState, setStoreState] = React.useState(() => store ?? createStore());
+		const resolvedStore = store ?? storeState;
+		React.useEffect(() => {
+			if (!store && resetKey) setStoreState(createStore());
+		}, [resetKey, store]);
+		const previousStoreContext = React.useContext(AtomStoreContext);
+		const storeContext = React.useMemo(() => {
+			const newStoreContext = new Map(previousStoreContext);
+			if (scope) newStoreContext.set(getFullyQualifiedScope(storeScope, scope), resolvedStore);
+			newStoreContext.set(getFullyQualifiedScope(storeScope, PROVIDER_SCOPE), resolvedStore);
+			return newStoreContext;
+		}, [
+			previousStoreContext,
+			resolvedStore,
+			scope
+		]);
+		return /* @__PURE__ */ React.createElement(AtomStoreContext.Provider, { value: storeContext }, /* @__PURE__ */ React.createElement(HydrateAtoms, {
+			store: resolvedStore,
+			atoms,
+			...props
+		}, !!Effect && /* @__PURE__ */ React.createElement(Effect, null), children));
+	};
+};
+
+//#endregion
+//#region ../udecode/jotai-x/src/createAtomStore.ts
+const capitalizeFirstLetter = (str = "") => str.length > 0 ? str[0].toUpperCase() + str.slice(1) : "";
+const isAtom = (possibleAtom) => !!possibleAtom && typeof possibleAtom === "object" && "read" in possibleAtom && typeof possibleAtom.read === "function";
+const convertScopeShorthand = (optionsOrScope = {}) => typeof optionsOrScope === "string" ? { scope: optionsOrScope } : optionsOrScope;
+const identity = (x) => x;
+/**
+* Create an atom store from an initial value.
+* Each property will have a getter and setter.
+*
+* @example
+* const { exampleStore, useExampleStore, useExampleValue, useExampleState, useExampleSet } = createAtomStore({ count: 1, say: 'hello' }, { name: 'example' as const })
+* const [count, setCount] = useExampleState()
+* const say = useExampleValue('say')
+* const setSay = useExampleSet('say')
+* setSay('world')
+* const countAtom = exampleStore.atom.count
+*/
+const createAtomStore = (initialState, { name, effect, extend, suppressWarnings }) => {
+	const atomsWithoutExtend = {};
+	const writableAtomsWithoutExtend = {};
+	const atomIsWritable = {};
+	/**
+	* Constructor to generate the object returned by `useStoreApi`. Using
+	* prototypes is much faster than constructing a new object every time the
+	* hook is called.
+	*/
+	function UseStoreApiFactory(options, store) {
+		this.options = options;
+		this.store = store;
+	}
+	for (const [key, atomOrValue] of Object.entries(initialState)) {
+		const atomConfig = isAtom(atomOrValue) ? atomOrValue : atomWithFn(atomOrValue);
+		atomsWithoutExtend[key] = atomConfig;
+		const writable = "write" in atomConfig;
+		atomIsWritable[key] = writable;
+		if (writable) writableAtomsWithoutExtend[key] = atomConfig;
+	}
+	const atoms = { ...atomsWithoutExtend };
+	if (extend) {
+		const extendedAtoms = extend(atomsWithoutExtend);
+		for (const [key, atomConfig] of Object.entries(extendedAtoms)) {
+			atoms[key] = atomConfig;
+			atomIsWritable[key] = "write" in atomConfig;
+		}
+	}
+	const useStore = (t0) => {
+		const $ = c(4);
+		let t1;
+		if ($[0] !== t0) {
+			t1 = t0 === void 0 ? {} : t0;
+			$[0] = t0;
+			$[1] = t1;
+		} else t1 = $[1];
+		const optionsOrScope = t1;
+		let t2;
+		if ($[2] !== optionsOrScope) {
+			t2 = convertScopeShorthand(optionsOrScope);
+			$[2] = optionsOrScope;
+			$[3] = t2;
+		} else t2 = $[3];
+		const { scope, store, warnIfNoStore: t3 } = t2;
+		const contextStore = useAtomStore(name, scope, !store && (t3 === void 0 ? !suppressWarnings : t3));
+		return store ?? contextStore;
+	};
+	const useAtomValueWithStore = (atomConfig, store, _optionsOrScope, selector, equalityFnOrDeps, deps) => {
+		const resolvedSelector = selector ?? identity;
+		const equalityFn = typeof equalityFnOrDeps === "function" ? equalityFnOrDeps : void 0;
+		const resolvedDeps = (typeof equalityFnOrDeps === "function" ? deps : equalityFnOrDeps) ?? [resolvedSelector, equalityFn];
+		const [memoizedSelector, memoizedEqualityFn] = React.useMemo(() => [resolvedSelector, equalityFn], resolvedDeps);
+		return useAtomValueRawSync(React.useMemo(() => memoizedSelector === identity && !memoizedEqualityFn ? atomConfig : selectAtom(atomConfig, memoizedSelector, memoizedEqualityFn), [
+			atomConfig,
+			memoizedSelector,
+			memoizedEqualityFn
+		]), { store });
+	};
+	const getAtomWithStore = (atomConfig, store, _optionsOrScope) => (store ?? getDefaultStore()).get(atomConfig);
+	const useSetAtomWithStore = (atomConfig, store, _optionsOrScope) => {
+		const $ = c(2);
+		let t0;
+		if ($[0] !== store) {
+			t0 = { store };
+			$[0] = store;
+			$[1] = t0;
+		} else t0 = $[1];
+		return useSetAtom(atomConfig, t0);
+	};
+	const setAtomWithStore = (atomConfig, store, _optionsOrScope) => (...args) => (store ?? getDefaultStore()).set(atomConfig, ...args);
+	const useAtomStateWithStore = (atomConfig, store, _optionsOrScope) => {
+		const $ = c(7);
+		let t0;
+		if ($[0] !== store) {
+			t0 = { store };
+			$[0] = store;
+			$[1] = t0;
+		} else t0 = $[1];
+		const t1 = useAtomValueRawSync(atomConfig, t0);
+		let t2;
+		if ($[2] !== store) {
+			t2 = { store };
+			$[2] = store;
+			$[3] = t2;
+		} else t2 = $[3];
+		const t3 = useSetAtom(atomConfig, t2);
+		let t4;
+		if ($[4] !== t1 || $[5] !== t3) {
+			t4 = [t1, t3];
+			$[4] = t1;
+			$[5] = t3;
+			$[6] = t4;
+		} else t4 = $[6];
+		return t4;
+	};
+	const subscribeAtomWithStore = (atomConfig, store, _optionsOrScope) => (callback) => {
+		const resolvedStore = store ?? getDefaultStore();
+		const unsubscribe = resolvedStore.sub(atomConfig, () => {
+			callback(resolvedStore.get(atomConfig));
+		});
+		return () => unsubscribe();
+	};
+	for (const key of Object.keys(atoms)) {
+		const atomConfig = atoms[key];
+		const isWritable = atomIsWritable[key];
+		const capitalizedKey = capitalizeFirstLetter(key);
+		UseStoreApiFactory.prototype[`use${capitalizedKey}Value`] = function(selector, equalityFnOrDeps, deps) {
+			return useAtomValueWithStore(atomConfig, this.store, this.options, selector, equalityFnOrDeps, deps);
+		};
+		UseStoreApiFactory.prototype[`get${capitalizedKey}`] = function() {
+			return getAtomWithStore(atomConfig, this.store, this.options);
+		};
+		UseStoreApiFactory.prototype[`subscribe${capitalizedKey}`] = function(callback) {
+			return subscribeAtomWithStore(atomConfig, this.store, this.options)(callback);
+		};
+		if (isWritable) {
+			UseStoreApiFactory.prototype[`useSet${capitalizedKey}`] = function() {
+				return useSetAtomWithStore(atomConfig, this.store, this.options);
+			};
+			UseStoreApiFactory.prototype[`set${capitalizedKey}`] = function(...args) {
+				return setAtomWithStore(atomConfig, this.store, this.options)(...args);
+			};
+			UseStoreApiFactory.prototype[`use${capitalizedKey}State`] = function() {
+				return useAtomStateWithStore(atomConfig, this.store, this.options);
+			};
+		}
+	}
+	const defineUseStoreApiMethod = (methodNameWithKey, methodNameWithAtomConfig, fnWithKey, fnWithAtomConfig = fnWithKey) => {
+		UseStoreApiFactory.prototype[methodNameWithKey] = function(key, ...args) {
+			const atomConfig = atoms[key];
+			return fnWithKey(atomConfig, this.store, this.options, ...args);
+		};
+		UseStoreApiFactory.prototype[methodNameWithAtomConfig] = function(atomConfig, ...args) {
+			return fnWithAtomConfig(atomConfig, this.store, this.options, ...args);
+		};
+	};
+	defineUseStoreApiMethod("useValue", "useAtomValue", useAtomValueWithStore);
+	defineUseStoreApiMethod("get", "getAtom", getAtomWithStore);
+	defineUseStoreApiMethod("useSet", "useSetAtom", useSetAtomWithStore);
+	defineUseStoreApiMethod("set", "setAtom", (atomConfig, store, options, ...args) => setAtomWithStore(atomConfig, store, options)(...args), setAtomWithStore);
+	defineUseStoreApiMethod("useState", "useAtomState", useAtomStateWithStore);
+	defineUseStoreApiMethod("subscribe", "subscribeAtom", (atomConfig, store, options, callback) => subscribeAtomWithStore(atomConfig, store, options)(callback), subscribeAtomWithStore);
+	const Provider = createAtomProvider(name, writableAtomsWithoutExtend, { effect });
+	const storeApi = {
+		atom: atoms,
+		name
+	};
+	const useStoreApi = (options = {}) => {
+		const convertedOptions = convertScopeShorthand(options);
+		const store = useStore(convertedOptions);
+		return useMemo(() => new UseStoreApiFactory(convertedOptions, store), [
+			store,
+			convertedOptions.delay,
+			convertedOptions.scope,
+			convertedOptions.store,
+			convertedOptions.warnIfNoStore
+		]);
+	};
+	const useNameState = (key, options) => {
+		const store = useStore(options) ?? getDefaultStore();
+		return useAtomStateWithStore(atoms[key], store, options);
+	};
+	const useNameValue = (key, t0, deps) => {
+		const $ = c(6);
+		let t1;
+		if ($[0] !== t0) {
+			t1 = t0 === void 0 ? {} : t0;
+			$[0] = t0;
+			$[1] = t1;
+		} else t1 = $[1];
+		let equalityFn;
+		let options;
+		let selector;
+		if ($[2] !== t1) {
+			({equalityFn, selector, ...options} = t1);
+			$[2] = t1;
+			$[3] = equalityFn;
+			$[4] = options;
+			$[5] = selector;
+		} else {
+			equalityFn = $[3];
+			options = $[4];
+			selector = $[5];
+		}
+		const store = useStore(options) ?? getDefaultStore();
+		return useAtomValueWithStore(atoms[key], store, options, selector, equalityFn ?? deps, equalityFn && deps);
+	};
+	const useNameSet = (key, options) => {
+		const store = useStore(options) ?? getDefaultStore();
+		return useSetAtomWithStore(atoms[key], store, options);
+	};
+	const capitalizedName = capitalizeFirstLetter(name);
+	const storeApiIndex = name.length === 0 ? "store" : `${name}Store`;
+	return {
+		[`${capitalizedName}Provider`]: Provider,
+		[storeApiIndex]: storeApi,
+		[`use${capitalizedName}Store`]: useStoreApi,
+		[`use${capitalizedName}State`]: useNameState,
+		[`use${capitalizedName}Value`]: useNameValue,
+		[`use${capitalizedName}Set`]: useNameSet,
+		name
+	};
+};
+function useAtomStoreValue(store, key, selector, equalityFnOrDeps, deps) {
+	return store.useValue(key, selector, equalityFnOrDeps, deps);
+}
+function useAtomStoreSet(store, key) {
+	return store.useSet(key);
+}
+function useAtomStoreState(store, key) {
+	return store.useState(key);
+}
+function useStoreAtomValue(store, atom$2, selector, equalityFnOrDeps, deps) {
+	return store.useAtomValue(atom$2, selector, equalityFnOrDeps, deps);
+}
+function useStoreSetAtom(store, atom$2) {
+	return store.useSetAtom(atom$2);
+}
+function useStoreAtomState(store, atom$2) {
+	return store.useAtomState(atom$2);
+}
+
 //#endregion
 //#region src/react/plugin/toPlatePlugin.ts
 const methodsToWrap = [
@@ -2529,7 +2998,7 @@ function useEditorPlugin(p, id) {
 //#region src/react/stores/plate/useEditorSelector.ts
 const useEditorSelector = (selector, deps, { id, equalityFn = (a, b) => a === b } = {}) => {
 	const selectorAtom = React.useMemo(() => selectAtom(plateStore.atom.trackedEditor, ({ editor }, prev) => selector(editor, prev), equalityFn), deps);
-	return useStoreAtomValue$1(usePlateStore(id), selectorAtom);
+	return useStoreAtomValue(usePlateStore(id), selectorAtom);
 };
 
 //#endregion

package/dist/static/index.d.ts

@@ -1,2 +1,2 @@
-import { $a as getEditorDOMFromHtmlString, Ao as SlateRenderElement, Ba as stripHtmlClassNames, Co as SlateRenderText, Do as pipeRenderLeafStatic, Eo as SlateRenderLeaf, Ga as getSelectedDomBlocks, Ha as isSelectOutside, Ja as getPluginDataAttributes, Ka as getRenderNodeStaticProps, Oo as pluginRenderLeafStatic, Qa as createStaticEditor, So as PlateStaticProps, To as pluginRenderTextStatic, Ua as getSelectedDomNode, Va as pipeDecorate, Wa as getSelectedDomFragment, Xa as getStaticPlugins, Ya as createStaticString, Za as ViewPlugin, _o as SerializeHtmlOptions, ao as SlateNodeProps, bo as LeafStatic, co as StyledSlateElementProps, do as useNodeAttributes, eo as SlateElement, fo as BoxStaticProps, go as SlateRenderTextProps, ho as SlateRenderNodeProps, io as SlateLeafProps, jo as pluginRenderElementStatic, ko as pipeRenderElementStatic, lo as StyledSlateLeafProps, mo as SlateRenderLeafProps, no as SlateHTMLProps, oo as SlateText, po as SlateRenderElementProps, qa as getNodeDataAttributes, ro as SlateLeaf, so as SlateTextProps, to as SlateElementProps, uo as StyledSlateTextProps, vo as serializeHtml, wo as pipeRenderTextStatic, xo as PlateStatic, yo as ElementStatic, za as stripSlateDataAttributes } from "../index-fLEDAjcC";
+import { $a as getEditorDOMFromHtmlString, Ao as SlateRenderElement, Ba as stripHtmlClassNames, Co as SlateRenderText, Do as pipeRenderLeafStatic, Eo as SlateRenderLeaf, Ga as getSelectedDomBlocks, Ha as isSelectOutside, Ja as getPluginDataAttributes, Ka as getRenderNodeStaticProps, Oo as pluginRenderLeafStatic, Qa as createStaticEditor, So as PlateStaticProps, To as pluginRenderTextStatic, Ua as getSelectedDomNode, Va as pipeDecorate, Wa as getSelectedDomFragment, Xa as getStaticPlugins, Ya as createStaticString, Za as ViewPlugin, _o as SerializeHtmlOptions, ao as SlateNodeProps, bo as LeafStatic, co as StyledSlateElementProps, do as useNodeAttributes, eo as SlateElement, fo as BoxStaticProps, go as SlateRenderTextProps, ho as SlateRenderNodeProps, io as SlateLeafProps, jo as pluginRenderElementStatic, ko as pipeRenderElementStatic, lo as StyledSlateLeafProps, mo as SlateRenderLeafProps, no as SlateHTMLProps, oo as SlateText, po as SlateRenderElementProps, qa as getNodeDataAttributes, ro as SlateLeaf, so as SlateTextProps, to as SlateElementProps, uo as StyledSlateTextProps, vo as serializeHtml, wo as pipeRenderTextStatic, xo as PlateStatic, yo as ElementStatic, za as stripSlateDataAttributes } from "../index-CtgFx8a9";
 export { BoxStaticProps, ElementStatic, LeafStatic, PlateStatic, PlateStaticProps, SerializeHtmlOptions, SlateElement, SlateElementProps, SlateHTMLProps, SlateLeaf, SlateLeafProps, SlateNodeProps, SlateRenderElement, SlateRenderElementProps, SlateRenderLeaf, SlateRenderLeafProps, SlateRenderNodeProps, SlateRenderText, SlateRenderTextProps, SlateText, SlateTextProps, StyledSlateElementProps, StyledSlateLeafProps, StyledSlateTextProps, ViewPlugin, createStaticEditor, createStaticString, getEditorDOMFromHtmlString, getNodeDataAttributes, getPluginDataAttributes, getRenderNodeStaticProps, getSelectedDomBlocks, getSelectedDomFragment, getSelectedDomNode, getStaticPlugins, isSelectOutside, pipeDecorate, pipeRenderElementStatic, pipeRenderLeafStatic, pipeRenderTextStatic, pluginRenderElementStatic, pluginRenderLeafStatic, pluginRenderTextStatic, serializeHtml, stripHtmlClassNames, stripSlateDataAttributes, useNodeAttributes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-core",
-  "version": "53.4.7",
+  "version": "53.4.8",
   "description": "The core of Plate – a plugin system for slate",
   "keywords": [
     "contentEditable",
@@ -53,9 +53,8 @@
     "zustand-x": "6.2.1",
     "@platejs/slate": "npm:@lofcz/platejs-slate@53.4.6",
     "@udecode/react-hotkeys": "npm:@lofcz/udecode-react-hotkeys@52.3.6",
-    "@udecode/react-utils": "npm:@lofcz/udecode-react-utils@52.3.4",
     "@udecode/utils": "npm:@lofcz/udecode-utils@52.3.4",
-    "jotai-x": "npm:@lofcz/jotai-x@2.4.0"
+    "@udecode/react-utils": "npm:@lofcz/udecode-react-utils@52.3.4"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
@@ -68,7 +67,8 @@
   "module": "./dist/index.js",
   "devDependencies": {
     "mutative": "^1.1.0",
-    "@plate/scripts": "1.0.0"
+    "@plate/scripts": "1.0.0",
+    "jotai-x": "npm:@lofcz/jotai-x@2.4.0"
   },
   "scripts": {
     "brl": "plate-pkg p:brl",