@godscene/playground-electron 1.7.11

package/dist/es/session-state.mjs

@@ -0,0 +1,32 @@
+function resolveSessionViewState(runtimeInfo) {
+    const metadata = (null == runtimeInfo ? void 0 : runtimeInfo.metadata) || {};
+    const rawSetupState = metadata.setupState;
+    const setupState = 'blocked' === rawSetupState || 'ready' === rawSetupState || 'required' === rawSetupState ? rawSetupState : 'ready';
+    return {
+        connected: Boolean(metadata.sessionConnected),
+        displayName: 'string' == typeof metadata.sessionDisplayName ? metadata.sessionDisplayName : void 0,
+        setupState,
+        setupBlockingReason: 'string' == typeof metadata.setupBlockingReason ? metadata.setupBlockingReason : void 0
+    };
+}
+function buildSessionInitialValues(setup, existingValues = {}) {
+    if (!setup) return {};
+    return Object.fromEntries(setup.fields.map((field)=>[
+            field.key,
+            resolveSessionFieldValue(field, existingValues[field.key])
+        ]));
+}
+function hasSessionFieldValue(value) {
+    return null != value && '' !== value;
+}
+function resolveSessionFieldValue(field, existingValue) {
+    var _ref;
+    if (hasSessionFieldValue(existingValue)) return existingValue;
+    if ('select' === field.type) {
+        var _ref1, _field_defaultValue;
+        var _field_options_, _field_options;
+        return null != (_ref1 = null != (_field_defaultValue = field.defaultValue) ? _field_defaultValue : null == (_field_options = field.options) ? void 0 : null == (_field_options_ = _field_options[0]) ? void 0 : _field_options_.value) ? _ref1 : '';
+    }
+    return null != (_ref = null != existingValue ? existingValue : field.defaultValue) ? _ref : '';
+}
+export { buildSessionInitialValues, resolveSessionViewState };

package/dist/es/useServerStatus.mjs

@@ -0,0 +1,120 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { buildFallbackRuntimeInfo, filterValidExecutionUxHints, normalizeRuntimeDeviceType } from "./runtime-info.mjs";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function useServerStatus(playgroundSDK, defaultDeviceType, pollIntervalMs) {
+    const [serverOnline, setServerOnline] = useState(false);
+    const [isUserOperating, setIsUserOperating] = useState(false);
+    const [deviceType, setDeviceType] = useState(defaultDeviceType);
+    const [runtimeInfo, setRuntimeInfo] = useState(null);
+    const [executionUxHints, setExecutionUxHints] = useState([]);
+    const runtimeInfoRef = useRef(null);
+    const mountedRef = useRef(true);
+    useEffect(()=>{
+        mountedRef.current = true;
+        return ()=>{
+            mountedRef.current = false;
+        };
+    }, []);
+    useEffect(()=>{
+        runtimeInfoRef.current = runtimeInfo;
+    }, [
+        runtimeInfo
+    ]);
+    useEffect(()=>{
+        playgroundSDK.onProgressUpdate((tip)=>{
+            setIsUserOperating(Boolean(tip));
+        });
+    }, [
+        playgroundSDK
+    ]);
+    const refreshServerState = useCallback(()=>_async_to_generator(function*() {
+            try {
+                const online = yield playgroundSDK.checkStatus();
+                if (!mountedRef.current) return;
+                setServerOnline(online);
+                if (!online) {
+                    runtimeInfoRef.current = null;
+                    setRuntimeInfo(null);
+                    setExecutionUxHints([]);
+                    return;
+                }
+                try {
+                    const nextRuntimeInfo = yield playgroundSDK.getRuntimeInfo();
+                    if (!mountedRef.current) return;
+                    if (nextRuntimeInfo) {
+                        runtimeInfoRef.current = nextRuntimeInfo;
+                        setRuntimeInfo(nextRuntimeInfo);
+                        setDeviceType(normalizeRuntimeDeviceType(nextRuntimeInfo, defaultDeviceType));
+                        setExecutionUxHints(filterValidExecutionUxHints(nextRuntimeInfo));
+                        return;
+                    }
+                } catch (error) {
+                    console.warn('Failed to get runtime info:', error);
+                }
+                try {
+                    const interfaceInfo = yield playgroundSDK.getInterfaceInfo();
+                    if (!mountedRef.current || !(null == interfaceInfo ? void 0 : interfaceInfo.type)) return;
+                    const fallbackRuntimeInfo = buildFallbackRuntimeInfo(runtimeInfoRef.current, interfaceInfo);
+                    runtimeInfoRef.current = fallbackRuntimeInfo;
+                    setRuntimeInfo(fallbackRuntimeInfo);
+                    setDeviceType(normalizeRuntimeDeviceType(fallbackRuntimeInfo, defaultDeviceType));
+                    setExecutionUxHints(filterValidExecutionUxHints(fallbackRuntimeInfo));
+                } catch (error) {
+                    console.warn('Failed to get interface info:', error);
+                }
+            } catch (error) {
+                if (!mountedRef.current) return;
+                console.error('Failed to check server status:', error);
+                setServerOnline(false);
+            }
+        })(), [
+        defaultDeviceType,
+        playgroundSDK
+    ]);
+    useEffect(()=>{
+        refreshServerState();
+        const interval = window.setInterval(()=>{
+            refreshServerState();
+        }, pollIntervalMs);
+        return ()=>{
+            window.clearInterval(interval);
+        };
+    }, [
+        pollIntervalMs,
+        refreshServerState
+    ]);
+    return {
+        serverOnline,
+        isUserOperating,
+        deviceType,
+        runtimeInfo,
+        executionUxHints,
+        refreshServerState
+    };
+}
+export { useServerStatus };

package/dist/lib/DeviceInteractionLayer.js

@@ -0,0 +1,434 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    keyNameForKeyboardEvent: ()=>keyNameForKeyboardEvent,
+    inscribedContentRect: ()=>inscribedContentRect,
+    DeviceInteractionLayer: ()=>DeviceInteractionLayer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+external_react_default();
+const keyboardControlKeys = new Set([
+    'Backspace',
+    'Delete',
+    'Enter',
+    'Tab',
+    'Escape',
+    'ArrowLeft',
+    'ArrowRight',
+    'ArrowUp',
+    'ArrowDown',
+    'Home',
+    'End',
+    'PageUp',
+    'PageDown'
+]);
+const pureModifierKeys = new Set([
+    'Alt',
+    'Control',
+    'Meta',
+    'Shift'
+]);
+function isHostCopyShortcut(event) {
+    return !event.altKey && (event.metaKey || event.ctrlKey) && 'c' === event.key.toLowerCase();
+}
+function isHostReservedShortcut(event) {
+    if ('F5' === event.key || 'F11' === event.key || 'F12' === event.key) return true;
+    const hasPrimaryModifier = event.metaKey || event.ctrlKey;
+    if (!hasPrimaryModifier) return false;
+    const lowerKey = event.key.toLowerCase();
+    if (event.altKey && 'i' === lowerKey) return true;
+    if (event.shiftKey && ('i' === lowerKey || 'j' === lowerKey)) return true;
+    const hostReservedKeys = new Set([
+        'r',
+        'q',
+        'w',
+        'm',
+        'h',
+        'n',
+        't',
+        '+',
+        '=',
+        '-',
+        '_',
+        '0'
+    ]);
+    return hostReservedKeys.has(lowerKey);
+}
+function hasHostSelectionOutsideOverlay(overlay) {
+    const selection = window.getSelection();
+    if (!selection || selection.isCollapsed || !overlay) return false;
+    const { anchorNode, focusNode } = selection;
+    if (!anchorNode || !focusNode) return false;
+    return !overlay.contains(anchorNode) && !overlay.contains(focusNode);
+}
+function keyNameForKeyboardEvent(event) {
+    if (pureModifierKeys.has(event.key)) return null;
+    const parts = [];
+    if (event.ctrlKey) parts.push('Control');
+    if (event.metaKey) parts.push('Meta');
+    if (event.altKey) parts.push('Alt');
+    if (event.shiftKey && 'Shift' !== event.key) parts.push('Shift');
+    parts.push(' ' === event.key ? 'Space' : event.key);
+    return parts.join('+');
+}
+function inscribedContentRect(panel, deviceSize) {
+    const aspect = deviceSize.width / deviceSize.height;
+    if (panel.height <= 0 || panel.width <= 0) return panel;
+    if (panel.width / panel.height > aspect) {
+        const renderedWidth = panel.height * aspect;
+        return {
+            left: panel.left + (panel.width - renderedWidth) / 2,
+            top: panel.top,
+            width: renderedWidth,
+            height: panel.height
+        };
+    }
+    const renderedHeight = panel.width / aspect;
+    return {
+        left: panel.left,
+        top: panel.top + (panel.height - renderedHeight) / 2,
+        width: panel.width,
+        height: renderedHeight
+    };
+}
+function DeviceInteractionLayer({ enabled, deviceSize, onTap, onSwipe, keyboardEnabled = false, onTextInput, onKeyboardPress, tapMaxDistance = 8, tapMaxDurationMs = 250, style }) {
+    const overlayRef = (0, external_react_namespaceObject.useRef)(null);
+    const keyboardSinkRef = (0, external_react_namespaceObject.useRef)(null);
+    const activePointer = (0, external_react_namespaceObject.useRef)(null);
+    const composingRef = (0, external_react_namespaceObject.useRef)(false);
+    const keyboardArmedRef = (0, external_react_namespaceObject.useRef)(false);
+    const lastKeyboardPointRef = (0, external_react_namespaceObject.useRef)(null);
+    const focusKeyboardSink = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (keyboardEnabled) {
+            var _keyboardSinkRef_current;
+            keyboardArmedRef.current = true;
+            null == (_keyboardSinkRef_current = keyboardSinkRef.current) || _keyboardSinkRef_current.focus({
+                preventScroll: true
+            });
+        }
+    }, [
+        keyboardEnabled
+    ]);
+    const positionKeyboardSink = (0, external_react_namespaceObject.useCallback)((clientX, clientY)=>{
+        const overlay = overlayRef.current;
+        const sink = keyboardSinkRef.current;
+        if (!overlay || !sink) return;
+        const rect = overlay.getBoundingClientRect();
+        sink.style.left = `${Math.max(0, clientX - rect.left)}px`;
+        sink.style.top = `${Math.max(0, clientY - rect.top)}px`;
+    }, []);
+    const projectToDevice = (0, external_react_namespaceObject.useCallback)((clientX, clientY, contentRect)=>{
+        if (!deviceSize) return null;
+        const ratioX = (clientX - contentRect.left) / contentRect.width;
+        const ratioY = (clientY - contentRect.top) / contentRect.height;
+        const x = Math.max(0, Math.min(deviceSize.width - 1, Math.round(ratioX * deviceSize.width)));
+        const y = Math.max(0, Math.min(deviceSize.height - 1, Math.round(ratioY * deviceSize.height)));
+        return {
+            x,
+            y
+        };
+    }, [
+        deviceSize
+    ]);
+    const handlePointerDown = (0, external_react_namespaceObject.useCallback)((event)=>{
+        if (!enabled || !deviceSize || !overlayRef.current) return;
+        if (0 !== event.button && 'mouse' === event.pointerType) return;
+        const panelRect = overlayRef.current.getBoundingClientRect();
+        const contentRect = inscribedContentRect(panelRect, deviceSize);
+        if (event.clientX < contentRect.left || event.clientX > contentRect.left + contentRect.width || event.clientY < contentRect.top || event.clientY > contentRect.top + contentRect.height) {
+            keyboardArmedRef.current = false;
+            return;
+        }
+        positionKeyboardSink(event.clientX, event.clientY);
+        focusKeyboardSink();
+        try {
+            overlayRef.current.setPointerCapture(event.pointerId);
+        } catch (unused) {}
+        activePointer.current = {
+            startX: event.clientX,
+            startY: event.clientY,
+            startTime: performance.now(),
+            contentRect
+        };
+        event.preventDefault();
+    }, [
+        enabled,
+        deviceSize,
+        focusKeyboardSink,
+        positionKeyboardSink
+    ]);
+    const finishPointer = (0, external_react_namespaceObject.useCallback)((event, cancelled)=>{
+        const active = activePointer.current;
+        activePointer.current = null;
+        if (!active) return;
+        try {
+            var _overlayRef_current;
+            null == (_overlayRef_current = overlayRef.current) || _overlayRef_current.releasePointerCapture(event.pointerId);
+        } catch (unused) {}
+        if (cancelled) return;
+        const dx = event.clientX - active.startX;
+        const dy = event.clientY - active.startY;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const duration = Math.max(0, performance.now() - active.startTime);
+        const startPoint = projectToDevice(active.startX, active.startY, active.contentRect);
+        const endPoint = projectToDevice(event.clientX, event.clientY, active.contentRect);
+        if (!startPoint || !endPoint) return;
+        lastKeyboardPointRef.current = endPoint;
+        if (distance <= tapMaxDistance && duration <= tapMaxDurationMs) null == onTap || onTap(startPoint);
+        else null == onSwipe || onSwipe(startPoint, endPoint, Math.round(duration));
+    }, [
+        onTap,
+        onSwipe,
+        projectToDevice,
+        tapMaxDistance,
+        tapMaxDurationMs
+    ]);
+    const handlePointerUp = (0, external_react_namespaceObject.useCallback)((event)=>finishPointer(event, false), [
+        finishPointer
+    ]);
+    const handlePointerCancel = (0, external_react_namespaceObject.useCallback)((event)=>finishPointer(event, true), [
+        finishPointer
+    ]);
+    const clearLocalEditableText = (0, external_react_namespaceObject.useCallback)(()=>{
+        var _keyboardSinkRef_current;
+        if (null == (_keyboardSinkRef_current = keyboardSinkRef.current) ? void 0 : _keyboardSinkRef_current.value) keyboardSinkRef.current.value = '';
+    }, []);
+    const handleKeyboardEvent = (0, external_react_namespaceObject.useCallback)((event)=>{
+        if (!keyboardEnabled || !keyboardArmedRef.current) return;
+        if (isHostCopyShortcut(event) && hasHostSelectionOutsideOverlay(overlayRef.current)) {
+            keyboardArmedRef.current = false;
+            return;
+        }
+        if (composingRef.current || event.isComposing) return;
+        if (isHostReservedShortcut(event)) return;
+        if (keyboardControlKeys.has(event.key) || event.altKey || event.ctrlKey || event.metaKey) {
+            var _lastKeyboardPointRef_current;
+            const keyName = keyNameForKeyboardEvent(event);
+            if (!keyName) return;
+            event.preventDefault();
+            event.stopPropagation();
+            null == onKeyboardPress || onKeyboardPress(keyName, null != (_lastKeyboardPointRef_current = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current : void 0);
+        }
+    }, [
+        keyboardEnabled,
+        onKeyboardPress
+    ]);
+    const handlePaste = (0, external_react_namespaceObject.useCallback)((event)=>{
+        var _lastKeyboardPointRef_current;
+        if (!keyboardEnabled || !keyboardArmedRef.current) return;
+        const text = event.clipboardData.getData('text');
+        if (!text) return;
+        event.preventDefault();
+        event.stopPropagation();
+        null == onTextInput || onTextInput(text, null != (_lastKeyboardPointRef_current = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current : void 0);
+    }, [
+        keyboardEnabled,
+        onTextInput
+    ]);
+    const handleEditableInput = (0, external_react_namespaceObject.useCallback)((event)=>{
+        var _lastKeyboardPointRef_current;
+        var _keyboardSinkRef_current;
+        if (!keyboardEnabled || !keyboardArmedRef.current) {
+            if (!composingRef.current) clearLocalEditableText();
+            return;
+        }
+        if (composingRef.current) return;
+        const nativeEvent = event.nativeEvent;
+        if ('insertLineBreak' === nativeEvent.inputType) {
+            var _lastKeyboardPointRef_current1;
+            clearLocalEditableText();
+            event.preventDefault();
+            event.stopPropagation();
+            null == onKeyboardPress || onKeyboardPress('Enter', null != (_lastKeyboardPointRef_current1 = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current1 : void 0);
+            return;
+        }
+        if ('deleteContentBackward' === nativeEvent.inputType) {
+            var _lastKeyboardPointRef_current2;
+            clearLocalEditableText();
+            event.preventDefault();
+            event.stopPropagation();
+            null == onKeyboardPress || onKeyboardPress('Backspace', null != (_lastKeyboardPointRef_current2 = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current2 : void 0);
+            return;
+        }
+        if ('deleteContentForward' === nativeEvent.inputType) {
+            var _lastKeyboardPointRef_current3;
+            clearLocalEditableText();
+            event.preventDefault();
+            event.stopPropagation();
+            null == onKeyboardPress || onKeyboardPress('Delete', null != (_lastKeyboardPointRef_current3 = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current3 : void 0);
+            return;
+        }
+        const text = nativeEvent.data || (null == (_keyboardSinkRef_current = keyboardSinkRef.current) ? void 0 : _keyboardSinkRef_current.value) || '';
+        clearLocalEditableText();
+        if (!text) return;
+        event.preventDefault();
+        event.stopPropagation();
+        null == onTextInput || onTextInput(text, null != (_lastKeyboardPointRef_current = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current : void 0);
+    }, [
+        clearLocalEditableText,
+        keyboardEnabled,
+        onKeyboardPress,
+        onTextInput
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled) {
+            activePointer.current = null;
+            composingRef.current = false;
+            keyboardArmedRef.current = false;
+            lastKeyboardPointRef.current = null;
+        }
+    }, [
+        enabled
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled || !keyboardEnabled) {
+            keyboardArmedRef.current = false;
+            return;
+        }
+        const handleDocumentPointerDown = (event)=>{
+            const overlay = overlayRef.current;
+            if (overlay && event.target instanceof Node && overlay.contains(event.target)) return;
+            keyboardArmedRef.current = false;
+        };
+        window.addEventListener('keydown', handleKeyboardEvent, true);
+        window.addEventListener('pointerdown', handleDocumentPointerDown, true);
+        return ()=>{
+            window.removeEventListener('keydown', handleKeyboardEvent, true);
+            window.removeEventListener('pointerdown', handleDocumentPointerDown, true);
+        };
+    }, [
+        enabled,
+        handleKeyboardEvent,
+        keyboardEnabled
+    ]);
+    if (!enabled || !deviceSize) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: overlayRef,
+        onPointerDown: handlePointerDown,
+        onPointerUp: handlePointerUp,
+        onPointerCancel: handlePointerCancel,
+        onContextMenu: (e)=>e.preventDefault(),
+        "data-midscene-device-interaction-layer": "true",
+        style: _object_spread({
+            position: 'absolute',
+            inset: 0,
+            zIndex: 5,
+            cursor: keyboardEnabled ? 'default' : 'crosshair',
+            outline: 'none',
+            color: 'transparent',
+            caretColor: 'transparent',
+            touchAction: 'none',
+            userSelect: 'none'
+        }, style),
+        children: keyboardEnabled ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("textarea", {
+            ref: keyboardSinkRef,
+            "data-midscene-keyboard-sink": "true",
+            tabIndex: -1,
+            onPaste: handlePaste,
+            onCompositionStart: ()=>{
+                keyboardArmedRef.current = true;
+                composingRef.current = true;
+            },
+            onCompositionEnd: (event)=>{
+                var _keyboardSinkRef_current;
+                if (!keyboardEnabled || !keyboardArmedRef.current) return;
+                composingRef.current = false;
+                const text = event.data || (null == (_keyboardSinkRef_current = keyboardSinkRef.current) ? void 0 : _keyboardSinkRef_current.value) || '';
+                clearLocalEditableText();
+                if (text) {
+                    var _lastKeyboardPointRef_current;
+                    null == onTextInput || onTextInput(text, null != (_lastKeyboardPointRef_current = lastKeyboardPointRef.current) ? _lastKeyboardPointRef_current : void 0);
+                }
+            },
+            onInput: handleEditableInput,
+            style: {
+                position: 'absolute',
+                left: 0,
+                top: 0,
+                width: 32,
+                height: 24,
+                opacity: 0.01,
+                pointerEvents: 'none',
+                resize: 'none',
+                border: 0,
+                padding: 0,
+                margin: 0,
+                outline: 'none',
+                background: 'transparent',
+                color: 'transparent',
+                caretColor: 'transparent',
+                fontSize: 16,
+                lineHeight: '20px',
+                transform: 'translate(-50%, -50%)'
+            }
+        }) : null
+    });
+}
+exports.DeviceInteractionLayer = __webpack_exports__.DeviceInteractionLayer;
+exports.inscribedContentRect = __webpack_exports__.inscribedContentRect;
+exports.keyNameForKeyboardEvent = __webpack_exports__.keyNameForKeyboardEvent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DeviceInteractionLayer",
+    "inscribedContentRect",
+    "keyNameForKeyboardEvent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});