@delmaredigital/payload-puck 0.6.12 → 0.6.14

package/dist/editor/components/VersionHistory.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useCallback, useEffect, useRef, memo } from 'react';
-import { History, Loader2, Check, RotateCcw, X, ChevronDown, } from 'lucide-react';
+import { History, Loader2, Check, RotateCcw, X, ChevronDown } from 'lucide-react';
 // Shared styles
 const styles = {
     container: {
-        position: 'relative',
+        position: 'relative'
     },
     button: {
         display: 'inline-flex',
@@ -19,23 +19,23 @@ const styles = {
         backgroundColor: 'var(--theme-bg)',
         color: 'var(--theme-elevation-700)',
         border: '1px solid var(--theme-elevation-200)',
-        cursor: 'pointer',
+        cursor: 'pointer'
     },
     buttonDisabled: {
         opacity: 0.5,
-        cursor: 'not-allowed',
+        cursor: 'not-allowed'
     },
     icon: {
         width: '16px',
         height: '16px',
         marginRight: '4px',
-        flexShrink: 0,
+        flexShrink: 0
     },
     iconSmall: {
         width: '12px',
         height: '12px',
         marginLeft: '4px',
-        flexShrink: 0,
+        flexShrink: 0
     },
     dropdown: {
         position: 'absolute',
@@ -49,19 +49,19 @@ const styles = {
         zIndex: 50,
         width: '320px',
         maxHeight: '400px',
-        overflow: 'hidden',
+        overflow: 'hidden'
     },
     header: {
         borderBottom: '1px solid var(--theme-elevation-200)',
         display: 'flex',
         alignItems: 'center',
         justifyContent: 'space-between',
-        padding: '12px 16px',
+        padding: '12px 16px'
     },
     headerTitle: {
         fontWeight: 500,
         fontSize: '14px',
-        color: 'var(--theme-elevation-900)',
+        color: 'var(--theme-elevation-900)'
     },
     closeButton: {
         color: 'var(--theme-elevation-400)',
@@ -69,38 +69,38 @@ const styles = {
         padding: '4px',
         background: 'none',
         border: 'none',
-        cursor: 'pointer',
+        cursor: 'pointer'
     },
     content: {
         maxHeight: '340px',
-        overflowY: 'auto',
+        overflowY: 'auto'
     },
     loadingContainer: {
         display: 'flex',
         alignItems: 'center',
         justifyContent: 'center',
-        padding: '32px',
+        padding: '32px'
     },
     loadingIcon: {
         width: '20px',
         height: '20px',
         color: 'var(--theme-elevation-400)',
-        animation: 'spin 1s linear infinite',
+        animation: 'spin 1s linear infinite'
     },
     errorText: {
         fontSize: '14px',
         color: 'var(--theme-error-600)',
         padding: '16px',
-        textAlign: 'center',
+        textAlign: 'center'
     },
     emptyText: {
         fontSize: '14px',
         color: 'var(--theme-elevation-500)',
         padding: '16px',
-        textAlign: 'center',
+        textAlign: 'center'
     },
     listContainer: {
-        padding: '8px',
+        padding: '8px'
     },
     versionItem: {
         borderRadius: '6px',
@@ -109,21 +109,21 @@ const styles = {
         alignItems: 'center',
         justifyContent: 'space-between',
         padding: '10px 12px',
-        gap: '12px',
+        gap: '12px'
     },
     versionInfo: {
         flex: 1,
-        minWidth: 0,
+        minWidth: 0
     },
     versionHeader: {
         display: 'flex',
         alignItems: 'center',
-        gap: '8px',
+        gap: '8px'
     },
     versionDate: {
         fontSize: '14px',
         fontWeight: 500,
-        color: 'var(--theme-elevation-900)',
+        color: 'var(--theme-elevation-900)'
     },
     badgeCurrent: {
         fontSize: '12px',
@@ -131,7 +131,7 @@ const styles = {
         borderRadius: '9999px',
         padding: '2px 8px',
         backgroundColor: 'var(--theme-elevation-100)',
-        color: 'var(--theme-elevation-700)',
+        color: 'var(--theme-elevation-700)'
     },
     badgePublished: {
         fontSize: '12px',
@@ -139,16 +139,16 @@ const styles = {
         borderRadius: '9999px',
         padding: '2px 8px',
         backgroundColor: 'var(--theme-success-100)',
-        color: 'var(--theme-success-700)',
+        color: 'var(--theme-success-700)'
     },
     autosaveText: {
         fontSize: '12px',
-        color: 'var(--theme-elevation-400)',
+        color: 'var(--theme-elevation-400)'
     },
     versionDetails: {
         fontSize: '12px',
         color: 'var(--theme-elevation-500)',
-        marginTop: '2px',
+        marginTop: '2px'
     },
     restoreButton: {
         fontSize: '12px',
@@ -162,25 +162,24 @@ const styles = {
         flexShrink: 0,
         background: 'none',
         border: 'none',
-        cursor: 'pointer',
+        cursor: 'pointer'
     },
     restoreButtonDisabled: {
         opacity: 0.5,
-        cursor: 'not-allowed',
+        cursor: 'not-allowed'
     },
     checkIcon: {
         width: '16px',
         height: '16px',
         color: 'var(--theme-elevation-400)',
-        flexShrink: 0,
-    },
+        flexShrink: 0
+    }
 };
 /**
  * Version history dropdown for the Puck editor
  *
  * Shows a list of previous versions with the ability to restore them.
- */
-export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint = '/api/puck/pages', onRestore, disabled, }) {
+ */ export const VersionHistory = /*#__PURE__*/ memo(function VersionHistory({ pageId, apiEndpoint = '/api/puck/pages', onRestore, disabled }) {
     const [isOpen, setIsOpen] = useState(false);
     const [isLoading, setIsLoading] = useState(false);
     const [isRestoring, setIsRestoring] = useState(false);
@@ -190,32 +189,34 @@ export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint
     const [hoveredIndex, setHoveredIndex] = useState(null);
     const dropdownRef = useRef(null);
     // Check if versions endpoint is available on mount
-    useEffect(() => {
+    useEffect(()=>{
         async function checkAvailability() {
             try {
                 const response = await fetch(`${apiEndpoint}/${pageId}/versions?limit=1`, {
-                    method: 'GET',
+                    method: 'GET'
                 });
                 setIsAvailable(response.status !== 404);
-            }
-            catch {
+            } catch  {
                 setIsAvailable(false);
             }
         }
         checkAvailability();
-    }, [apiEndpoint, pageId]);
+    }, [
+        apiEndpoint,
+        pageId
+    ]);
     // Close on outside click
-    useEffect(() => {
+    useEffect(()=>{
         function handleClickOutside(event) {
             if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
                 setIsOpen(false);
             }
         }
         document.addEventListener('mousedown', handleClickOutside);
-        return () => document.removeEventListener('mousedown', handleClickOutside);
+        return ()=>document.removeEventListener('mousedown', handleClickOutside);
     }, []);
     // Fetch versions when dropdown opens
-    const fetchVersions = useCallback(async () => {
+    const fetchVersions = useCallback(async ()=>{
         setIsLoading(true);
         setError(null);
         try {
@@ -225,23 +226,27 @@ export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint
             }
             const data = await response.json();
             setVersions(data.docs || []);
-        }
-        catch (err) {
+        } catch (err) {
             setError(err instanceof Error ? err.message : 'Failed to load versions');
             console.error('Error fetching versions:', err);
-        }
-        finally {
+        } finally{
             setIsLoading(false);
         }
-    }, [apiEndpoint, pageId]);
+    }, [
+        apiEndpoint,
+        pageId
+    ]);
     // Fetch versions when opening
-    useEffect(() => {
+    useEffect(()=>{
         if (isOpen) {
             fetchVersions();
         }
-    }, [isOpen, fetchVersions]);
+    }, [
+        isOpen,
+        fetchVersions
+    ]);
     // Handle version restore
-    const handleRestore = useCallback(async (version) => {
+    const handleRestore = useCallback(async (version)=>{
         if (!confirm(`Restore this version from ${formatDate(version.updatedAt)}? This will overwrite current changes.`)) {
             return;
         }
@@ -249,8 +254,12 @@ export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint
         try {
             const response = await fetch(`${apiEndpoint}/${pageId}/versions`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ versionId: version.id }),
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    versionId: version.id
+                })
             });
             if (!response.ok) {
                 throw new Error('Failed to restore version');
@@ -258,15 +267,17 @@ export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint
             onRestore?.(version);
             setIsOpen(false);
             window.location.reload();
-        }
-        catch (err) {
+        } catch (err) {
             setError(err instanceof Error ? err.message : 'Failed to restore version');
             console.error('Error restoring version:', err);
-        }
-        finally {
+        } finally{
             setIsRestoring(false);
         }
-    }, [apiEndpoint, pageId, onRestore]);
+    }, [
+        apiEndpoint,
+        pageId,
+        onRestore
+    ]);
     // Format date for display
     function formatDate(dateStr) {
         const date = new Date(dateStr);
@@ -275,34 +286,169 @@ export const VersionHistory = memo(function VersionHistory({ pageId, apiEndpoint
         const diffMins = Math.floor(diffMs / 60000);
         const diffHours = Math.floor(diffMs / 3600000);
         const diffDays = Math.floor(diffMs / 86400000);
-        if (diffMins < 1)
-            return 'Just now';
-        if (diffMins < 60)
-            return `${diffMins}m ago`;
-        if (diffHours < 24)
-            return `${diffHours}h ago`;
-        if (diffDays < 7)
-            return `${diffDays}d ago`;
+        if (diffMins < 1) return 'Just now';
+        if (diffMins < 60) return `${diffMins}m ago`;
+        if (diffHours < 24) return `${diffHours}h ago`;
+        if (diffDays < 7) return `${diffDays}d ago`;
         return date.toLocaleDateString();
     }
     // Format time for display
     function formatTime(dateStr) {
         const date = new Date(dateStr);
-        return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+        return date.toLocaleTimeString([], {
+            hour: '2-digit',
+            minute: '2-digit'
+        });
     }
     // Don't render if versions endpoint is not available or still checking
     if (isAvailable !== true) {
         return null;
     }
-    return (_jsxs("div", { ref: dropdownRef, style: styles.container, children: [_jsxs("button", { type: "button", onClick: () => setIsOpen(!isOpen), disabled: disabled, style: {
+    return /*#__PURE__*/ _jsxs("div", {
+        ref: dropdownRef,
+        style: styles.container,
+        children: [
+            /*#__PURE__*/ _jsxs("button", {
+                type: "button",
+                onClick: ()=>setIsOpen(!isOpen),
+                disabled: disabled,
+                style: {
                     ...styles.button,
-                    ...(disabled ? styles.buttonDisabled : {}),
-                }, children: [_jsx(History, { style: styles.icon }), "History", _jsx(ChevronDown, { style: styles.iconSmall })] }), isOpen && (_jsxs("div", { style: styles.dropdown, children: [_jsxs("div", { style: styles.header, children: [_jsx("span", { style: styles.headerTitle, children: "Version History" }), _jsx("button", { type: "button", onClick: () => setIsOpen(false), style: styles.closeButton, children: _jsx(X, { style: { width: '16px', height: '16px' } }) })] }), _jsx("div", { style: styles.content, children: isLoading ? (_jsx("div", { style: styles.loadingContainer, children: _jsx(Loader2, { style: styles.loadingIcon }) })) : error ? (_jsx("div", { style: styles.errorText, children: error })) : versions.length === 0 ? (_jsx("div", { style: styles.emptyText, children: "No version history available" })) : (_jsx("div", { style: styles.listContainer, children: versions.map((version, index) => (_jsxs("div", { style: {
-                                    ...styles.versionItem,
-                                    backgroundColor: hoveredIndex === index ? 'var(--theme-elevation-50)' : 'transparent',
-                                }, onMouseEnter: () => setHoveredIndex(index), onMouseLeave: () => setHoveredIndex(null), children: [_jsxs("div", { style: styles.versionInfo, children: [_jsxs("div", { style: styles.versionHeader, children: [_jsx("span", { style: styles.versionDate, children: formatDate(version.updatedAt) }), index === 0 && (_jsx("span", { style: styles.badgeCurrent, children: "Current" })), version.version._status === 'published' && (_jsx("span", { style: styles.badgePublished, children: "Published" })), version.autosave && (_jsx("span", { style: styles.autosaveText, title: "Autosaved", children: "(auto)" }))] }), _jsxs("div", { style: styles.versionDetails, children: [formatTime(version.updatedAt), version.version.title && (_jsxs("span", { children: [" \u00B7 ", version.version.title] }))] })] }), index > 0 && (_jsxs("button", { type: "button", onClick: () => handleRestore(version), disabled: isRestoring, style: {
-                                            ...styles.restoreButton,
-                                            ...(isRestoring ? styles.restoreButtonDisabled : {}),
-                                        }, children: [isRestoring ? (_jsx(Loader2, { style: { width: '12px', height: '12px', animation: 'spin 1s linear infinite' } })) : (_jsx(RotateCcw, { style: { width: '12px', height: '12px' } })), "Restore"] })), index === 0 && (_jsx("span", { style: { flexShrink: 0 }, children: _jsx(Check, { style: styles.checkIcon }) }))] }, version.id))) })) })] }))] }));
+                    ...disabled ? styles.buttonDisabled : {}
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(History, {
+                        style: styles.icon
+                    }),
+                    "History",
+                    /*#__PURE__*/ _jsx(ChevronDown, {
+                        style: styles.iconSmall
+                    })
+                ]
+            }),
+            isOpen && /*#__PURE__*/ _jsxs("div", {
+                style: styles.dropdown,
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        style: styles.header,
+                        children: [
+                            /*#__PURE__*/ _jsx("span", {
+                                style: styles.headerTitle,
+                                children: "Version History"
+                            }),
+                            /*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                onClick: ()=>setIsOpen(false),
+                                style: styles.closeButton,
+                                children: /*#__PURE__*/ _jsx(X, {
+                                    style: {
+                                        width: '16px',
+                                        height: '16px'
+                                    }
+                                })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        style: styles.content,
+                        children: isLoading ? /*#__PURE__*/ _jsx("div", {
+                            style: styles.loadingContainer,
+                            children: /*#__PURE__*/ _jsx(Loader2, {
+                                style: styles.loadingIcon
+                            })
+                        }) : error ? /*#__PURE__*/ _jsx("div", {
+                            style: styles.errorText,
+                            children: error
+                        }) : versions.length === 0 ? /*#__PURE__*/ _jsx("div", {
+                            style: styles.emptyText,
+                            children: "No version history available"
+                        }) : /*#__PURE__*/ _jsx("div", {
+                            style: styles.listContainer,
+                            children: versions.map((version, index)=>/*#__PURE__*/ _jsxs("div", {
+                                    style: {
+                                        ...styles.versionItem,
+                                        backgroundColor: hoveredIndex === index ? 'var(--theme-elevation-50)' : 'transparent'
+                                    },
+                                    onMouseEnter: ()=>setHoveredIndex(index),
+                                    onMouseLeave: ()=>setHoveredIndex(null),
+                                    children: [
+                                        /*#__PURE__*/ _jsxs("div", {
+                                            style: styles.versionInfo,
+                                            children: [
+                                                /*#__PURE__*/ _jsxs("div", {
+                                                    style: styles.versionHeader,
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx("span", {
+                                                            style: styles.versionDate,
+                                                            children: formatDate(version.updatedAt)
+                                                        }),
+                                                        index === 0 && /*#__PURE__*/ _jsx("span", {
+                                                            style: styles.badgeCurrent,
+                                                            children: "Current"
+                                                        }),
+                                                        version.version._status === 'published' && /*#__PURE__*/ _jsx("span", {
+                                                            style: styles.badgePublished,
+                                                            children: "Published"
+                                                        }),
+                                                        version.autosave && /*#__PURE__*/ _jsx("span", {
+                                                            style: styles.autosaveText,
+                                                            title: "Autosaved",
+                                                            children: "(auto)"
+                                                        })
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsxs("div", {
+                                                    style: styles.versionDetails,
+                                                    children: [
+                                                        formatTime(version.updatedAt),
+                                                        version.version.title && /*#__PURE__*/ _jsxs("span", {
+                                                            children: [
+                                                                "· ",
+                                                                version.version.title
+                                                            ]
+                                                        })
+                                                    ]
+                                                })
+                                            ]
+                                        }),
+                                        index > 0 && /*#__PURE__*/ _jsxs("button", {
+                                            type: "button",
+                                            onClick: ()=>handleRestore(version),
+                                            disabled: isRestoring,
+                                            style: {
+                                                ...styles.restoreButton,
+                                                ...isRestoring ? styles.restoreButtonDisabled : {}
+                                            },
+                                            children: [
+                                                isRestoring ? /*#__PURE__*/ _jsx(Loader2, {
+                                                    style: {
+                                                        width: '12px',
+                                                        height: '12px',
+                                                        animation: 'spin 1s linear infinite'
+                                                    }
+                                                }) : /*#__PURE__*/ _jsx(RotateCcw, {
+                                                    style: {
+                                                        width: '12px',
+                                                        height: '12px'
+                                                    }
+                                                }),
+                                                "Restore"
+                                            ]
+                                        }),
+                                        index === 0 && /*#__PURE__*/ _jsx("span", {
+                                            style: {
+                                                flexShrink: 0
+                                            },
+                                            children: /*#__PURE__*/ _jsx(Check, {
+                                                style: styles.checkIcon
+                                            })
+                                        })
+                                    ]
+                                }, version.id))
+                        })
+                    })
+                ]
+            })
+        ]
+    });
 });
-//# sourceMappingURL=VersionHistory.js.map

package/dist/editor/hooks/useDarkMode.d.ts

@@ -34,4 +34,3 @@ export interface UseDarkModeReturn {
  * ```
  */
 export declare function useDarkMode(): UseDarkModeReturn;
-//# sourceMappingURL=useDarkMode.d.ts.map

package/dist/editor/hooks/useDarkMode.js

@@ -17,44 +17,52 @@ import { useState, useEffect, useCallback } from 'react';
  *   // Apply dark mode styles
  * }
  * ```
- */
-export function useDarkMode() {
+ */ export function useDarkMode() {
     const [state, setState] = useState({
         isDarkMode: false,
-        source: 'none',
+        source: 'none'
     });
     // Check for dark mode class on document element
-    const checkDarkModeClass = useCallback(() => {
-        if (typeof document === 'undefined')
-            return false;
+    const checkDarkModeClass = useCallback(()=>{
+        if (typeof document === 'undefined') return false;
         return document.documentElement.classList.contains('dark');
     }, []);
     // Check for OS dark mode preference
-    const checkMediaQuery = useCallback(() => {
-        if (typeof window === 'undefined')
-            return false;
+    const checkMediaQuery = useCallback(()=>{
+        if (typeof window === 'undefined') return false;
         return window.matchMedia('(prefers-color-scheme: dark)').matches;
     }, []);
     // Compute current dark mode state
-    const computeState = useCallback(() => {
+    const computeState = useCallback(()=>{
         // Priority 1: Check for .dark class (PayloadCMS)
         if (checkDarkModeClass()) {
-            return { isDarkMode: true, source: 'class' };
+            return {
+                isDarkMode: true,
+                source: 'class'
+            };
         }
         // Priority 2: Check OS preference
         if (checkMediaQuery()) {
-            return { isDarkMode: true, source: 'media-query' };
+            return {
+                isDarkMode: true,
+                source: 'media-query'
+            };
         }
-        return { isDarkMode: false, source: 'none' };
-    }, [checkDarkModeClass, checkMediaQuery]);
-    useEffect(() => {
+        return {
+            isDarkMode: false,
+            source: 'none'
+        };
+    }, [
+        checkDarkModeClass,
+        checkMediaQuery
+    ]);
+    useEffect(()=>{
         // Set initial state
         setState(computeState());
         // Watch for class changes on document element
-        const observer = new MutationObserver((mutations) => {
-            for (const mutation of mutations) {
-                if (mutation.type === 'attributes' &&
-                    mutation.attributeName === 'class') {
+        const observer = new MutationObserver((mutations)=>{
+            for (const mutation of mutations){
+                if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
                     setState(computeState());
                     break;
                 }
@@ -62,19 +70,22 @@ export function useDarkMode() {
         });
         observer.observe(document.documentElement, {
             attributes: true,
-            attributeFilter: ['class'],
+            attributeFilter: [
+                'class'
+            ]
         });
         // Watch for OS preference changes
         const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
-        const handleMediaChange = () => {
+        const handleMediaChange = ()=>{
             setState(computeState());
         };
         mediaQuery.addEventListener('change', handleMediaChange);
-        return () => {
+        return ()=>{
             observer.disconnect();
             mediaQuery.removeEventListener('change', handleMediaChange);
         };
-    }, [computeState]);
+    }, [
+        computeState
+    ]);
     return state;
 }
-//# sourceMappingURL=useDarkMode.js.map

package/dist/editor/hooks/useUnsavedChanges.d.ts

@@ -24,4 +24,3 @@ export interface UseUnsavedChangesReturn {
  * ```
  */
 export declare function useUnsavedChanges(): UseUnsavedChangesReturn;
-//# sourceMappingURL=useUnsavedChanges.d.ts.map

package/dist/editor/hooks/useUnsavedChanges.js

@@ -19,16 +19,15 @@ import { useState, useEffect, useCallback, useRef } from 'react';
  *   markClean()
  * }
  * ```
- */
-export function useUnsavedChanges() {
+ */ export function useUnsavedChanges() {
     const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
     // Use a ref to track the latest value for the beforeunload handler
     // This ensures the handler always checks the current value, not a stale closure
     const hasUnsavedChangesRef = useRef(hasUnsavedChanges);
     hasUnsavedChangesRef.current = hasUnsavedChanges;
     // Register beforeunload handler once (uses ref for latest value)
-    useEffect(() => {
-        const handleBeforeUnload = (e) => {
+    useEffect(()=>{
+        const handleBeforeUnload = (e)=>{
             if (hasUnsavedChangesRef.current) {
                 e.preventDefault();
                 // Modern browsers ignore custom messages but still show a warning
@@ -36,20 +35,19 @@ export function useUnsavedChanges() {
             }
         };
         window.addEventListener('beforeunload', handleBeforeUnload);
-        return () => window.removeEventListener('beforeunload', handleBeforeUnload);
+        return ()=>window.removeEventListener('beforeunload', handleBeforeUnload);
     }, []);
-    const markClean = useCallback(() => {
+    const markClean = useCallback(()=>{
         hasUnsavedChangesRef.current = false; // Update ref immediately for beforeunload
         setHasUnsavedChanges(false);
     }, []);
-    const markDirty = useCallback(() => {
+    const markDirty = useCallback(()=>{
         hasUnsavedChangesRef.current = true; // Update ref immediately for beforeunload
         setHasUnsavedChanges(true);
     }, []);
     return {
         hasUnsavedChanges,
         markClean,
-        markDirty,
+        markDirty
     };
 }
-//# sourceMappingURL=useUnsavedChanges.js.map

package/dist/editor/index.d.ts

@@ -59,4 +59,3 @@ export { useUnsavedChanges, type UseUnsavedChangesReturn } from './hooks/useUnsa
 export { useDarkMode, type UseDarkModeReturn, type DarkModeSource } from './hooks/useDarkMode.js';
 export { headingAnalyzer } from './plugins/index.js';
 export { createVersionHistoryPlugin, type VersionHistoryPluginOptions, VersionHistoryPanel, type VersionHistoryPanelProps, } from './plugins/index.js';
-//# sourceMappingURL=index.d.ts.map