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

package/dist/Ryunix.esm.js

@@ -587,34 +587,6 @@ const reconcileChildren = (wipFiber, elements) => {
   });
 };
 
-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
  */
@@ -628,371 +600,130 @@ const Priority = {
 
 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')
@@ -1361,6 +1092,349 @@ var hooks = /*#__PURE__*/Object.freeze({
   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
  */
@@ -1498,5 +1572,5 @@ var Ryunix = /*#__PURE__*/Object.freeze({
 
 window.Ryunix = Ryunix;
 
-export { Children, Fragment, hooks as Hooks, Image, NavLink, Priority, RouterProvider, Suspense, batchUpdates, createContext, createElement, Ryunix as default, init, lazy, memo, profiler, render, safeRender, useCallback, useDeferredValue, useEffect, useHash, useMemo, useMetadata, useProfiler, useQuery, useReducer, useRef, useRouter, useStore, useStorePriority, useTransition, withProfiler };
+export { Children, Fragment, hooks as Hooks, Image, MDXContent, MDXProvider, NavLink, Priority, RouterProvider, Suspense, batchUpdates, createContext, createElement, Ryunix as default, defaultComponents, getMDXComponents, init, lazy, memo, profiler, render, safeRender, useCallback, useDeferredValue, useEffect, useHash, useMDXComponents, useMemo, useMetadata, useProfiler, useQuery, useReducer, useRef, useRouter, useStore, useStorePriority, useTransition, withProfiler };
 //# sourceMappingURL=Ryunix.esm.js.map