"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__, {
    selectAddNodeToCanvas: ()=>selectAddNodeToCanvas,
    selectNavigateToDepth: ()=>selectNavigateToDepth,
    selectInitializeWithData: ()=>selectInitializeWithData,
    selectNavigateToCanvas: ()=>selectNavigateToCanvas,
    selectNavigateToSiblingCanvas: ()=>selectNavigateToSiblingCanvas,
    selectCanvasActions: ()=>selectCanvasActions,
    selectCurrentCanvas: ()=>selectCurrentCanvas,
    selectDrillIntoNode: ()=>selectDrillIntoNode,
    selectGetNodeById: ()=>selectGetNodeById,
    selectGetBreadcrumbs: ()=>selectGetBreadcrumbs,
    useCanvasStore: ()=>useCanvasStore,
    selectUpdateSelection: ()=>selectUpdateSelection,
    selectAddNode: ()=>selectAddNode,
    selectBreadcrumbs: ()=>selectBreadcrumbs,
    selectCreateChildCanvas: ()=>selectCreateChildCanvas,
    selectCurrentPath: ()=>selectCurrentPath,
    selectCanvasStack: ()=>selectCanvasStack,
    selectInitializeCanvas: ()=>selectInitializeCanvas,
    selectRemoveEdge: ()=>selectRemoveEdge,
    selectTransitionState: ()=>selectTransitionState,
    selectUpdateEdges: ()=>selectUpdateEdges,
    selectUpdateNodes: ()=>selectUpdateNodes,
    selectCurrentPathLength: ()=>selectCurrentPathLength,
    selectUpdateTransitionState: ()=>selectUpdateTransitionState,
    selectPreviousCanvas: ()=>selectPreviousCanvas,
    selectRemoveNode: ()=>selectRemoveNode,
    selectUpdateNode: ()=>selectUpdateNode,
    selectUpdateViewport: ()=>selectUpdateViewport
});
const external_reselect_namespaceObject = require("reselect");
const external_zustand_namespaceObject = require("zustand");
const middleware_namespaceObject = require("zustand/middleware");
const external_animatedViewportManager_cjs_namespaceObject = require("./animatedViewportManager.cjs");
const selectCurrentCanvas = (state)=>{
    const currentCanvasId = state.currentPath[state.currentPath.length - 1];
    return currentCanvasId ? state.canvasStack[currentCanvasId] : void 0;
};
const selectPreviousCanvas = (state)=>{
    const previousIndex = state.currentPath.length - 2;
    if (previousIndex < 0) return;
    const previousCanvasId = state.currentPath[previousIndex];
    return previousCanvasId ? state.canvasStack[previousCanvasId] : void 0;
};
const selectBreadcrumbs = (0, external_reselect_namespaceObject.createSelector)([
    (state)=>state.currentPath,
    (state)=>state.canvasStack
], (currentPath, canvasStack)=>currentPath.map((canvasId)=>{
        const canvas = canvasStack[canvasId];
        return {
            id: canvasId,
            name: canvas?.name || canvasId
        };
    }));
const selectCanvasActions = (state)=>({
        navigateToCanvas: state.navigateToCanvas,
        navigateToDepth: state.navigateToDepth,
        drillIntoNode: state.drillIntoNode,
        navigateToSiblingCanvas: state.navigateToSiblingCanvas,
        addNode: state.addNode,
        addNodeToCanvas: state.addNodeToCanvas,
        createChildCanvas: state.createChildCanvas,
        updateNode: state.updateNode,
        removeNode: state.removeNode,
        updateNodes: state.updateNodes,
        updateEdges: state.updateEdges,
        updateSelection: state.updateSelection,
        updateViewport: state.updateViewport,
        updateTransitionState: state.updateTransitionState
    });
const selectTransitionState = (state)=>state.transitionState;
const selectCanvasStack = (state)=>state.canvasStack;
const selectInitializeWithData = (state)=>state.initializeWithData;
const selectCurrentPath = (state)=>state.currentPath;
const selectCurrentPathLength = (state)=>state.currentPath.length;
const selectInitializeCanvas = (state)=>state.initializeCanvas;
const selectNavigateToCanvas = (state)=>state.navigateToCanvas;
const selectNavigateToDepth = (state)=>state.navigateToDepth;
const selectNavigateToSiblingCanvas = (state)=>state.navigateToSiblingCanvas;
const selectDrillIntoNode = (state)=>state.drillIntoNode;
const selectAddNode = (state)=>state.addNode;
const selectAddNodeToCanvas = (state)=>state.addNodeToCanvas;
const selectUpdateNode = (state)=>state.updateNode;
const selectRemoveNode = (state)=>state.removeNode;
const selectUpdateNodes = (state)=>state.updateNodes;
const selectGetNodeById = (state)=>state.getNodeById;
const selectUpdateEdges = (state)=>state.updateEdges;
const selectRemoveEdge = (state)=>state.removeEdge;
const selectCreateChildCanvas = (state)=>state.createChildCanvas;
const selectUpdateSelection = (state)=>state.updateSelection;
const selectUpdateViewport = (state)=>state.updateViewport;
const selectUpdateTransitionState = (state)=>state.updateTransitionState;
const selectGetBreadcrumbs = (state)=>state.getBreadcrumbs;
const createDemoCanvases = ()=>{
    const rootCanvas = {
        id: 'root',
        name: 'Main Workflow',
        nodes: [
            {
                type: 'blank-canvas-node',
                position: {
                    x: 500,
                    y: 500
                },
                id: 'blank-canvas-node',
                data: {
                    label: 'Start Here'
                }
            }
        ],
        edges: [],
        nodeTypes: [
            'default'
        ],
        edgeTypes: [
            'default'
        ],
        viewport: {
            x: 0,
            y: 0,
            zoom: 1
        },
        selection: {
            isSingleNodeSelected: false,
            isSingleEdgeSelected: false,
            nodeIds: [],
            edgeIds: []
        },
        options: {},
        properties: {}
    };
    return {
        root: rootCanvas
    };
};
const useCanvasStore = (0, external_zustand_namespaceObject.create)()((0, middleware_namespaceObject.devtools)((set, get)=>({
        canvasStack: {},
        currentPath: [],
        transitionState: {
            isTransitioning: false,
            type: 'none',
            startTime: 0,
            progress: 0
        },
        initializeCanvas: ()=>{
            set({
                canvasStack: createDemoCanvases(),
                currentPath: [
                    'root'
                ]
            });
            external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.setTransitionCallbacks({
                onStart: (type)=>{
                    set((state)=>({
                            transitionState: {
                                ...state.transitionState,
                                isTransitioning: true,
                                type,
                                startTime: performance.now(),
                                progress: 0
                            }
                        }));
                },
                onUpdate: (transitionState)=>{
                    set({
                        transitionState
                    });
                },
                onComplete: (_type)=>{
                    set((state)=>({
                            transitionState: {
                                ...state.transitionState,
                                isTransitioning: false,
                                type: 'none',
                                progress: 1
                            }
                        }));
                }
            });
        },
        initializeWithData: (canvases, initialPath)=>{
            const canvasKeys = Object.keys(canvases);
            const firstKey = canvasKeys[0];
            const path = initialPath ?? (firstKey ? [
                firstKey
            ] : []);
            set({
                canvasStack: canvases,
                currentPath: path
            });
            external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.setTransitionCallbacks({
                onStart: (type)=>{
                    set((state)=>({
                            transitionState: {
                                ...state.transitionState,
                                isTransitioning: true,
                                type,
                                startTime: performance.now(),
                                progress: 0
                            }
                        }));
                },
                onUpdate: (transitionState)=>{
                    set({
                        transitionState
                    });
                },
                onComplete: (_type)=>{
                    set((state)=>({
                            transitionState: {
                                ...state.transitionState,
                                isTransitioning: false,
                                type: 'none',
                                progress: 1
                            }
                        }));
                }
            });
        },
        navigateToCanvas: async (targetCanvasId, sourceViewport, animated = true)=>{
            const state = get();
            const targetCanvas = state.canvasStack[targetCanvasId];
            if (!targetCanvas) return;
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            const updatedCanvasStack = {
                ...state.canvasStack
            };
            if (sourceViewport && currentCanvasId && state.canvasStack[currentCanvasId]) updatedCanvasStack[currentCanvasId] = {
                ...state.canvasStack[currentCanvasId],
                viewport: sourceViewport
            };
            set({
                canvasStack: updatedCanvasStack,
                currentPath: [
                    ...state.currentPath,
                    targetCanvasId
                ]
            });
            if (animated && targetCanvas.viewport) try {
                await external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.animateToViewport(targetCanvas.viewport, void 0, 'drill-in');
            } catch (error) {
                console.warn('Canvas navigation animation failed:', error);
            }
        },
        navigateToDepth: async (depth, animated = true)=>{
            const state = get();
            if (depth < 0 || depth >= state.currentPath.length) return;
            const newPath = state.currentPath.slice(0, depth + 1);
            const targetCanvasId = newPath[newPath.length - 1];
            const targetCanvas = targetCanvasId ? state.canvasStack[targetCanvasId] : void 0;
            set({
                currentPath: newPath
            });
            if (animated && targetCanvas?.viewport) try {
                await external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.animateToViewport(targetCanvas.viewport, void 0, 'drill-out');
            } catch (error) {
                console.warn('Canvas navigation animation failed:', error);
            }
        },
        navigateToSiblingCanvas: async (targetCanvasId, animated = true)=>{
            const state = get();
            const targetCanvas = state.canvasStack[targetCanvasId];
            if (!targetCanvas || 0 === state.currentPath.length) return;
            const newPath = [
                ...state.currentPath.slice(0, -1),
                targetCanvasId
            ];
            set({
                currentPath: newPath
            });
            if (animated && targetCanvas.viewport) try {
                await external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.animateToViewport(targetCanvas.viewport, void 0, 'drill-in');
            } catch (error) {
                console.warn('Sibling canvas navigation animation failed:', error);
            }
        },
        drillIntoNode: async (nodeId, animated = true)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            const targetNode = currentCanvas.nodes.find((node)=>node.id === nodeId);
            if (!targetNode || !targetNode.data?.isDrillable || !targetNode.data?.childCanvasId) return void console.warn(`Node ${nodeId} is not drillable or child canvas not found`);
            const childCanvasId = targetNode.data.childCanvasId;
            const childCanvas = state.canvasStack[childCanvasId];
            if (!childCanvas) return void console.warn(`Child canvas ${childCanvasId} not found`);
            const currentViewport = external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.getCurrentViewport();
            const updatedCanvasStack = {
                ...state.canvasStack,
                [currentCanvasId]: {
                    ...currentCanvas,
                    viewport: currentViewport
                }
            };
            set({
                canvasStack: updatedCanvasStack,
                currentPath: [
                    ...state.currentPath,
                    childCanvasId
                ]
            });
            if (animated) try {
                await external_animatedViewportManager_cjs_namespaceObject.animatedViewportManager.drillIntoNode(targetNode);
            } catch (error) {
                console.warn('Drill-in animation failed:', error);
            }
            else set({
                currentPath: [
                    ...state.currentPath,
                    childCanvasId
                ]
            });
        },
        addNode: (nodeType, position)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId) return '';
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return '';
            const nodeId = `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
            const isDrillable = 'subprocess' === nodeType || 'process' === nodeType || 'loop' === nodeType;
            const defaultParams = {
                label: 'subprocess' === nodeType ? 'Sub-Process' : 'process' === nodeType ? 'Process' : 'New Node',
                isDrillable
            };
            const nodePosition = position || {
                x: 100 + 50 * currentCanvas.nodes.length % 400,
                y: 100 + 100 * Math.floor(currentCanvas.nodes.length / 8)
            };
            const newNode = {
                id: nodeId,
                type: nodeType,
                position: nodePosition,
                data: {
                    ...defaultParams,
                    nodeType,
                    parameters: defaultParams,
                    isDrillable,
                    childCanvasId: isDrillable ? `canvas-${nodeId}` : null
                }
            };
            const updatedCanvasStack = {
                ...state.canvasStack
            };
            if (isDrillable) {
                const childCanvasId = `canvas-${nodeId}`;
                newNode.data = {
                    ...newNode.data,
                    isDrillable: true,
                    childCanvasId
                };
                const childCanvas = {
                    id: childCanvasId,
                    name: defaultParams.label || 'Sub-Process',
                    nodes: [],
                    edges: [],
                    nodeTypes: currentCanvas.nodeTypes,
                    edgeTypes: currentCanvas.edgeTypes,
                    viewport: {
                        x: 0,
                        y: 0,
                        zoom: 1
                    },
                    selection: {
                        isSingleNodeSelected: false,
                        isSingleEdgeSelected: false,
                        nodeIds: [],
                        edgeIds: []
                    },
                    options: {},
                    properties: {}
                };
                updatedCanvasStack[childCanvasId] = childCanvas;
            }
            const updatedNodes = [
                ...currentCanvas.nodes,
                newNode
            ];
            updatedCanvasStack[currentCanvasId] = {
                ...currentCanvas,
                nodes: updatedNodes
            };
            set({
                canvasStack: updatedCanvasStack
            });
            return nodeId;
        },
        addNodeToCanvas: (node)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        nodes: [
                            ...currentCanvas.nodes,
                            node
                        ]
                    }
                }
            });
        },
        createChildCanvas: (parentNodeId, childCanvasId, name)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            const childCanvas = {
                id: childCanvasId,
                name,
                nodes: [],
                edges: [],
                nodeTypes: currentCanvas.nodeTypes,
                edgeTypes: currentCanvas.edgeTypes,
                viewport: {
                    x: 0,
                    y: 0,
                    zoom: 1
                },
                selection: {
                    isSingleNodeSelected: false,
                    isSingleEdgeSelected: false,
                    nodeIds: [],
                    edgeIds: []
                },
                options: {},
                properties: {}
            };
            const updatedNodes = currentCanvas.nodes.map((node)=>node.id === parentNodeId ? {
                    ...node,
                    data: {
                        ...node.data,
                        isDrillable: true,
                        childCanvasId
                    }
                } : node);
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        nodes: updatedNodes
                    },
                    [childCanvasId]: childCanvas
                }
            });
        },
        updateNode: (updatedNode)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            const updatedNodes = currentCanvas.nodes.map((node)=>node.id === updatedNode.id ? updatedNode : node);
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        nodes: updatedNodes
                    }
                }
            });
        },
        removeNode: (nodeId)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId || 'string' != typeof currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            const updatedNodes = currentCanvas.nodes.filter((n)=>n.id !== nodeId);
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        nodes: updatedNodes
                    }
                }
            });
        },
        removeEdge: (edgeId)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId || 'string' != typeof currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            const updatedEdges = currentCanvas.edges.filter((e)=>e.id !== edgeId);
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        edges: updatedEdges
                    }
                }
            });
        },
        updateNodes: (nodes)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId || 'string' != typeof currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        nodes
                    }
                }
            });
        },
        updateEdges: (edges)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId || 'string' != typeof currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        edges
                    }
                }
            });
        },
        updateSelection: (nodeIds, edgeIds)=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            if (!currentCanvasId || 'string' != typeof currentCanvasId) return;
            const currentCanvas = state.canvasStack[currentCanvasId];
            if (!currentCanvas) return;
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [currentCanvasId]: {
                        ...currentCanvas,
                        selection: {
                            isSingleNodeSelected: 1 === nodeIds.length && 0 === edgeIds.length,
                            isSingleEdgeSelected: 1 === edgeIds.length && 0 === nodeIds.length,
                            nodeIds,
                            edgeIds
                        }
                    }
                }
            });
        },
        updateViewport: (viewport, canvasId)=>{
            const state = get();
            const targetCanvasId = canvasId || state.currentPath[state.currentPath.length - 1];
            if (!targetCanvasId || 'string' != typeof targetCanvasId) return;
            const targetCanvas = state.canvasStack[targetCanvasId];
            if (!targetCanvas) return;
            set({
                canvasStack: {
                    ...state.canvasStack,
                    [targetCanvasId]: {
                        ...targetCanvas,
                        viewport
                    }
                }
            });
        },
        getCurrentCanvas: ()=>{
            const state = get();
            const currentCanvasId = state.currentPath[state.currentPath.length - 1];
            return currentCanvasId ? state.canvasStack[currentCanvasId] : void 0;
        },
        updateTransitionState: (transitionUpdate)=>{
            set((state)=>({
                    transitionState: {
                        ...state.transitionState,
                        ...transitionUpdate
                    }
                }));
        },
        getNodeById: (nodeId, canvasId)=>{
            const state = get();
            const targetCanvasId = canvasId || state.currentPath[state.currentPath.length - 1];
            if (!targetCanvasId) return;
            const canvas = state.canvasStack[targetCanvasId];
            if (!canvas) return;
            return canvas.nodes.find((node)=>node.id === nodeId);
        },
        getBreadcrumbs: ()=>{
            const state = get();
            return state.currentPath.map((canvasId)=>{
                const canvas = state.canvasStack[canvasId];
                return {
                    id: canvasId,
                    name: canvas?.name || canvasId
                };
            });
        }
    }), {
    trace: true
}));
exports.selectAddNode = __webpack_exports__.selectAddNode;
exports.selectAddNodeToCanvas = __webpack_exports__.selectAddNodeToCanvas;
exports.selectBreadcrumbs = __webpack_exports__.selectBreadcrumbs;
exports.selectCanvasActions = __webpack_exports__.selectCanvasActions;
exports.selectCanvasStack = __webpack_exports__.selectCanvasStack;
exports.selectCreateChildCanvas = __webpack_exports__.selectCreateChildCanvas;
exports.selectCurrentCanvas = __webpack_exports__.selectCurrentCanvas;
exports.selectCurrentPath = __webpack_exports__.selectCurrentPath;
exports.selectCurrentPathLength = __webpack_exports__.selectCurrentPathLength;
exports.selectDrillIntoNode = __webpack_exports__.selectDrillIntoNode;
exports.selectGetBreadcrumbs = __webpack_exports__.selectGetBreadcrumbs;
exports.selectGetNodeById = __webpack_exports__.selectGetNodeById;
exports.selectInitializeCanvas = __webpack_exports__.selectInitializeCanvas;
exports.selectInitializeWithData = __webpack_exports__.selectInitializeWithData;
exports.selectNavigateToCanvas = __webpack_exports__.selectNavigateToCanvas;
exports.selectNavigateToDepth = __webpack_exports__.selectNavigateToDepth;
exports.selectNavigateToSiblingCanvas = __webpack_exports__.selectNavigateToSiblingCanvas;
exports.selectPreviousCanvas = __webpack_exports__.selectPreviousCanvas;
exports.selectRemoveEdge = __webpack_exports__.selectRemoveEdge;
exports.selectRemoveNode = __webpack_exports__.selectRemoveNode;
exports.selectTransitionState = __webpack_exports__.selectTransitionState;
exports.selectUpdateEdges = __webpack_exports__.selectUpdateEdges;
exports.selectUpdateNode = __webpack_exports__.selectUpdateNode;
exports.selectUpdateNodes = __webpack_exports__.selectUpdateNodes;
exports.selectUpdateSelection = __webpack_exports__.selectUpdateSelection;
exports.selectUpdateTransitionState = __webpack_exports__.selectUpdateTransitionState;
exports.selectUpdateViewport = __webpack_exports__.selectUpdateViewport;
exports.useCanvasStore = __webpack_exports__.useCanvasStore;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "selectAddNode",
    "selectAddNodeToCanvas",
    "selectBreadcrumbs",
    "selectCanvasActions",
    "selectCanvasStack",
    "selectCreateChildCanvas",
    "selectCurrentCanvas",
    "selectCurrentPath",
    "selectCurrentPathLength",
    "selectDrillIntoNode",
    "selectGetBreadcrumbs",
    "selectGetNodeById",
    "selectInitializeCanvas",
    "selectInitializeWithData",
    "selectNavigateToCanvas",
    "selectNavigateToDepth",
    "selectNavigateToSiblingCanvas",
    "selectPreviousCanvas",
    "selectRemoveEdge",
    "selectRemoveNode",
    "selectTransitionState",
    "selectUpdateEdges",
    "selectUpdateNode",
    "selectUpdateNodes",
    "selectUpdateSelection",
    "selectUpdateTransitionState",
    "selectUpdateViewport",
    "useCanvasStore"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});
