@meonode/ui 0.2.21 → 0.3.1

package/dist/components/styled-renderer.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styled-renderer.client.d.ts","sourceRoot":"","sources":["../../src/components/styled-renderer.client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,WAAW;IACxD,OAAO,EAAE,CAAC,CAAA;IACV,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,GAAG,CAAC,EAAE,gBAAgB,CAAA;CACvB;AAED,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAChG,OAAO,EACP,GAAG,EACH,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM;;wDAEjC"}
+{"version":3,"file":"styled-renderer.client.d.ts","sourceRoot":"","sources":["../../src/components/styled-renderer.client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAE5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAKpD,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,WAAW;IACxD,OAAO,EAAE,CAAC,CAAA;IACV,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,GAAG,EAAE,gBAAgB,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAChG,OAAO,EACP,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDASjC"}

package/dist/components/styled-renderer.client.js

@@ -1 +1,9 @@
-"use client";var _excluded=["element","css","children"];function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}import{jsx}from"@emotion/react";export default function StyledRenderer(a){var b=a.element,c=a.css,d=a.children,e=_objectWithoutProperties(a,_excluded);return jsx(b,_objectSpread(_objectSpread({},e),{},{css:c}),d)}StyledRenderer.displayName="Styled";
+"use client";var _excluded=["element","children"];function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}import{useContext}from"react";import{jsx}from"@emotion/react";import{resolveObjWithTheme}from"../helper/theme.helper.js";import{ThemeContext}from"./theme-provider.client.js";import{resolveDefaultStyle}from"../helper/node.helper.js";/**
+ * A client-side component that renders a styled element using Emotion.
+ * It resolves theme values and applies default styles.
+ * @template E The type of the HTML element to render.
+ * @template TProps The type of the props for the component.
+ * @param element The HTML element to render (e.g., 'div', 'span').
+ * @param children Optional children to be rendered inside the element.
+ * @returns {JSX.Element} The rendered JSX element.
+ */export default function StyledRenderer(a){var b=a.element,c=a.children,d=_objectWithoutProperties(a,_excluded),e=useContext(ThemeContext),f=null===e||void 0===e?void 0:e.theme,g=d;f&&(g=resolveObjWithTheme(d,f.system));var h=resolveDefaultStyle(g.css);return jsx(b,_objectSpread(_objectSpread({},g),{},{css:h}),c)}StyledRenderer.displayName="Styled";

package/dist/components/theme-provider.client.d.ts

@@ -0,0 +1,25 @@
+import type { Children, Theme } from '../node.type.js';
+export interface ThemeContextValue {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+}
+export declare const ThemeContext: import("react").Context<ThemeContextValue | null>;
+/**
+ * The internal implementation of the ThemeProvider component.
+ * @param {object} props The props for the component.
+ * @param {Children} [props.children] The children to render.
+ * @param {Theme} props.theme The theme to provide.
+ * @returns {React.ReactNode} The rendered component.
+ * @private
+ */
+export declare function _ThemeProvider({ children, theme }: {
+    children?: Children;
+    theme: Theme;
+}): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+/**
+ * A component that provides a theme to its children.
+ */
+export declare const ThemeProvider: (<AdditionalProps extends Record<string, any> = Record<string, any>>(props: import("../node.type.js").MergedProps<typeof _ThemeProvider, AdditionalProps>) => import("../node.type.js").NodeInstance<typeof _ThemeProvider>) & {
+    element: typeof _ThemeProvider;
+};
+//# sourceMappingURL=theme-provider.client.d.ts.map

package/dist/components/theme-provider.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-provider.client.d.ts","sourceRoot":"","sources":["../../src/components/theme-provider.client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGxD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,CAAA;IACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AAED,eAAO,MAAM,YAAY,mDAAgD,CAAA;AAEzE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,8FAgBxF;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;;CAA6B,CAAA"}

package/dist/components/theme-provider.client.js

@@ -0,0 +1,10 @@
+"use client";function _slicedToArray(a,b){return _arrayWithHoles(a)||_iterableToArrayLimit(a,b)||_unsupportedIterableToArray(a,b)||_nonIterableRest()}function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _unsupportedIterableToArray(b,c){if(b){if("string"==typeof b)return _arrayLikeToArray(b,c);var a={}.toString.call(b).slice(8,-1);return"Object"===a&&b.constructor&&(a=b.constructor.name),"Map"===a||"Set"===a?Array.from(b):"Arguments"===a||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a)?_arrayLikeToArray(b,c):void 0}}function _arrayLikeToArray(b,c){(null==c||c>b.length)&&(c=b.length);for(var d=0,f=Array(c);d<c;d++)f[d]=b[d];return f}function _iterableToArrayLimit(b,c){var d=null==b?null:"undefined"!=typeof Symbol&&b[Symbol.iterator]||b["@@iterator"];if(null!=d){var g,h,j,k,l=[],a=!0,m=!1;try{if(j=(d=d.call(b)).next,0===c){if(Object(d)!==d)return;a=!1}else for(;!(a=(g=j.call(d)).done)&&(l.push(g.value),l.length!==c);a=!0);}catch(a){m=!0,h=a}finally{try{if(!a&&null!=d["return"]&&(k=d["return"](),Object(k)!==k))return}finally{if(m)throw h}}return l}}function _arrayWithHoles(a){if(Array.isArray(a))return a}import{createContext,useState}from"react";import{createNode,Node}from"../main.js";export var ThemeContext=createContext(null);/**
+ * The internal implementation of the ThemeProvider component.
+ * @param {object} props The props for the component.
+ * @param {Children} [props.children] The children to render.
+ * @param {Theme} props.theme The theme to provide.
+ * @returns {React.ReactNode} The rendered component.
+ * @private
+ */export function _ThemeProvider(a){var b=a.children,c=a.theme,d=useState(c),e=_slicedToArray(d,2),f=e[0],g=e[1];if(!c)throw new Error("`theme` prop must be defined");return Node(ThemeContext.Provider,{value:{theme:f,setTheme:function setTheme(a){document.cookie="theme=".concat(a.mode),g(a)}},children:b}).render()}/**
+ * A component that provides a theme to its children.
+ */export var ThemeProvider=createNode(_ThemeProvider);

package/dist/core.node.d.ts

@@ -1,45 +1,30 @@
 import { type ReactElement } from 'react';
-import type { Children, FinalNodeProps, HasRequiredProps, MergedProps, NodeElementType, NodeInstance, NodePortal, NodeProps, PropsOf, RawNodeProps } from './node.type.js';
+import type { Children, FinalNodeProps, HasRequiredProps, MergedProps, NodeElementType, NodeInstance, NodePortal, NodeProps, PropsOf } from './node.type.js';
 /**
- * Represents a node in a React component tree with theme and styling capabilities.
+ * Represents a node in a React component tree.
  * This class wraps React elements and handles:
  * - Props processing and normalization
- * - Theme inheritance and resolution
  * - Child node processing and management
- * - Style processing with theme variables
+ * - Style processing
  * @template E The type of React element or component this node represents
  */
 export declare class BaseNode<E extends NodeElementType> implements NodeInstance<E> {
     /** The underlying React element or component type that this node represents */
     element: E;
     /** Original props passed during construction, preserved for cloning/recreation */
-    rawProps: RawNodeProps<E>;
+    rawProps: Partial<NodeProps<E>>;
     /** Flag to identify BaseNode instances */
     readonly isBaseNode: boolean;
-    /** Processed props after theme resolution, style processing, and child normalization */
+    /** Processed props after style processing, and child normalization */
     private _props?;
     /** DOM element used for portal rendering */
     private _portalDOMElement;
     /** React root instance for portal rendering */
     private _portalReactRoot;
-    /** Hash of the current children and theme to detect changes */
-    private _childrenHash?;
     /** Cache for normalized children */
     private _normalizedChildren?;
     /** Indicates whether the code is running on the server (true) or client (false) */
     private static _isServer;
-    /**
-     * WeakMap cache for processed children, keyed by object/array identity for GC friendliness.
-     * Each entry stores the hash, processed children, and a server-side flag.
-     */
-    private static _processedChildrenWeakCache;
-    /**
-     * Map cache for processed children, keyed by a stable string signature.
-     * Used for non-object cases or as a fallback. Each entry stores the processed children and a server-side flag.
-     */
-    private static _processedChildrenMapCache;
-    /** Maximum number of entries in the Map cache to prevent unbounded growth */
-    private static readonly _MAX_PROCESSED_CHILDREN_CACHE = 1000;
     /**
      * Constructs a new BaseNode instance.
      *
@@ -49,98 +34,51 @@ export declare class BaseNode<E extends NodeElementType> implements NodeInstance
      * @param element The React element or component type this node will represent.
      * @param rawProps The initial, unprocessed props for the element.
      */
-    constructor(element: E, rawProps?: RawNodeProps<E>);
+    constructor(element: E, rawProps?: Partial<NodeProps<E>>);
     /**
      * Lazily processes and retrieves the final, normalized props for the node.
      *
      * The first time this getter is accessed, it triggers `_processProps` to resolve
-     * themes, styles, and children. Subsequent accesses return the cached result
+     * styles, and children. Subsequent accesses return the cached result
      * until the node is cloned or recreated.
      * @returns The fully processed and normalized `FinalNodeProps`.
      */
     get props(): FinalNodeProps;
     /**
-     * Performs the core logic of processing raw props into their final, normalized form.
-     *
-     * This method is called by the `props` getter on its first access. It handles:
-     * 1.  **Theme Resolution**: Selects the active theme from `theme` or `nodetheme` props.
-     * 2.  **Prop Resolution**: Resolves theme-aware values (functions) in `rawProps` and `nativeProps.style`.
-     * 3.  **Style Extraction**: Separates style-related props (`css`, `style`) from other DOM/component props.
-     * 4.  **Default Style Merging**: Combines default styles with resolved style props.
-     * 5.  **Child Processing**: Normalizes the `children` prop, propagating the theme.
-     * @returns The processed `FinalNodeProps` object.
+     * Processes raw props into a final, normalized form.
+     * This includes:
+     * - Extracting and separating style-related props
+     * - Merging CSS-in-JS styles with other style props
+     * - Processing and normalizing children
+     * - Combining all parts into a single props object
      * @private
+     * @returns The processed `FinalNodeProps` ready for rendering.
      */
     private _processProps;
     /**
-     * Deeply clones processed children before returning them from cache so that each parent receives
-     * independent `BaseNode` instances (prevents sharing cycles and mutation bugs).
-     *
-     * - If the input is an array, each child is cloned recursively.
-     * - If the input is a `BaseNode`, a new instance is created with the same element and copied rawProps.
-     * - For other objects/primitives, the value is returned as-is (they are immutable or safe to reuse).
-     *
-     * This ensures that cached children are never shared between different parents in the React tree.
-     * @param processed The processed child or array of children to clone.
-     * @returns A deep clone of the processed children, safe for use in multiple parents.
-     * @private
-     */
-    private static _cloneProcessedChildren;
-    /**
-     * Retrieves cached processed children for a given set of `children` and an optional `theme`.
-     *
-     * - Skips caching entirely when executed on the server (returns `null`).
-     * - Uses a **WeakMap** for identity-based caching when `children` is an object or array,
-     * ensuring garbage collection safety.
-     * - Falls back to a **Map** keyed by a stable hash of `children` and `theme`
-     * for value-based caching.
-     * - Only returns cached entries that are **not server-side**.
-     * @param children The child node(s) to resolve cached results for.
-     * @param theme The theme context that may influence child processing.
-     * @returns A cloned version of the cached processed children if available, otherwise `null`.
-     * @private
-     */
-    private _getCachedChildren;
-    /**
-     * Caches processed children for a given set of children and theme.
-     * This method stores the processed NodeElement(s) in a Map keyed by a stable hash.
-     * The cache is bounded to avoid unbounded memory growth.
-     * No caching is performed on the server to avoid RSC issues.
-     * @param children The original children to cache.
-     * @param theme The theme associated with the children.
-     * @param processed The processed NodeElement(s) to cache.
-     * @private
-     */
-    private _setCachedChildren;
-    /**
-     * Recursively processes raw children, converting them into `BaseNode` instances as needed
-     * and propagating the provided theme.
+     * Recursively processes raw children, converting them into `BaseNode` instances as needed.
      *
-     * This method ensures consistent theme handling for all children and optimizes performance
-     * using caching strategies: a Map for client-side and no caching for server-side.
+     * This method ensures consistent handling for all children.
      *
      * - If `children` is an array, each child is processed individually.
      * - If `children` is a single node, it is processed directly.
-     * - The processed result is cached on the client to avoid redundant work.
      * @param children The raw child or array of children to process.
-     * @param theme The theme to propagate to the children.
      * @returns The processed children, ready for normalization and rendering.
      * @private
      */
     private _processChildren;
     /**
-     * Renders a processed `NodeElement` into a `ReactNode`, applying a theme and key if necessary.
+     * Renders a processed `NodeElement` into a `ReactNode`, applying a key if necessary.
      *
      * This static method centralizes the logic for converting various types of processed elements
      * into renderable React nodes. It handles:
-     * - `BaseNode` instances: Re-wraps them to apply a new key or theme.
+     * - `BaseNode` instances: Re-wraps them to apply a new key.
      * - React class components: Wraps them in a new `BaseNode`.
      * - `NodeInstance` objects: Invokes their `render()` method.
      * - React component instances: Invokes their `render()` method.
      * - Functional components: Creates a React element from them.
      * - Other valid `ReactNode` types (strings, numbers, etc.): Returns them as-is.
      * @param processedElement The node element to render.
-     * @param passedTheme The theme to propagate.
      * @param passedKey The React key to assign.
      * @returns A renderable `ReactNode`.
      * @private
@@ -159,15 +97,12 @@ export declare class BaseNode<E extends NodeElementType> implements NodeInstance
      */
     private static _isFunctionChild;
     /**
-     * Renders the output of a function-as-a-child, ensuring theme propagation.
+     * Renders the output of a function-as-a-child.
      *
      * This method is designed to handle "render prop" style children (`() => ReactNode`).
-     * It invokes the function, processes its result, and ensures the parent's theme is
-     * correctly passed down to any `BaseNode` instances returned by the function.
+     * It invokes the function and processes its result.
      * @param props The properties for the function renderer.
      * @param props.render The function to execute to get the child content.
-     * @param props.passedTheme The theme to propagate to the rendered child.
-     * // * @param props.processRawNode A reference to the `_processRawNode` method for recursive processing.
      * @returns The rendered `ReactNode`.
      * @private
      */
@@ -192,16 +127,15 @@ export declare class BaseNode<E extends NodeElementType> implements NodeInstance
      * Processes a single raw node, recursively converting it into a `BaseNode` or other renderable type.
      *
      * This is a central method for normalizing children. It handles various types of input:
-     * - **`BaseNode` instances**: Re-creates them to ensure the correct theme and key are applied.
+     * - **`BaseNode` instances**: Re-creates them to ensure the correct key is applied.
      * - **Primitives**: Returns strings, numbers, booleans, null, and undefined as-is.
      * - **Functions (Render Props)**: Wraps them in a `BaseNode` that uses `_functionRenderer` to delay execution.
-     * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props and propagating the theme.
-     * - **React Component Types**: Wraps them in a `BaseNode` with the parent theme.
+     * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props.
+     * - **React Component Types**: Wraps them in a `BaseNode`.
      * - **React Component Instances**: Renders them and processes the output recursively.
      *
      * It also generates a stable key for elements within an array if one is not provided.
      * @param node The raw child node to process.
-     * @param passedTheme The theme inherited from the parent.
      * @param nodeIndex The index of the child if it is in an array, used for key generation.
      * @returns A processed `NodeElement` (typically a `BaseNode` instance or a primitive).
      * @private
@@ -214,7 +148,7 @@ export declare class BaseNode<E extends NodeElementType> implements NodeInstance
      * This method is called during the `render` phase. It takes a child that has already
      * been processed by `_processChildren` and prepares it for `React.createElement`.
      *
-     * - For `BaseNode` instances, it calls their `render()` method, ensuring the theme is consistent.
+     * - For `BaseNode` instances, it calls their `render()` method.
      * - It validates that other children are valid React element types.
      * - Primitives and other valid nodes are returned as-is.
      * @param child The processed child node to normalize.

package/dist/core.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"core.node.d.ts","sourceRoot":"","sources":["../src/core.node.ts"],"names":[],"mappings":"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"}

package/dist/core.node.js

@@ -1,10 +1,9 @@
-"use strict";var _excluded=["ref","key","children","nodetheme","theme","props"],_excluded2=["style"],_excluded3=["style","css"],_excluded4=["style"],_excluded5=["children","key","nativeProps"];function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import React,{createElement,Fragment,isValidElement}from"react";import{createStableHash,isNodeInstance,resolveDefaultStyle}from"./helper/node.helper.js";import{isForwardRef,isFragment,isMemo,isReactClassComponent,isValidElementType}from"./helper/react-is.helper.js";import{createRoot}from"react-dom/client";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName,hasNoStyleTag,omit,omitUndefined}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";import{resolveObjWithTheme}from"./helper/theme.helper.js";/**
- * Represents a node in a React component tree with theme and styling capabilities.
+"use strict";var _excluded=["ref","key","children","css","props"],_excluded2=["style"],_excluded3=["style"],_excluded4=["children","key","nativeProps"];function ownKeys(a,b){var c=Object.keys(a);if(Object.getOwnPropertySymbols){var d=Object.getOwnPropertySymbols(a);b&&(d=d.filter(function(b){return Object.getOwnPropertyDescriptor(a,b).enumerable})),c.push.apply(c,d)}return c}function _objectSpread(a){for(var b,c=1;c<arguments.length;c++)b=null==arguments[c]?{}:arguments[c],c%2?ownKeys(Object(b),!0).forEach(function(c){_defineProperty(a,c,b[c])}):Object.getOwnPropertyDescriptors?Object.defineProperties(a,Object.getOwnPropertyDescriptors(b)):ownKeys(Object(b)).forEach(function(c){Object.defineProperty(a,c,Object.getOwnPropertyDescriptor(b,c))});return a}function _objectWithoutProperties(a,b){if(null==a)return{};var c,d,e=_objectWithoutPropertiesLoose(a,b);if(Object.getOwnPropertySymbols){var f=Object.getOwnPropertySymbols(a);for(d=0;d<f.length;d++)c=f[d],-1===b.indexOf(c)&&{}.propertyIsEnumerable.call(a,c)&&(e[c]=a[c])}return e}function _objectWithoutPropertiesLoose(a,b){if(null==a)return{};var c={};for(var d in a)if({}.hasOwnProperty.call(a,d)){if(-1!==b.indexOf(d))continue;c[d]=a[d]}return c}function _typeof(a){"@babel/helpers - typeof";return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},_typeof(a)}function _defineProperty(a,b,c){return(b=_toPropertyKey(b))in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _toPropertyKey(a){var b=_toPrimitive(a,"string");return"symbol"==_typeof(b)?b:b+""}function _toPrimitive(a,b){if("object"!=_typeof(a)||!a)return a;var c=a[Symbol.toPrimitive];if(void 0!==c){var d=c.call(a,b||"default");if("object"!=_typeof(d))return d;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===b?String:Number)(a)}import React,{createElement,Fragment,isValidElement}from"react";import{isNodeInstance}from"./helper/node.helper.js";import{isForwardRef,isFragment,isMemo,isReactClassComponent,isValidElementType}from"./helper/react-is.helper.js";import{createRoot}from"react-dom/client";import{getComponentType,getCSSProps,getDOMProps,getElementTypeName,hasNoStyleTag,omitUndefined}from"./helper/common.helper.js";import StyledRenderer from"./components/styled-renderer.client.js";/**
+ * Represents a node in a React component tree.
  * This class wraps React elements and handles:
  * - Props processing and normalization
- * - Theme inheritance and resolution
  * - Child node processing and management
- * - Style processing with theme variables
+ * - Style processing
  * @template E The type of React element or component this node represents
  */export class BaseNode{/**
    * Constructs a new BaseNode instance.
@@ -14,124 +13,74 @@
    * accessed via the `props` getter, allowing for lazy evaluation.
    * @param element The React element or component type this node will represent.
    * @param rawProps The initial, unprocessed props for the element.
-   */constructor(a){var b=this,c=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{};/** The underlying React element or component type that this node represents *//** Original props passed during construction, preserved for cloning/recreation *//** Flag to identify BaseNode instances *//** DOM element used for portal rendering *//** React root instance for portal rendering *//**
+   */constructor(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{};/** The underlying React element or component type that this node represents *//** Original props passed during construction, preserved for cloning/recreation *//** Flag to identify BaseNode instances *//** DOM element used for portal rendering *//** React root instance for portal rendering *//**
    * Normalizes a processed child node into a final, renderable `ReactNode`.
    *
    * This method is called during the `render` phase. It takes a child that has already
    * been processed by `_processChildren` and prepares it for `React.createElement`.
    *
-   * - For `BaseNode` instances, it calls their `render()` method, ensuring the theme is consistent.
+   * - For `BaseNode` instances, it calls their `render()` method.
    * - It validates that other children are valid React element types.
    * - Primitives and other valid nodes are returned as-is.
    * @param child The processed child node to normalize.
    * @returns A renderable `ReactNode`.
    * @throws {Error} If the child is not a valid React element type.
    * @private
-   */_defineProperty(this,"rawProps",{}),_defineProperty(this,"isBaseNode",!0),_defineProperty(this,"_portalDOMElement",null),_defineProperty(this,"_portalReactRoot",null),_defineProperty(this,"_normalizeChild",function(a){var c,d;// Handle null/undefined quickly
+   */_defineProperty(this,"rawProps",{}),_defineProperty(this,"isBaseNode",!0),_defineProperty(this,"_portalDOMElement",null),_defineProperty(this,"_portalReactRoot",null),_defineProperty(this,"_normalizeChild",function(a){// Handle null/undefined quickly
 if(null===a||a===void 0)return a;// Primitives should be returned as-is (text nodes, numbers, booleans)
-var e=_typeof(a);if("string"===e||"number"===e||"boolean"===e)return a;var f=(null===(c=b.rawProps)||void 0===c?void 0:c.nodetheme)||(null===(d=b.rawProps)||void 0===d?void 0:d.theme)||b.props.nodetheme||b.props.theme;// For BaseNode instances, apply current theme if child has no theme
-if(a instanceof BaseNode||isNodeInstance(a)){var g;return null!==(g=a.rawProps)&&void 0!==g&&g.nodetheme||void 0===f?a.render():new BaseNode(a.element,_objectSpread(_objectSpread({},a.rawProps),{},{nodetheme:f})).render()}// Handle React.Component instances
+var b=_typeof(a);if("string"===b||"number"===b||"boolean"===b)return a;// For BaseNode instances, apply current theme if child has no theme
+if(a instanceof BaseNode||isNodeInstance(a))return a.render();// Handle React.Component instances
 if("function"==typeof a.render)// React.Component instance
 return a.render();// Validate element type before returning
-if(!isValidElementType(a)){var h=getComponentType(a);throw new Error("Invalid element type: ".concat(h," provided!"))}// Return valid React elements as-is
-return a}),this.element=a,this.rawProps=c}/**
+if(!isValidElementType(a)){var c=getComponentType(a);throw new Error("Invalid element type: ".concat(c," provided!"))}// Return valid React elements as-is
+return a}),this.element=a,this.rawProps=b}/**
    * Lazily processes and retrieves the final, normalized props for the node.
    *
    * The first time this getter is accessed, it triggers `_processProps` to resolve
-   * themes, styles, and children. Subsequent accesses return the cached result
+   * styles, and children. Subsequent accesses return the cached result
    * until the node is cloned or recreated.
    * @returns The fully processed and normalized `FinalNodeProps`.
    */get props(){return this._props||(this._props=this._processProps()),this._props}/**
-   * Performs the core logic of processing raw props into their final, normalized form.
-   *
-   * This method is called by the `props` getter on its first access. It handles:
-   * 1.  **Theme Resolution**: Selects the active theme from `theme` or `nodetheme` props.
-   * 2.  **Prop Resolution**: Resolves theme-aware values (functions) in `rawProps` and `nativeProps.style`.
-   * 3.  **Style Extraction**: Separates style-related props (`css`, `style`) from other DOM/component props.
-   * 4.  **Default Style Merging**: Combines default styles with resolved style props.
-   * 5.  **Child Processing**: Normalizes the `children` prop, propagating the theme.
-   * @returns The processed `FinalNodeProps` object.
+   * Processes raw props into a final, normalized form.
+   * This includes:
+   * - Extracting and separating style-related props
+   * - Merging CSS-in-JS styles with other style props
+   * - Processing and normalizing children
+   * - Combining all parts into a single props object
    * @private
+   * @returns The processed `FinalNodeProps` ready for rendering.
    */_processProps(){// Destructure raw props into relevant parts
-var a=this.rawProps,b=a.ref,c=a.key,d=a.children,e=a.nodetheme,f=a.theme,g=a.props,h=void 0===g?{}:g,i=_objectWithoutProperties(a,_excluded),j=f||e,k=h,l=k.style,m=_objectWithoutProperties(k,_excluded2),n=resolveObjWithTheme(i,j),o=resolveObjWithTheme(l,j),p=n.style,q=n.css,r=_objectWithoutProperties(n,_excluded3),s=getCSSProps(r),t=getDOMProps(r),u=resolveDefaultStyle(_objectSpread(_objectSpread({},s),p)),v=this._processChildren(d,j),w=omitUndefined(_objectSpread(_objectSpread({ref:b,key:c,nodetheme:j,theme:f,css:_objectSpread(_objectSpread({},u),q),style:o},t),{},{nativeProps:m,children:v}));// Process children while maintaining theme inheritance
+var a=this.rawProps,b=a.ref,c=a.key,d=a.children,e=a.css,f=a.props,g=void 0===f?{}:f,h=_objectWithoutProperties(a,_excluded),i=g,j=i.style,k=_objectWithoutProperties(i,_excluded2),l=getCSSProps(h),m=getDOMProps(h),n=this._processChildren(d);// Process children
 // Combine processed props into final normalized form
-// Special handling for standard HTML tags vs custom components
-return"string"==typeof this.element&&(hasNoStyleTag(this.element)?w=omit(w,"css","style","theme","nodetheme"):w=omit(w,"theme","nodetheme")),w}/**
-   * Deeply clones processed children before returning them from cache so that each parent receives
-   * independent `BaseNode` instances (prevents sharing cycles and mutation bugs).
-   *
-   * - If the input is an array, each child is cloned recursively.
-   * - If the input is a `BaseNode`, a new instance is created with the same element and copied rawProps.
-   * - For other objects/primitives, the value is returned as-is (they are immutable or safe to reuse).
-   *
-   * This ensures that cached children are never shared between different parents in the React tree.
-   * @param processed The processed child or array of children to clone.
-   * @returns A deep clone of the processed children, safe for use in multiple parents.
-   * @private
-   */static _cloneProcessedChildren(a){var b=function cloneOne(a){return a instanceof BaseNode||isNodeInstance(a)?new BaseNode(a.element,_objectSpread({},a.rawProps)):a;// NodeInstance returns its own instances when render() is called - we avoid calling render here.
-// For other objects/primitives, return as-is (they are immutable or safe to reuse).
-};return Array.isArray(a)?a.map(function(a){return b(a)}):b(a)}/**
-   * Retrieves cached processed children for a given set of `children` and an optional `theme`.
-   *
-   * - Skips caching entirely when executed on the server (returns `null`).
-   * - Uses a **WeakMap** for identity-based caching when `children` is an object or array,
-   * ensuring garbage collection safety.
-   * - Falls back to a **Map** keyed by a stable hash of `children` and `theme`
-   * for value-based caching.
-   * - Only returns cached entries that are **not server-side**.
-   * @param children The child node(s) to resolve cached results for.
-   * @param theme The theme context that may influence child processing.
-   * @returns A cloned version of the cached processed children if available, otherwise `null`.
-   * @private
-   */_getCachedChildren(a,b){if(BaseNode._isServer)return null;// No server caching
-// Compute hash once
-var c=createStableHash(a,b);// If children is an object (array or object), try identity-keyed WeakMap first
-if(a&&"object"===_typeof(a)){var d=BaseNode._processedChildrenWeakCache.get(a);if(d&&d.hash===c&&!d.isServerSide)return BaseNode._cloneProcessedChildren(d.children)}// Fallback to string-hash Map cache
-var e=BaseNode._processedChildrenMapCache.get(c);return e&&!e.isServerSide?BaseNode._cloneProcessedChildren(e.children):null}/**
-   * Caches processed children for a given set of children and theme.
-   * This method stores the processed NodeElement(s) in a Map keyed by a stable hash.
-   * The cache is bounded to avoid unbounded memory growth.
-   * No caching is performed on the server to avoid RSC issues.
-   * @param children The original children to cache.
-   * @param theme The theme associated with the children.
-   * @param processed The processed NodeElement(s) to cache.
-   * @private
-   */_setCachedChildren(a,b,c){if(!BaseNode._isServer){var d=createStableHash(a,b);if(a&&"object"===_typeof(a))return void BaseNode._processedChildrenWeakCache.set(a,{hash:d,children:c,isServerSide:!1});// Manage bounded Map cache (FIFO eviction)
-if(BaseNode._processedChildrenMapCache.has(d))return void BaseNode._processedChildrenMapCache.set(d,{children:c,isServerSide:!1});if(BaseNode._processedChildrenMapCache.size>=BaseNode._MAX_PROCESSED_CHILDREN_CACHE){var e=BaseNode._processedChildrenMapCache.keys().next().value;void 0!==e&&BaseNode._processedChildrenMapCache["delete"](e)}BaseNode._processedChildrenMapCache.set(d,{children:c,isServerSide:!1})}}/**
-   * Recursively processes raw children, converting them into `BaseNode` instances as needed
-   * and propagating the provided theme.
+return omitUndefined(_objectSpread(_objectSpread({ref:b,key:c,css:_objectSpread(_objectSpread({},l),e),style:j},m),{},{nativeProps:k,children:n}))}/**
+   * Recursively processes raw children, converting them into `BaseNode` instances as needed.
    *
-   * This method ensures consistent theme handling for all children and optimizes performance
-   * using caching strategies: a Map for client-side and no caching for server-side.
+   * This method ensures consistent handling for all children.
    *
    * - If `children` is an array, each child is processed individually.
    * - If `children` is a single node, it is processed directly.
-   * - The processed result is cached on the client to avoid redundant work.
    * @param children The raw child or array of children to process.
-   * @param theme The theme to propagate to the children.
    * @returns The processed children, ready for normalization and rendering.
    * @private
-   */_processChildren(a,b){if(a){// Use RSC-safe caching strategy
-var c=this._getCachedChildren(a,b);if(c)return c;var d;return d="function"==typeof a?a:Array.isArray(a)?a.map(function(a,c){return BaseNode._processRawNode(a,b,c)}):BaseNode._processRawNode(a,b),BaseNode._isServer||this._setCachedChildren(a,b,d),d}}/**
-   * Renders a processed `NodeElement` into a `ReactNode`, applying a theme and key if necessary.
+   */_processChildren(a){if(a){var b;return b="function"==typeof a?a:Array.isArray(a)?a.map(function(a,b){return BaseNode._processRawNode(a,b)}):BaseNode._processRawNode(a),b}}/**
+   * Renders a processed `NodeElement` into a `ReactNode`, applying a key if necessary.
    *
    * This static method centralizes the logic for converting various types of processed elements
    * into renderable React nodes. It handles:
-   * - `BaseNode` instances: Re-wraps them to apply a new key or theme.
+   * - `BaseNode` instances: Re-wraps them to apply a new key.
    * - React class components: Wraps them in a new `BaseNode`.
    * - `NodeInstance` objects: Invokes their `render()` method.
    * - React component instances: Invokes their `render()` method.
    * - Functional components: Creates a React element from them.
    * - Other valid `ReactNode` types (strings, numbers, etc.): Returns them as-is.
    * @param processedElement The node element to render.
-   * @param passedTheme The theme to propagate.
    * @param passedKey The React key to assign.
    * @returns A renderable `ReactNode`.
    * @private
    * @static
-   */static _renderProcessedNode(a,b,c){var d={};// 1. BaseNode instance: re-wrap to apply key/theme if needed
-if(void 0!==c&&(d.key=c),a instanceof BaseNode||isNodeInstance(a)){var e,f,g,h,i,j=(null===(e=a.rawProps)||void 0===e?void 0:e.theme)||(null===(f=a.rawProps)||void 0===f?void 0:f.nodetheme)||b,k=null===(g=a.rawProps)||void 0===g?void 0:g.key;return k===c&&j===((null===(h=a.rawProps)||void 0===h?void 0:h.nodetheme)||(null===(i=a.rawProps)||void 0===i?void 0:i.theme))?a.render():new BaseNode(a.element,_objectSpread(_objectSpread(_objectSpread({},a.rawProps),d),{},{nodetheme:j})).render()}// 2. React class component type: wrap in BaseNode
-return isReactClassComponent(a)?new BaseNode(a,d).render():isNodeInstance(a)?a.render():a instanceof React.Component?a.render():"function"==typeof a?createElement(a,{key:c}):a;// 3. NodeInstance object: call its render
+   */static _renderProcessedNode(a,b){var c={};// 1. BaseNode instance: re-wrap to apply key/theme if needed
+if(void 0!==b&&(c.key=b),a instanceof BaseNode||isNodeInstance(a)){var d,e=null===(d=a.rawProps)||void 0===d?void 0:d.key;return e===b?a.render():new BaseNode(a.element,_objectSpread(_objectSpread({},a.rawProps),c)).render()}// 2. React class component type: wrap in BaseNode
+return isReactClassComponent(a)?new BaseNode(a,c).render():isNodeInstance(a)?a.render():a instanceof React.Component?a.render():"function"==typeof a?createElement(a,{key:b}):a;// 3. NodeInstance object: call its render
 // 4. React.Component instance: call its render
 // 5. Functional component: create element with key
 // 6. Other valid ReactNode types
@@ -149,26 +98,22 @@ if("function"!=typeof a)return!1;// Exclude React component types
 if(isReactClassComponent(a))return!1;if(isMemo(a))return!1;if(isForwardRef(a))return!1;try{// Try to check if it's a React component instance using prototype
 return!(a.prototype&&"function"==typeof a.prototype.render)}catch(a){// If accessing prototype fails (due to cross-realm), assume it's a function child
 return!0}}/**
-   * Renders the output of a function-as-a-child, ensuring theme propagation.
+   * Renders the output of a function-as-a-child.
    *
    * This method is designed to handle "render prop" style children (`() => ReactNode`).
-   * It invokes the function, processes its result, and ensures the parent's theme is
-   * correctly passed down to any `BaseNode` instances returned by the function.
+   * It invokes the function and processes its result.
    * @param props The properties for the function renderer.
    * @param props.render The function to execute to get the child content.
-   * @param props.passedTheme The theme to propagate to the rendered child.
-   * // * @param props.processRawNode A reference to the `_processRawNode` method for recursive processing.
    * @returns The rendered `ReactNode`.
    * @private
-   */static _functionRenderer(a){var b,c=a.render,d=a.passedTheme;// Invoke the render function to get the child node.
+   */static _functionRenderer(a){var b,c=a.render;// Invoke the render function to get the child node.
 try{b=c()}catch(a){b=null}// Handle null/undefined
 if(null===b||b===void 0)return b;// Handle arrays of elements (common in render props)
-if(Array.isArray(b))return b.map(function(a,b){var c=BaseNode._processRawNode(a,d,b);return BaseNode._renderProcessedNode(c,d,"".concat(getElementTypeName(a),"-").concat(b))});// Handle React.Component instance
-if(b instanceof React.Component){var e=b.render(),f=BaseNode._processRawNode(e,d);return BaseNode._renderProcessedNode(f,d)}// Handle BaseNode instance or NodeInstance
-if(b instanceof BaseNode||isNodeInstance(b)){var g,h=b;// If nodetheme is missing and passedTheme exists, inject it
-return void 0===(null===(g=h.rawProps)||void 0===g?void 0:g.nodetheme)&&void 0!==d?new BaseNode(h.element,_objectSpread(_objectSpread({},h.rawProps),{},{nodetheme:d})).render():h.render()}// Handle primitives and valid React nodes (string, number, boolean)
+if(Array.isArray(b))return b.map(function(a,b){var c=BaseNode._processRawNode(a,b);return BaseNode._renderProcessedNode(c,"".concat(getElementTypeName(a),"-").concat(b))});// Handle React.Component instance
+if(b instanceof React.Component){var d=b.render(),e=BaseNode._processRawNode(d);return BaseNode._renderProcessedNode(e)}// Handle BaseNode instance or NodeInstance
+if(b instanceof BaseNode||isNodeInstance(b))return b.render();// Handle primitives and valid React nodes (string, number, boolean)
 if("string"==typeof b||"number"==typeof b||"boolean"==typeof b)return b;// Process any other result types
-var i=BaseNode._processRawNode(b,d);return i?BaseNode._renderProcessedNode(i,d):b}/**
+var f=BaseNode._processRawNode(b);return f?BaseNode._renderProcessedNode(f):b}/**
    * Generates a stable key for a node, especially for elements within an array.
    *
    * If an `existingKey` is provided, it is returned. Otherwise, a key is generated
@@ -186,41 +131,37 @@ var i=BaseNode._processRawNode(b,d);return i?BaseNode._renderProcessedNode(i,d):
    * Processes a single raw node, recursively converting it into a `BaseNode` or other renderable type.
    *
    * This is a central method for normalizing children. It handles various types of input:
-   * - **`BaseNode` instances**: Re-creates them to ensure the correct theme and key are applied.
+   * - **`BaseNode` instances**: Re-creates them to ensure the correct key is applied.
    * - **Primitives**: Returns strings, numbers, booleans, null, and undefined as-is.
    * - **Functions (Render Props)**: Wraps them in a `BaseNode` that uses `_functionRenderer` to delay execution.
-   * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props and propagating the theme.
-   * - **React Component Types**: Wraps them in a `BaseNode` with the parent theme.
+   * - **Valid React Elements**: Converts them into `BaseNode` instances, extracting props.
+   * - **React Component Types**: Wraps them in a `BaseNode`.
    * - **React Component Instances**: Renders them and processes the output recursively.
    *
    * It also generates a stable key for elements within an array if one is not provided.
    * @param node The raw child node to process.
-   * @param passedTheme The theme inherited from the parent.
    * @param nodeIndex The index of the child if it is in an array, used for key generation.
    * @returns A processed `NodeElement` (typically a `BaseNode` instance or a primitive).
    * @private
    * @static
-   */static _processRawNode(a,b,c// Index for generating stable keys for array children
-){var d=getComponentType(a);// Determine the type of the raw node
+   */static _processRawNode(a,b// Index for generating stable keys for array children
+){var c=getComponentType(a);// Determine the type of the raw node
 // Case 1: Child is already a BaseNode instance
-if(a instanceof BaseNode||isNodeInstance(a)){var e=a.rawProps||{},f=e.theme||e.nodetheme||b;// Get initial raw props of the child
-// Prefer child's own theme
+if(a instanceof BaseNode||isNodeInstance(a)){var d=a.rawProps||{};// Get initial raw props of the child
 // Check if we can reuse the existing node
-if(e.nodetheme===f&&e.key!==void 0)return a;var g=BaseNode._generateKey({nodeIndex:c,element:a.element,existingKey:e.key,children:e.children});// Generate key if needed
-return new BaseNode(a.element,_objectSpread(_objectSpread({},e),{},{nodetheme:f,// Use the determined theme for the new node
-key:g}));// Create a new BaseNode with merged props and theme
+if(d.key!==void 0)return a;var e=BaseNode._generateKey({nodeIndex:b,element:a.element,existingKey:d.key,children:d.children});// Generate key if needed
+return new BaseNode(a.element,_objectSpread(_objectSpread({},d),{},{key:e}));// Create a new BaseNode with merged props and theme
 }// Case 2: Child is a primitive (string, number, boolean, null, undefined)
-if("string"===d||"number"===d||"boolean"===d||null===a||void 0===a)return a;// Case 3: Child is a function that needs to be called during render (FunctionRenderer).
+if("string"===c||"number"===c||"boolean"===c||null===a||void 0===a)return a;// Case 3: Child is a function that needs to be called during render (FunctionRenderer).
 if(BaseNode._isFunctionChild(a)){// The key is for the BaseNode that wraps the _functionRenderer component.
 // Functions themselves don't have a .key prop that we can access here.
-var h=BaseNode._generateKey({nodeIndex:c,element:BaseNode._functionRenderer});// Generate key for function renderer
-return new BaseNode(BaseNode._functionRenderer,{render:a,passedTheme:b,key:h})}// Case 4: Child is a React Element (JSX element like <div> or <MyComponent>)
-if(isValidElement(a)){var i=a.props,j=i.style,k=_objectWithoutProperties(i,_excluded4),l=_objectSpread(_objectSpread({},k),j||{}),m=l.theme||l.nodetheme||b,n=BaseNode._generateKey({nodeIndex:c,element:a.type,existingKey:a.key,children:l.children});return new BaseNode(a.type,_objectSpread(_objectSpread({},l),{},{nodetheme:m,key:n}))}// Case 5: Child is an ElementType (string tag, class component, Memo/ForwardRef)
-if(isReactClassComponent(a)||"object"===d&&(isMemo(a)||isForwardRef(a))){var o,p=BaseNode._generateKey({nodeIndex:c,element:a,children:"object"===_typeof(a)&&"props"in a?null===(o=a.props)||void 0===o?void 0:o.children:void 0});// ElementTypes don't have an intrinsic key from the node itself.
-return new BaseNode(a,{nodetheme:b,// Apply parent theme
-key:p})}// Case 6: Handle instances of React.Component
-if(a instanceof React.Component){var q=a.render();// Recursively process the rendered element with a parent theme and index if available
-return BaseNode._processRawNode(q,b,c)}// Case 7: Fallback for other ReactNode types (e.g., Fragments, Portals if not caught by isValidElement)
+var f=BaseNode._generateKey({nodeIndex:b,element:BaseNode._functionRenderer});// Generate key for function renderer
+return new BaseNode(BaseNode._functionRenderer,{render:a,key:f})}// Case 4: Child is a React Element (JSX element like <div> or <MyComponent>)
+if(isValidElement(a)){var g=a.props,h=g.style,i=_objectWithoutProperties(g,_excluded3),j=_objectSpread(_objectSpread({},i),h||{}),k=BaseNode._generateKey({nodeIndex:b,element:a.type,existingKey:a.key,children:j.children});return new BaseNode(a.type,_objectSpread(_objectSpread({},j),{},{key:k}))}// Case 5: Child is an ElementType (string tag, class component, Memo/ForwardRef)
+if(isReactClassComponent(a)||"object"===c&&(isMemo(a)||isForwardRef(a))){var l,m=BaseNode._generateKey({nodeIndex:b,element:a,children:"object"===_typeof(a)&&"props"in a?null===(l=a.props)||void 0===l?void 0:l.children:void 0});// ElementTypes don't have an intrinsic key from the node itself.
+return new BaseNode(a,{key:m})}// Case 6: Handle instances of React.Component
+if(a instanceof React.Component){var n=a.render();// Recursively process the rendered element with a parent theme and index if available
+return BaseNode._processRawNode(n,b)}// Case 7: Fallback for other ReactNode types (e.g., Fragments, Portals if not caught by isValidElement)
 // These are returned as-is. If they are elements within an array, React expects them to have keys.
 // This logic primarily adds keys to BaseNode instances we create, other ReactNodes are returned as-is.
 return a}/**
@@ -238,7 +179,7 @@ return a}/**
    * @returns The rendered `ReactElement`.
    * @throws {Error} If the node's `element` is not a valid React element type.
    */render(){var a=this;if(!isValidElementType(this.element)){var b=getComponentType(this.element);throw new Error("Invalid element type: ".concat(b," provided!"))}// Extract children and key
-var c=this.props,d=c.children,e=c.key,f=c.nativeProps,g=_objectWithoutProperties(c,_excluded5),h=void 0;if(d!==void 0&&null!==d){if(!this._normalizedChildren||this._childrenHash!==createStableHash(d,this.props.nodetheme||this.props.theme))if(!Array.isArray(d))this._normalizedChildren=this._normalizeChild(d);else if(0<d.length){var i=d.map(function(b){return a._normalizeChild(b)});this._normalizedChildren=i.every(function(a){return null===a||void 0===a})?void 0:i}else this._normalizedChildren=void 0;h=this._normalizedChildren}// If the element is a Fragment, use React.createElement directly
+var c=this.props,d=c.children,e=c.key,f=c.nativeProps,g=_objectWithoutProperties(c,_excluded4),h=void 0;if(d!==void 0&&null!==d){if(!this._normalizedChildren)if(!Array.isArray(d))this._normalizedChildren=this._normalizeChild(d);else if(0<d.length){var i=d.map(function(b){return a._normalizeChild(b)});this._normalizedChildren=i.every(function(a){return null===a||void 0===a})?void 0:i}else this._normalizedChildren=void 0;h=this._normalizedChildren}// If the element is a Fragment, use React.createElement directly
 if(this.element===Fragment||isFragment(this.element))return createElement(this.element,{key:e},h);// If the element has a `css` prop and has style tag, render using the `StyledRenderer` component
 // This enables emotion-based style handling for the element
 if(this.element&&!hasNoStyleTag(this.element)&&g.css){// Set displayName for easier debugging in React DevTools
@@ -293,7 +234,7 @@ return this._portalReactRoot}}}/**
  * @param props The props for the node (optional).
  * @param additionalProps Additional props to merge into the node (optional).
  * @returns A new `BaseNode` instance as a `NodeInstance<E>`.
- */_defineProperty(BaseNode,"_isServer","undefined"==typeof window),_defineProperty(BaseNode,"_processedChildrenWeakCache",new WeakMap),_defineProperty(BaseNode,"_processedChildrenMapCache",new Map),_defineProperty(BaseNode,"_MAX_PROCESSED_CHILDREN_CACHE",1e3),_defineProperty(BaseNode,"_generateKey",function(a){var b=a.nodeIndex,c=a.element,d=a.existingKey,e=a.children;if(d)return d;var f,g=getElementTypeName(c);return f=Array.isArray(e)&&0<e.length?void 0===b?"".concat(g,"-").concat(e.length):"".concat(g,"-").concat(b,"-").concat(e.length):void 0===b?g:"".concat(g,"-").concat(b),f});export function Node(a){var b=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{},c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:{},d=_objectSpread(_objectSpread({},b),c);return d.theme&&!d.nodetheme&&(d.nodetheme=d.theme),new BaseNode(a,d)}/**
+ */_defineProperty(BaseNode,"_isServer","undefined"==typeof window),_defineProperty(BaseNode,"_generateKey",function(a){var b=a.nodeIndex,c=a.element,d=a.existingKey,e=a.children;if(d)return d;var f,g=getElementTypeName(c);return f=Array.isArray(e)&&0<e.length?void 0===b?"".concat(g,"-").concat(e.length):"".concat(g,"-").concat(b,"-").concat(e.length):void 0===b?g:"".concat(g,"-").concat(b),f});export function Node(a){var b=1<arguments.length&&arguments[1]!==void 0?arguments[1]:{},c=2<arguments.length&&arguments[2]!==void 0?arguments[2]:{},d=_objectSpread(_objectSpread({},b),c);return new BaseNode(a,d)}/**
  * Creates a curried node factory for a given React element or component type.
  *
  * Returns a function that, when called with props, produces a `NodeInstance<E>`.