"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, definition)=>{
        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
            enumerable: true,
            get: definition[key]
        });
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    BaseNode: ()=>BaseNode
});
const jsx_runtime_namespaceObject = require("react/jsx-runtime");
const react_cjs_namespaceObject = require("../../xyflow/react.cjs");
const external_react_namespaceObject = require("react");
const external_constants_cjs_namespaceObject = require("../../constants.cjs");
const index_cjs_namespaceObject = require("../../core/index.cjs");
const external_hooks_index_cjs_namespaceObject = require("../../hooks/index.cjs");
const adornment_resolver_cjs_namespaceObject = require("../../utils/adornment-resolver.cjs");
const icon_registry_cjs_namespaceObject = require("../../utils/icon-registry.cjs");
const manifest_resolver_cjs_namespaceObject = require("../../utils/manifest-resolver.cjs");
const NodeUtils_cjs_namespaceObject = require("../../utils/NodeUtils.cjs");
const toolbar_resolver_cjs_namespaceObject = require("../../utils/toolbar-resolver.cjs");
const BaseCanvasModeProvider_cjs_namespaceObject = require("../BaseCanvas/BaseCanvasModeProvider.cjs");
const CanvasThemeContext_cjs_namespaceObject = require("../BaseCanvas/CanvasThemeContext.cjs");
const ConnectedHandlesContext_cjs_namespaceObject = require("../BaseCanvas/ConnectedHandlesContext.cjs");
const SelectionStateContext_cjs_namespaceObject = require("../BaseCanvas/SelectionStateContext.cjs");
const SmartHandle_cjs_namespaceObject = require("../ButtonHandle/SmartHandle.cjs");
const useButtonHandles_cjs_namespaceObject = require("../ButtonHandle/useButtonHandles.cjs");
const InitialsBadge_cjs_namespaceObject = require("../shared/InitialsBadge.cjs");
const external_Toolbar_index_cjs_namespaceObject = require("../Toolbar/index.cjs");
const external_BaseNodeBadgeSlot_cjs_namespaceObject = require("./BaseNodeBadgeSlot.cjs");
const external_BaseNodeConfigContext_cjs_namespaceObject = require("./BaseNodeConfigContext.cjs");
const external_BaseNodeContainer_cjs_namespaceObject = require("./BaseNodeContainer.cjs");
const external_BaseNodeInnerShape_cjs_namespaceObject = require("./BaseNodeInnerShape.cjs");
const external_BaseNodeMissingManifest_cjs_namespaceObject = require("./BaseNodeMissingManifest.cjs");
const external_NodeLabel_cjs_namespaceObject = require("./NodeLabel.cjs");
const getContainerWidth = (shape, width)=>{
    const defaultWidth = 'rectangle' === shape ? external_constants_cjs_namespaceObject.DEFAULT_RECTANGLE_NODE_WIDTH : external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE;
    if (width && width !== external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE && width !== external_constants_cjs_namespaceObject.DEFAULT_RECTANGLE_NODE_WIDTH) return width;
    return defaultWidth;
};
const getContainerHeight = (height, hasFooter, footerVariant)=>{
    if (hasFooter) switch(footerVariant){
        case 'button':
            return external_constants_cjs_namespaceObject.NODE_HEIGHT_FOOTER_BUTTON;
        case 'single':
            return external_constants_cjs_namespaceObject.NODE_HEIGHT_FOOTER_SINGLE;
        case 'double':
            return external_constants_cjs_namespaceObject.NODE_HEIGHT_FOOTER_DOUBLE;
        default:
            return 'auto';
    }
    return height || external_constants_cjs_namespaceObject.NODE_HEIGHT_DEFAULT;
};
const BaseNodeComponent = (props)=>{
    const { type, data, selected, id, dragging, width, height, parentId } = props;
    const { onHandleAction: onHandleActionProp, shouldShowAddButtonFn: shouldShowAddButtonFnProp, shouldShowButtonHandleNotchesFn: shouldShowButtonHandleNotchesFnProp, toolbarConfig: toolbarConfigProp, handleConfigurations: handleConfigurationsProp, adornments: adornmentsProp, suggestionType, disabled, executionStatusOverride, labelTooltip, labelBackgroundColor, footerVariant, footerComponent, subLabelComponent, iconComponent } = (0, external_BaseNodeConfigContext_cjs_namespaceObject.useBaseNodeOverrideConfig)();
    const updateNodeInternals = (0, react_cjs_namespaceObject.useUpdateNodeInternals)();
    const { updateNodeData, updateNode } = (0, react_cjs_namespaceObject.useReactFlow)();
    const containerRef = (0, external_react_namespaceObject.useRef)(null);
    const [isHovered, setIsHovered] = (0, external_react_namespaceObject.useState)(false);
    const [isFocused, setIsFocused] = (0, external_react_namespaceObject.useState)(false);
    const syncedHeightRef = (0, external_react_namespaceObject.useRef)(void 0);
    const baseHeightRef = (0, external_react_namespaceObject.useRef)(external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE);
    if (height && height !== syncedHeightRef.current) baseHeightRef.current = height;
    const executionState = (0, external_hooks_index_cjs_namespaceObject.useNodeExecutionState)(id);
    const validationState = (0, external_hooks_index_cjs_namespaceObject.useElementValidationStatus)(id);
    const nodeTypeRegistry = (0, index_cjs_namespaceObject.useNodeTypeRegistry)();
    const { mode } = (0, BaseCanvasModeProvider_cjs_namespaceObject.useBaseCanvasMode)();
    const connectedHandleIds = (0, ConnectedHandlesContext_cjs_namespaceObject.useConnectedHandles)(id);
    const isConnecting = (0, react_cjs_namespaceObject.useStore)(NodeUtils_cjs_namespaceObject.selectIsConnecting);
    const { multipleNodesSelected } = (0, SelectionStateContext_cjs_namespaceObject.useSelectionState)();
    const { isDarkMode } = (0, CanvasThemeContext_cjs_namespaceObject.useCanvasTheme)();
    const manifest = (0, external_react_namespaceObject.useMemo)(()=>nodeTypeRegistry.getManifest(type), [
        type,
        nodeTypeRegistry
    ]);
    const statusContext = (0, external_react_namespaceObject.useMemo)(()=>({
            nodeId: id,
            executionState: executionStatusOverride ?? executionState,
            validationState,
            isConnecting,
            isSelected: selected,
            isDragging: dragging,
            mode
        }), [
        id,
        executionStatusOverride,
        executionState,
        validationState,
        isConnecting,
        selected,
        dragging,
        mode
    ]);
    const onHandleActionCallback = onHandleActionProp;
    const shouldShowAddButtonFn = shouldShowAddButtonFnProp;
    const shouldShowButtonHandleNotchesFn = shouldShowButtonHandleNotchesFnProp;
    const executionStatus = executionStatusOverride ?? ('string' == typeof executionState ? executionState : executionState?.status);
    const display = (0, external_react_namespaceObject.useMemo)(()=>(0, manifest_resolver_cjs_namespaceObject.resolveDisplay)(manifest?.display, {
            ...data,
            nodeId: id
        }), [
        manifest,
        data,
        id
    ]);
    const isStacked = Boolean(manifest?.drillable || data?.isCollapsed);
    const Icon = (0, external_react_namespaceObject.useMemo)(()=>{
        if (void 0 !== iconComponent) return iconComponent;
        if (display.icon) {
            const IconComponent = (0, icon_registry_cjs_namespaceObject.getIcon)(display.icon);
            return IconComponent ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(IconComponent, {}) : null;
        }
        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(InitialsBadge_cjs_namespaceObject.InitialsBadge, {
            name: display.label,
            size: "var(--icon-size)"
        });
    }, [
        iconComponent,
        display.icon,
        display.label
    ]);
    const handleConfigurations = (0, external_react_namespaceObject.useMemo)(()=>{
        if (handleConfigurationsProp && Array.isArray(handleConfigurationsProp)) return handleConfigurationsProp;
        const dataHandleConfigs = data?.handleConfigurations;
        if (dataHandleConfigs && Array.isArray(dataHandleConfigs)) return dataHandleConfigs;
        if (!manifest) return [];
        const resolved = (0, manifest_resolver_cjs_namespaceObject.resolveHandles)(manifest.handleConfiguration, {
            ...data,
            nodeId: id
        });
        return resolved.map((group)=>({
                position: group.position,
                handles: group.handles.map((h)=>({
                        id: h.id,
                        type: h.type,
                        handleType: h.handleType,
                        label: h.label,
                        visible: h.visible,
                        showButton: h.showButton,
                        constraints: h.constraints
                    })),
                visible: group.visible
            }));
    }, [
        handleConfigurationsProp,
        manifest,
        data,
        id
    ]);
    const toolbarConfig = (0, external_react_namespaceObject.useMemo)(()=>{
        if (void 0 !== toolbarConfigProp) return null === toolbarConfigProp ? void 0 : toolbarConfigProp;
        return manifest ? (0, toolbar_resolver_cjs_namespaceObject.resolveToolbar)(manifest, statusContext) : void 0;
    }, [
        toolbarConfigProp,
        manifest,
        statusContext
    ]);
    const adornments = (0, external_react_namespaceObject.useMemo)(()=>{
        const adornmentsFromProps = adornmentsProp ?? {};
        const adornmentsFromResolver = (0, adornment_resolver_cjs_namespaceObject.resolveAdornments)(statusContext);
        return {
            ...adornmentsFromResolver,
            ...adornmentsFromProps
        };
    }, [
        adornmentsProp,
        statusContext
    ]);
    const computedHeight = (0, external_react_namespaceObject.useMemo)(()=>{
        const leftHandles = handleConfigurations.filter((config)=>config.position === react_cjs_namespaceObject.Position.Left && false !== config.visible).reduce((count, config)=>count + config.handles.filter((h)=>false !== h.visible).length, 0);
        const rightHandles = handleConfigurations.filter((config)=>config.position === react_cjs_namespaceObject.Position.Right && false !== config.visible).reduce((count, config)=>count + config.handles.filter((h)=>false !== h.visible).length, 0);
        const leftRightHandles = Math.max(leftHandles, rightHandles);
        const minNodeHeight = (2 * leftRightHandles + 2) * external_constants_cjs_namespaceObject.GRID_SPACING;
        return Math.max(baseHeightRef.current, minNodeHeight);
    }, [
        handleConfigurations,
        height
    ]);
    (0, external_react_namespaceObject.useEffect)(()=>{
        updateNodeInternals(id);
    }, [
        handleConfigurations,
        id,
        updateNodeInternals
    ]);
    (0, external_react_namespaceObject.useEffect)(()=>{
        if (void 0 !== computedHeight && computedHeight !== height) {
            syncedHeightRef.current = computedHeight;
            const frameId = requestAnimationFrame(()=>{
                updateNode(id, {
                    height: computedHeight
                });
                updateNodeInternals(id);
            });
            return ()=>{
                cancelAnimationFrame(frameId);
            };
        }
    }, [
        computedHeight,
        height,
        id,
        updateNode,
        updateNodeInternals
    ]);
    const displayLabel = display.label;
    const displayShape = display.shape ?? 'square';
    const displayBackground = display.background;
    const displayColor = display.color;
    const displayIconBackground = isDarkMode ? display.iconBackgroundDark ?? display.iconBackground : display.iconBackground;
    const displayLabelTooltip = labelTooltip;
    const displayLabelBackgroundColor = labelBackgroundColor;
    const displayFooterVariant = footerVariant;
    const displaySubLabel = (0, external_react_namespaceObject.useMemo)(()=>{
        if (void 0 !== subLabelComponent) return subLabelComponent;
        return display.subLabel;
    }, [
        subLabelComponent,
        display.subLabel
    ]);
    const displayFooter = footerComponent;
    const hasFooter = !!displayFooter;
    const containerWidth = getContainerWidth(displayShape, width);
    const containerHeight = getContainerHeight(height, hasFooter, displayFooterVariant);
    const nodeVars = (0, external_react_namespaceObject.useMemo)(()=>{
        const numH = 'number' == typeof containerHeight ? containerHeight : external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE;
        const getRadius = (basis, ratio)=>'circle' === displayShape ? '50%' : hasFooter ? `${external_constants_cjs_namespaceObject.GRID_SPACING}px` : `${basis * ratio}px`;
        const radiusBasis = Math.min(containerWidth, numH);
        const nodeRadius = getRadius(radiusBasis, external_constants_cjs_namespaceObject.NODE_CONTAINER_RADIUS_RATIO);
        const effectiveH = hasFooter ? external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE : numH;
        const effectiveW = hasFooter ? external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE : containerWidth;
        const innerBasis = Math.min(effectiveH, effectiveW);
        const innerRadius = getRadius(innerBasis, external_constants_cjs_namespaceObject.NODE_INNER_RADIUS_RATIO);
        const gap = innerBasis * (1 - external_constants_cjs_namespaceObject.NODE_INNER_SHAPE_RATIO);
        const keepSquare = 'circle' === displayShape || 'rectangle' === displayShape;
        const innerW = keepSquare ? innerBasis - gap : effectiveW - gap;
        const innerH = keepSquare ? innerBasis - gap : effectiveH - gap;
        return {
            '--node-w': `${containerWidth}px`,
            '--node-h': 'number' == typeof containerHeight ? `${containerHeight}px` : 'auto',
            '--node-radius': nodeRadius,
            '--node-gap': `${(gap - 2 * external_constants_cjs_namespaceObject.NODE_BORDER_SIZE) / 2}px`,
            '--inner-w': `${innerW}px`,
            '--inner-h': `${innerH}px`,
            '--inner-radius': innerRadius,
            '--icon-size': `${innerBasis * external_constants_cjs_namespaceObject.NODE_INNER_ICON_RATIO}px`
        };
    }, [
        containerWidth,
        containerHeight,
        displayShape,
        hasFooter
    ]);
    const interactionState = (0, external_react_namespaceObject.useMemo)(()=>{
        if (disabled) return 'disabled';
        if (dragging) return 'drag';
        if (selected) return 'selected';
        if (isFocused) return 'focus';
        if (isHovered) return 'hover';
        return 'default';
    }, [
        disabled,
        dragging,
        selected,
        isHovered,
        isFocused
    ]);
    const shouldShowHandles = (0, external_react_namespaceObject.useMemo)(()=>(isConnecting || selected || isHovered) && !dragging, [
        isConnecting,
        selected,
        isHovered,
        dragging
    ]);
    const toolbarPosition = toolbarConfig?.position ?? (toolbarConfig ? react_cjs_namespaceObject.Position.Top : void 0);
    const hasHandleButtonsAtToolbar = (0, external_react_namespaceObject.useMemo)(()=>{
        if (!toolbarPosition || !handleConfigurations?.length) return false;
        return handleConfigurations.some((config)=>config.position === toolbarPosition && false !== config.visible && config.handles.some((h)=>'source' === h.type && false !== h.showButton));
    }, [
        toolbarPosition,
        handleConfigurations
    ]);
    const hasVisibleBottomHandles = (0, external_react_namespaceObject.useMemo)(()=>{
        if (!handleConfigurations || !Array.isArray(handleConfigurations) || !selected || 'circle' === displayShape) return false;
        return handleConfigurations.some((config)=>config.position === react_cjs_namespaceObject.Position.Bottom && config.handles.length > 0 && false !== config.visible && (config.handles.some((h)=>'source' === h.type) || config.handles.some((h)=>h.showButton)));
    }, [
        handleConfigurations,
        selected,
        displayShape
    ]);
    const handleMouseEnter = (0, external_react_namespaceObject.useCallback)(()=>setIsHovered(true), []);
    const handleMouseLeave = (0, external_react_namespaceObject.useCallback)(()=>setIsHovered(false), []);
    const handleFocus = (0, external_react_namespaceObject.useCallback)(()=>setIsFocused(true), []);
    const handleBlur = (0, external_react_namespaceObject.useCallback)(()=>setIsFocused(false), []);
    const handleLabelChange = (0, external_react_namespaceObject.useCallback)((values)=>{
        const newDisplay = {
            ...data.display
        };
        for (const labelKey of Object.keys(values))if (values[labelKey]) newDisplay[labelKey] = values[labelKey];
        else delete newDisplay[labelKey];
        updateNodeData(id, {
            display: newDisplay
        });
    }, [
        id,
        data.display,
        updateNodeData
    ]);
    const showNotches = shouldShowButtonHandleNotchesFn ? shouldShowButtonHandleNotchesFn({
        isConnecting,
        isSelected: selected,
        isHovered
    }) : isConnecting || isHovered || selected;
    const handleAction = (0, external_react_namespaceObject.useCallback)((event)=>{
        setIsHovered(false);
        setIsFocused(false);
        if (onHandleActionCallback) onHandleActionCallback(event);
    }, [
        onHandleActionCallback
    ]);
    const useSmartHandles = data?.useSmartHandles ?? false;
    const buttonHandleElements = (0, useButtonHandles_cjs_namespaceObject.useButtonHandles)({
        handleConfigurations,
        shouldShowHandles,
        handleAction,
        nodeId: id,
        selected: selected ?? false,
        hovered: isHovered,
        showAddButton: 'design' === mode && !multipleNodesSelected && !isConnecting && !dragging,
        showNotches,
        nodeWidth: width,
        nodeHeight: height,
        shouldShowAddButtonFn,
        portalActions: !!parentId
    });
    const smartHandleElements = (0, external_react_namespaceObject.useMemo)(()=>{
        if (!useSmartHandles) return null;
        if (!handleConfigurations || !Array.isArray(handleConfigurations)) return null;
        let handleIndex = 0;
        const handles = handleConfigurations.flatMap((config)=>config.handles.map((handle)=>{
                const defaultPosition = config.position;
                const configVisible = config.visible ?? true;
                const currentIndex = handleIndex++;
                const handleVisualType = handle.handleType ?? ('source' === handle.type ? 'output' : 'input');
                const hasConnection = connectedHandleIds.has(handle.id);
                const isVisible = hasConnection || shouldShowHandles && configVisible;
                const shouldShowButton = 'design' === mode && selected && handle.showButton && !multipleNodesSelected;
                return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SmartHandle_cjs_namespaceObject.SmartHandle, {
                    type: handle.type,
                    id: handle.id,
                    defaultPosition: defaultPosition,
                    handleType: handleVisualType,
                    nodeWidth: width,
                    nodeHeight: height,
                    label: handle.label,
                    showButton: shouldShowButton,
                    selected: selected,
                    showNotches: showNotches,
                    onAction: handleAction,
                    visible: isVisible,
                    configOrder: currentIndex
                }, `${handle.id}-${handle.type}`);
            }));
        return handles.length > 0 ? handles : null;
    }, [
        useSmartHandles,
        handleConfigurations,
        shouldShowHandles,
        width,
        height,
        mode,
        selected,
        showNotches,
        handleAction,
        multipleNodesSelected,
        connectedHandleIds
    ]);
    const handleElements = useSmartHandles ? smartHandleElements : buttonHandleElements;
    if (!manifest) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
        ref: containerRef,
        className: "relative",
        style: nodeVars,
        onMouseEnter: handleMouseEnter,
        onMouseLeave: handleMouseLeave,
        onFocus: handleFocus,
        onBlur: handleBlur,
        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeMissingManifest_cjs_namespaceObject.MissingManifestNode, {
            type: data.nodeType,
            isSelected: selected,
            isHovered: isHovered,
            interactionState: interactionState
        })
    });
    const nodeContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
        ref: containerRef,
        className: "relative",
        style: nodeVars,
        onMouseEnter: handleMouseEnter,
        onMouseLeave: handleMouseLeave,
        onFocus: handleFocus,
        onBlur: handleBlur,
        children: [
            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_BaseNodeContainer_cjs_namespaceObject.BaseContainer, {
                shape: displayShape,
                isSelected: selected,
                isHovered: isHovered,
                isStacked: isStacked,
                interactionState: interactionState,
                executionStatus: executionStatus,
                validationStatus: validationState?.validationStatus,
                suggestionType: suggestionType,
                hasFooter: hasFooter,
                background: displayBackground,
                loading: data.loading,
                children: [
                    (Icon || data.loading) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeInnerShape_cjs_namespaceObject.BaseInnerShape, {
                        color: displayColor,
                        background: displayIconBackground,
                        loading: data.loading,
                        children: data.loading ? null : Icon
                    }),
                    adornments?.topLeft && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeBadgeSlot_cjs_namespaceObject.BaseBadgeSlot, {
                        position: "top-left",
                        shape: displayShape,
                        children: adornments.topLeft
                    }),
                    adornments?.topRight && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeBadgeSlot_cjs_namespaceObject.BaseBadgeSlot, {
                        position: "top-right",
                        shape: displayShape,
                        children: adornments.topRight
                    }),
                    adornments?.bottomRight && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeBadgeSlot_cjs_namespaceObject.BaseBadgeSlot, {
                        position: "bottom-right",
                        shape: displayShape,
                        children: adornments.bottomRight
                    }),
                    adornments?.bottomLeft && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_BaseNodeBadgeSlot_cjs_namespaceObject.BaseBadgeSlot, {
                        position: "bottom-left",
                        shape: displayShape,
                        children: adornments.bottomLeft
                    }),
                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_NodeLabel_cjs_namespaceObject.NodeLabel, {
                        label: displayLabel,
                        subLabel: displaySubLabel,
                        labelTooltip: displayLabelTooltip,
                        labelBackgroundColor: displayLabelBackgroundColor,
                        shape: displayShape,
                        hasBottomHandles: hasVisibleBottomHandles,
                        selected: selected,
                        dragging: dragging,
                        readonly: 'design' !== mode,
                        onChange: handleLabelChange
                    }),
                    displayFooter && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
                        className: "basis-full pt-0.5 min-w-0 overflow-hidden",
                        children: displayFooter
                    }),
                    toolbarConfig && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_Toolbar_index_cjs_namespaceObject.NodeToolbar, {
                        nodeId: id,
                        config: toolbarConfig,
                        expanded: selected || isHovered,
                        hidden: dragging || multipleNodesSelected,
                        offsetToolbar: hasHandleButtonsAtToolbar
                    })
                ]
            }),
            handleElements
        ]
    });
    if (useSmartHandles) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SmartHandle_cjs_namespaceObject.SmartHandleProvider, {
        nodeWidth: width,
        nodeHeight: height,
        children: nodeContent
    });
    return nodeContent;
};
const BaseNode = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(BaseNodeComponent);
exports.BaseNode = __webpack_exports__.BaseNode;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "BaseNode"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});
