@unsetsoft/ryunixjs 1.2.3-canary.10 → 1.2.3-canary.11

package/dist/Ryunix.umd.js

@@ -593,34 +593,6 @@
     });
   };
 
-  const updateFunctionComponent = (fiber) => {
-    const state = getState();
-    state.wipFiber = fiber;
-    state.hookIndex = 0;
-    state.wipFiber.hooks = [];
-
-    const children = [fiber.type(fiber.props)];
-
-    if (fiber.type._contextId && fiber.props.value !== undefined) {
-      fiber._contextId = fiber.type._contextId;
-      fiber._contextValue = fiber.props.value;
-    }
-
-    reconcileChildren(fiber, children);
-  };
-
-  const updateHostComponent = (fiber) => {
-    if (!fiber.dom) {
-      fiber.dom = createDom(fiber);
-    }
-    const children = fiber.props?.children || [];
-    reconcileChildren(fiber, children);
-  };
-
-  const Image = ({ src, ...props }) => {
-    return createElement('img', { ...props, src })
-  };
-
   /**
    * Priority levels for updates
    */
@@ -634,371 +606,130 @@
 
   Priority.NORMAL;
 
-  /**
-   * Performance profiler for Ryunix
-   */
-  class Profiler {
-    constructor() {
-      this.enabled = process.env.NODE_ENV !== 'production';
-      this.measures = new Map();
-      this.renderTimes = [];
-      this.maxSamples = 100;
-    }
-
-    startMeasure(name) {
-      if (!this.enabled) return
-      this.measures.set(name, performance.now());
-    }
-
-    endMeasure(name) {
-      if (!this.enabled) return
-      const start = this.measures.get(name);
-      if (!start) return
-
-      const duration = performance.now() - start;
-      this.measures.delete(name);
-
-      return duration
+  const validateHookCall = () => {
+    const state = getState();
+    if (!state.wipFiber) {
+      throw new Error(
+        'Hooks can only be called inside the body of a function component.',
+      )
     }
-
-    recordRender(componentName, duration) {
-      if (!this.enabled) return
-
-      this.renderTimes.push({
-        component: componentName,
-        duration,
-        timestamp: Date.now(),
-      });
-
-      if (this.renderTimes.length > this.maxSamples) {
-        this.renderTimes.shift();
-      }
+    if (!Array.isArray(state.wipFiber.hooks)) {
+      state.wipFiber.hooks = [];
     }
+  };
 
-    getStats() {
-      if (!this.enabled) return null
+  const haveDepsChanged = (oldDeps, newDeps) => {
+    if (!oldDeps || !newDeps) return true
+    if (oldDeps.length !== newDeps.length) return true
+    return oldDeps.some((dep, i) => !Object.is(dep, newDeps[i]))
+  };
 
-      const total = this.renderTimes.reduce((sum, r) => sum + r.duration, 0);
-      const avg = total / this.renderTimes.length;
-      const max = Math.max(...this.renderTimes.map((r) => r.duration));
-      const min = Math.min(...this.renderTimes.map((r) => r.duration));
+  const useStore = (initialState) => {
+    const reducer = (state, action) =>
+      is.function(action) ? action(state) : action;
+    return useReducer(reducer, initialState)
+  };
 
-      return { total, avg, max, min, count: this.renderTimes.length }
-    }
+  const useReducer = (reducer, initialState, init) => {
+    validateHookCall();
 
-    getSlowestComponents(limit = 10) {
-      if (!this.enabled) return []
+    const state = getState();
+    const { wipFiber, hookIndex } = state;
+    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
 
-      const byComponent = new Map();
+    const hook = {
+      hookID: hookIndex,
+      type: RYUNIX_TYPES.RYUNIX_STORE,
+      state: oldHook ? oldHook.state : init ? init(initialState) : initialState,
+      queue: [], // Siempre nueva cola vacía
+    };
 
-      this.renderTimes.forEach(({ component, duration }) => {
-        if (!byComponent.has(component)) {
-          byComponent.set(component, { total: 0, count: 0, max: 0 });
+    // Procesar acciones del render anterior
+    if (oldHook?.queue) {
+      oldHook.queue.forEach((action) => {
+        try {
+          hook.state = reducer(hook.state, action);
+        } catch (error) {
+          if (process.env.NODE_ENV !== 'production') {
+            console.error('Error in reducer:', error);
+          }
         }
-        const stats = byComponent.get(component);
-        stats.total += duration;
-        stats.count++;
-        stats.max = Math.max(stats.max, duration);
       });
-
-      return Array.from(byComponent.entries())
-        .map(([name, stats]) => ({
-          name,
-          avg: stats.total / stats.count,
-          max: stats.max,
-          count: stats.count,
-        }))
-        .sort((a, b) => b.avg - a.avg)
-        .slice(0, limit)
     }
 
-    logStats() {
-      if (!this.enabled) return
+    const dispatch = (action) => {
+      if (action === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn('dispatch called with undefined action');
+        }
+        return
+      }
 
-      const stats = this.getStats();
-      if (!stats) return
+      hook.queue.push(action);
 
-      console.group('🔍 Ryunix Performance Stats');
-      console.log(`Total renders: ${stats.count}`);
-      console.log(`Avg render time: ${stats.avg.toFixed(2)}ms`);
-      console.log(
-        `Min: ${stats.min.toFixed(2)}ms | Max: ${stats.max.toFixed(2)}ms`,
-      );
+      const currentState = getState();
+      currentState.wipRoot = {
+        dom: currentState.currentRoot.dom,
+        props: currentState.currentRoot.props,
+        alternate: currentState.currentRoot,
+      };
+      currentState.deletions = [];
+      currentState.hookIndex = 0;
+      scheduleWork(currentState.wipRoot);
+    };
 
-      const slowest = this.getSlowestComponents(5);
-      if (slowest.length > 0) {
-        console.log('\n⚠️  Slowest components:');
-        slowest.forEach((comp, i) => {
-          console.log(
-            `${i + 1}. ${comp.name}: ${comp.avg.toFixed(2)}ms avg (${comp.count} renders)`,
-          );
-        });
-      }
-      console.groupEnd();
-    }
+    wipFiber.hooks[hookIndex] = hook;
+    state.hookIndex++;
+    return [hook.state, dispatch]
+  };
 
-    clear() {
-      this.renderTimes = [];
-      this.measures.clear();
-    }
+  const useEffect = (callback, deps) => {
+    validateHookCall();
 
-    enable() {
-      this.enabled = true;
+    if (!is.function(callback)) {
+      throw new Error('useEffect callback must be a function')
     }
-
-    disable() {
-      this.enabled = false;
+    if (deps !== undefined && !Array.isArray(deps)) {
+      throw new Error('useEffect dependencies must be an array or undefined')
     }
-  }
 
-  // Global profiler instance
-  const profiler = new Profiler();
+    const state = getState();
+    const { wipFiber, hookIndex } = state;
+    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
+    const hasChanged = haveDepsChanged(oldHook?.deps, deps);
 
-  /**
-   * Hook to profile component render
-   */
-  const useProfiler = (componentName) => {
-    const startTime = performance.now();
+    const hook = {
+      hookID: hookIndex,
+      type: RYUNIX_TYPES.RYUNIX_EFFECT,
+      deps,
+      effect: hasChanged ? callback : null,
+      cancel: oldHook?.cancel,
+    };
 
-    return () => {
-      const duration = performance.now() - startTime;
-      profiler.recordRender(componentName, duration);
-    }
+    wipFiber.hooks[hookIndex] = hook;
+    state.hookIndex++;
   };
 
-  /**
-   * HOC to profile component
-   */
-  const withProfiler = (Component, name) => {
-    return (props) => {
-      profiler.startMeasure(name);
-      const result = Component(props);
-      const duration = profiler.endMeasure(name);
-      if (duration) profiler.recordRender(name, duration);
-      return result
-    }
-  };
+  const useRef = (initialValue) => {
+    validateHookCall();
 
-  const workLoop = (deadline) => {
     const state = getState();
-    let shouldYield = false;
-
-    while (state.nextUnitOfWork && !shouldYield) {
-      state.nextUnitOfWork = performUnitOfWork(state.nextUnitOfWork);
-      shouldYield = deadline.timeRemaining() < 1;
-    }
+    const { wipFiber, hookIndex } = state;
+    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
 
-    if (!state.nextUnitOfWork && state.wipRoot) {
-      commitRoot();
-    }
+    const hook = {
+      hookID: hookIndex,
+      type: RYUNIX_TYPES.RYUNIX_REF,
+      value: oldHook ? oldHook.value : { current: initialValue },
+    };
 
-    requestIdleCallback(workLoop);
+    wipFiber.hooks[hookIndex] = hook;
+    state.hookIndex++;
+    return hook.value
   };
 
-  requestIdleCallback(workLoop);
-
-  const performUnitOfWork = (fiber) => {
-    const componentName = fiber.type?.name || fiber.type?.displayName || 'Unknown';
-
-    profiler.startMeasure(componentName);
-
-    const isFunctionComponent = fiber.type instanceof Function;
-    if (isFunctionComponent) {
-      updateFunctionComponent(fiber);
-    } else {
-      updateHostComponent(fiber);
-    }
-
-    const duration = profiler.endMeasure(componentName);
-    if (duration) profiler.recordRender(componentName, duration);
-
-    if (fiber.child) {
-      return fiber.child
-    }
-    let nextFiber = fiber;
-    while (nextFiber) {
-      if (nextFiber.sibling) {
-        return nextFiber.sibling
-      }
-      nextFiber = nextFiber.parent;
-    }
-  };
-
-  const scheduleWork = (root, priority = Priority.NORMAL) => {
-    const state = getState();
-    state.nextUnitOfWork = root;
-    state.wipRoot = root;
-    state.deletions = [];
-    state.hookIndex = 0;
-    state.effects = [];
-
-    // Higher priority = faster scheduling
-    if (priority <= Priority.USER_BLOCKING) {
-      requestIdleCallback(workLoop);
-    } else {
-      setTimeout(() => requestIdleCallback(workLoop), 0);
-    }
-  };
-
-  const render = (element, container) => {
-    const state = getState();
-    state.wipRoot = {
-      dom: container,
-      props: {
-        children: [element],
-      },
-      alternate: state.currentRoot,
-    };
-
-    state.nextUnitOfWork = state.wipRoot;
-    state.deletions = [];
-    scheduleWork(state.wipRoot);
-    return state.wipRoot
-  };
-
-  const init = (MainElement, root = '__ryunix') => {
-    const state = getState();
-    state.containerRoot = document.getElementById(root);
-    const renderProcess = render(MainElement, state.containerRoot);
-    return renderProcess
-  };
-
-  const safeRender = (component, props, onError) => {
-    try {
-      return component(props)
-    } catch (error) {
-      if (process.env.NODE_ENV !== 'production') {
-        console.error('Component error:', error);
-      }
-      if (onError) onError(error);
-      return null
-    }
-  };
-
-  const validateHookCall = () => {
-    const state = getState();
-    if (!state.wipFiber) {
-      throw new Error(
-        'Hooks can only be called inside the body of a function component.',
-      )
-    }
-    if (!Array.isArray(state.wipFiber.hooks)) {
-      state.wipFiber.hooks = [];
-    }
-  };
-
-  const haveDepsChanged = (oldDeps, newDeps) => {
-    if (!oldDeps || !newDeps) return true
-    if (oldDeps.length !== newDeps.length) return true
-    return oldDeps.some((dep, i) => !Object.is(dep, newDeps[i]))
-  };
-
-  const useStore = (initialState) => {
-    const reducer = (state, action) =>
-      is.function(action) ? action(state) : action;
-    return useReducer(reducer, initialState)
-  };
-
-  const useReducer = (reducer, initialState, init) => {
-    validateHookCall();
-
-    const state = getState();
-    const { wipFiber, hookIndex } = state;
-    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
-
-    const hook = {
-      hookID: hookIndex,
-      type: RYUNIX_TYPES.RYUNIX_STORE,
-      state: oldHook ? oldHook.state : init ? init(initialState) : initialState,
-      queue: [], // Siempre nueva cola vacía
-    };
-
-    // Procesar acciones del render anterior
-    if (oldHook?.queue) {
-      oldHook.queue.forEach((action) => {
-        try {
-          hook.state = reducer(hook.state, action);
-        } catch (error) {
-          if (process.env.NODE_ENV !== 'production') {
-            console.error('Error in reducer:', error);
-          }
-        }
-      });
-    }
-
-    const dispatch = (action) => {
-      if (action === undefined) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn('dispatch called with undefined action');
-        }
-        return
-      }
-
-      hook.queue.push(action);
-
-      const currentState = getState();
-      currentState.wipRoot = {
-        dom: currentState.currentRoot.dom,
-        props: currentState.currentRoot.props,
-        alternate: currentState.currentRoot,
-      };
-      currentState.deletions = [];
-      currentState.hookIndex = 0;
-      scheduleWork(currentState.wipRoot);
-    };
-
-    wipFiber.hooks[hookIndex] = hook;
-    state.hookIndex++;
-    return [hook.state, dispatch]
-  };
-
-  const useEffect = (callback, deps) => {
-    validateHookCall();
-
-    if (!is.function(callback)) {
-      throw new Error('useEffect callback must be a function')
-    }
-    if (deps !== undefined && !Array.isArray(deps)) {
-      throw new Error('useEffect dependencies must be an array or undefined')
-    }
-
-    const state = getState();
-    const { wipFiber, hookIndex } = state;
-    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
-    const hasChanged = haveDepsChanged(oldHook?.deps, deps);
-
-    const hook = {
-      hookID: hookIndex,
-      type: RYUNIX_TYPES.RYUNIX_EFFECT,
-      deps,
-      effect: hasChanged ? callback : null,
-      cancel: oldHook?.cancel,
-    };
-
-    wipFiber.hooks[hookIndex] = hook;
-    state.hookIndex++;
-  };
-
-  const useRef = (initialValue) => {
-    validateHookCall();
-
-    const state = getState();
-    const { wipFiber, hookIndex } = state;
-    const oldHook = wipFiber.alternate?.hooks?.[hookIndex];
-
-    const hook = {
-      hookID: hookIndex,
-      type: RYUNIX_TYPES.RYUNIX_REF,
-      value: oldHook ? oldHook.value : { current: initialValue },
-    };
-
-    wipFiber.hooks[hookIndex] = hook;
-    state.hookIndex++;
-    return hook.value
-  };
-
-  const useMemo = (compute, deps) => {
-    validateHookCall();
+  const useMemo = (compute, deps) => {
+    validateHookCall();
 
     if (!is.function(compute)) {
       throw new Error('useMemo callback must be a function')
@@ -1367,6 +1098,349 @@
     useTransition: useTransition
   });
 
+  const updateFunctionComponent = (fiber) => {
+    const state = getState();
+    state.wipFiber = fiber;
+    state.hookIndex = 0;
+    state.wipFiber.hooks = [];
+
+    const children = [fiber.type(fiber.props)];
+
+    if (fiber.type._contextId && fiber.props.value !== undefined) {
+      fiber._contextId = fiber.type._contextId;
+      fiber._contextValue = fiber.props.value;
+    }
+
+    reconcileChildren(fiber, children);
+  };
+
+  const updateHostComponent = (fiber) => {
+    if (!fiber.dom) {
+      fiber.dom = createDom(fiber);
+    }
+    const children = fiber.props?.children || [];
+    reconcileChildren(fiber, children);
+  };
+
+  /* Image component */
+  const Image = ({ src, ...props }) => {
+    return createElement('img', { ...props, src })
+  };
+
+  const { Provider: MDXProvider, useContext: useMDXComponents } = createContext(
+    'ryunix.mdx',
+    {},
+  );
+
+  /**
+   * Get merged MDX components from context and provided components
+   * @param {Object} components - Additional components to merge
+   * @returns {Object} Merged components object
+   */
+  const getMDXComponents = (components) => {
+    const contextComponents = useMDXComponents();
+    return {
+      ...contextComponents,
+      ...components,
+    }
+  };
+
+  /**
+   * Default MDX components with Ryunix-optimized rendering
+   */
+  const defaultComponents = {
+    // Headings
+    h1: (props) => createElement('h1', { ...props }),
+    h2: (props) => createElement('h2', { ...props }),
+    h3: (props) => createElement('h3', { ...props }),
+    h4: (props) => createElement('h4', { ...props }),
+    h5: (props) => createElement('h5', { ...props }),
+    h6: (props) => createElement('h6', { ...props }),
+
+    // Text
+    p: (props) => createElement('p', { ...props }),
+    a: (props) => createElement('a', { ...props }),
+    strong: (props) => createElement('strong', { ...props }),
+    em: (props) => createElement('em', { ...props }),
+    code: (props) => createElement('code', { ...props }),
+
+    // Lists
+    ul: (props) => createElement('ul', { ...props }),
+    ol: (props) => createElement('ol', { ...props }),
+    li: (props) => createElement('li', { ...props }),
+
+    // Blocks
+    blockquote: (props) => createElement('blockquote', { ...props }),
+    pre: (props) => createElement('pre', { ...props }),
+    hr: (props) => createElement('hr', { ...props }),
+
+    // Tables
+    table: (props) => createElement('table', { ...props }),
+    thead: (props) => createElement('thead', { ...props }),
+    tbody: (props) => createElement('tbody', { ...props }),
+    tr: (props) => createElement('tr', { ...props }),
+    th: (props) => createElement('th', { ...props }),
+    td: (props) => createElement('td', { ...props }),
+
+    // Media
+    img: (props) => createElement('img', { ...props }),
+  };
+
+  /**
+   * MDX Wrapper component
+   * Provides default styling and components for MDX content
+   */
+  const MDXContent = ({ children, components = {} }) => {
+    const mergedComponents = getMDXComponents(components);
+
+    return createElement(
+      MDXProvider,
+      { value: mergedComponents },
+      createElement('div', null, children),
+    )
+  };
+
+  /**
+   * Performance profiler for Ryunix
+   */
+  class Profiler {
+    constructor() {
+      this.enabled = process.env.NODE_ENV !== 'production';
+      this.measures = new Map();
+      this.renderTimes = [];
+      this.maxSamples = 100;
+    }
+
+    startMeasure(name) {
+      if (!this.enabled) return
+      this.measures.set(name, performance.now());
+    }
+
+    endMeasure(name) {
+      if (!this.enabled) return
+      const start = this.measures.get(name);
+      if (!start) return
+
+      const duration = performance.now() - start;
+      this.measures.delete(name);
+
+      return duration
+    }
+
+    recordRender(componentName, duration) {
+      if (!this.enabled) return
+
+      this.renderTimes.push({
+        component: componentName,
+        duration,
+        timestamp: Date.now(),
+      });
+
+      if (this.renderTimes.length > this.maxSamples) {
+        this.renderTimes.shift();
+      }
+    }
+
+    getStats() {
+      if (!this.enabled) return null
+
+      const total = this.renderTimes.reduce((sum, r) => sum + r.duration, 0);
+      const avg = total / this.renderTimes.length;
+      const max = Math.max(...this.renderTimes.map((r) => r.duration));
+      const min = Math.min(...this.renderTimes.map((r) => r.duration));
+
+      return { total, avg, max, min, count: this.renderTimes.length }
+    }
+
+    getSlowestComponents(limit = 10) {
+      if (!this.enabled) return []
+
+      const byComponent = new Map();
+
+      this.renderTimes.forEach(({ component, duration }) => {
+        if (!byComponent.has(component)) {
+          byComponent.set(component, { total: 0, count: 0, max: 0 });
+        }
+        const stats = byComponent.get(component);
+        stats.total += duration;
+        stats.count++;
+        stats.max = Math.max(stats.max, duration);
+      });
+
+      return Array.from(byComponent.entries())
+        .map(([name, stats]) => ({
+          name,
+          avg: stats.total / stats.count,
+          max: stats.max,
+          count: stats.count,
+        }))
+        .sort((a, b) => b.avg - a.avg)
+        .slice(0, limit)
+    }
+
+    logStats() {
+      if (!this.enabled) return
+
+      const stats = this.getStats();
+      if (!stats) return
+
+      console.group('🔍 Ryunix Performance Stats');
+      console.log(`Total renders: ${stats.count}`);
+      console.log(`Avg render time: ${stats.avg.toFixed(2)}ms`);
+      console.log(
+        `Min: ${stats.min.toFixed(2)}ms | Max: ${stats.max.toFixed(2)}ms`,
+      );
+
+      const slowest = this.getSlowestComponents(5);
+      if (slowest.length > 0) {
+        console.log('\n⚠️  Slowest components:');
+        slowest.forEach((comp, i) => {
+          console.log(
+            `${i + 1}. ${comp.name}: ${comp.avg.toFixed(2)}ms avg (${comp.count} renders)`,
+          );
+        });
+      }
+      console.groupEnd();
+    }
+
+    clear() {
+      this.renderTimes = [];
+      this.measures.clear();
+    }
+
+    enable() {
+      this.enabled = true;
+    }
+
+    disable() {
+      this.enabled = false;
+    }
+  }
+
+  // Global profiler instance
+  const profiler = new Profiler();
+
+  /**
+   * Hook to profile component render
+   */
+  const useProfiler = (componentName) => {
+    const startTime = performance.now();
+
+    return () => {
+      const duration = performance.now() - startTime;
+      profiler.recordRender(componentName, duration);
+    }
+  };
+
+  /**
+   * HOC to profile component
+   */
+  const withProfiler = (Component, name) => {
+    return (props) => {
+      profiler.startMeasure(name);
+      const result = Component(props);
+      const duration = profiler.endMeasure(name);
+      if (duration) profiler.recordRender(name, duration);
+      return result
+    }
+  };
+
+  const workLoop = (deadline) => {
+    const state = getState();
+    let shouldYield = false;
+
+    while (state.nextUnitOfWork && !shouldYield) {
+      state.nextUnitOfWork = performUnitOfWork(state.nextUnitOfWork);
+      shouldYield = deadline.timeRemaining() < 1;
+    }
+
+    if (!state.nextUnitOfWork && state.wipRoot) {
+      commitRoot();
+    }
+
+    requestIdleCallback(workLoop);
+  };
+
+  requestIdleCallback(workLoop);
+
+  const performUnitOfWork = (fiber) => {
+    const componentName = fiber.type?.name || fiber.type?.displayName || 'Unknown';
+
+    profiler.startMeasure(componentName);
+
+    const isFunctionComponent = fiber.type instanceof Function;
+    if (isFunctionComponent) {
+      updateFunctionComponent(fiber);
+    } else {
+      updateHostComponent(fiber);
+    }
+
+    const duration = profiler.endMeasure(componentName);
+    if (duration) profiler.recordRender(componentName, duration);
+
+    if (fiber.child) {
+      return fiber.child
+    }
+    let nextFiber = fiber;
+    while (nextFiber) {
+      if (nextFiber.sibling) {
+        return nextFiber.sibling
+      }
+      nextFiber = nextFiber.parent;
+    }
+  };
+
+  const scheduleWork = (root, priority = Priority.NORMAL) => {
+    const state = getState();
+    state.nextUnitOfWork = root;
+    state.wipRoot = root;
+    state.deletions = [];
+    state.hookIndex = 0;
+    state.effects = [];
+
+    // Higher priority = faster scheduling
+    if (priority <= Priority.USER_BLOCKING) {
+      requestIdleCallback(workLoop);
+    } else {
+      setTimeout(() => requestIdleCallback(workLoop), 0);
+    }
+  };
+
+  const render = (element, container) => {
+    const state = getState();
+    state.wipRoot = {
+      dom: container,
+      props: {
+        children: [element],
+      },
+      alternate: state.currentRoot,
+    };
+
+    state.nextUnitOfWork = state.wipRoot;
+    state.deletions = [];
+    scheduleWork(state.wipRoot);
+    return state.wipRoot
+  };
+
+  const init = (MainElement, root = '__ryunix') => {
+    const state = getState();
+    state.containerRoot = document.getElementById(root);
+    const renderProcess = render(MainElement, state.containerRoot);
+    return renderProcess
+  };
+
+  const safeRender = (component, props, onError) => {
+    try {
+      return component(props)
+    } catch (error) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.error('Component error:', error);
+      }
+      if (onError) onError(error);
+      return null
+    }
+  };
+
   /**
    * memo - Memoize component to prevent unnecessary re-renders
    */
@@ -1508,6 +1582,8 @@
   exports.Fragment = Fragment;
   exports.Hooks = hooks;
   exports.Image = Image;
+  exports.MDXContent = MDXContent;
+  exports.MDXProvider = MDXProvider;
   exports.NavLink = NavLink;
   exports.Priority = Priority;
   exports.RouterProvider = RouterProvider;
@@ -1516,6 +1592,8 @@
   exports.createContext = createContext;
   exports.createElement = createElement;
   exports.default = Ryunix;
+  exports.defaultComponents = defaultComponents;
+  exports.getMDXComponents = getMDXComponents;
   exports.init = init;
   exports.lazy = lazy;
   exports.memo = memo;
@@ -1526,6 +1604,7 @@
   exports.useDeferredValue = useDeferredValue;
   exports.useEffect = useEffect;
   exports.useHash = useHash;
+  exports.useMDXComponents = useMDXComponents;
   exports.useMemo = useMemo;
   exports.useMetadata = useMetadata;
   exports.useProfiler = useProfiler;