@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/cjs/cli.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_modules__ = {
+    "./cli/index" (module) {
+        module.exports = require("./cli/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        default: ()=>_cli_index__rspack_import_0_default.a
+    });
+    var _cli_index__rspack_import_0 = __webpack_require__("./cli/index");
+    var _cli_index__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(_cli_index__rspack_import_0);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _cli_index__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_cli_index__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/DefaultNotFound.js

@@ -0,0 +1,47 @@
+"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__, {
+    DefaultNotFound: ()=>DefaultNotFound
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const DefaultNotFound = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        style: {
+            margin: '150px auto',
+            textAlign: 'center',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center'
+        },
+        children: "404"
+    });
+exports.DefaultNotFound = __webpack_exports__.DefaultNotFound;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DefaultNotFound"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/basepathRewrite.js

@@ -0,0 +1,62 @@
+"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__, {
+    createModernBasepathRewrite: ()=>createModernBasepathRewrite
+});
+function normalizeBasepath(basepath) {
+    if (!basepath) return '/';
+    let normalized = basepath.startsWith('/') ? basepath : `/${basepath}`;
+    if (normalized.length > 1 && normalized.endsWith('/')) normalized = normalized.slice(0, -1);
+    return normalized || '/';
+}
+function createModernBasepathRewrite(basepath, caseSensitive = false) {
+    const normalizedBasepath = normalizeBasepath(basepath);
+    if ('/' === normalizedBasepath) return;
+    const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
+    const checkBasepath = caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
+    const checkBasepathWithSlash = caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
+    return {
+        input: ({ url })=>{
+            const pathname = caseSensitive ? url.pathname : url.pathname.toLowerCase();
+            if (pathname === checkBasepath) url.pathname = '/';
+            else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length) || '/';
+            return url;
+        },
+        output: ({ url })=>{
+            const pathname = url.pathname || '/';
+            if ('/' === pathname) url.pathname = normalizedBasepath;
+            else url.pathname = `${normalizedBasepath}${pathname.startsWith('/') ? '' : '/'}${pathname}`;
+            return url;
+        }
+    };
+}
+exports.createModernBasepathRewrite = __webpack_exports__.createModernBasepathRewrite;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModernBasepathRewrite"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/dataMutation.js

@@ -0,0 +1,345 @@
+"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__, {
+    Form: ()=>Form,
+    RouteActionResponseError: ()=>RouteActionResponseError,
+    useFetcher: ()=>useFetcher
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_react_namespaceObject = require("react");
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function formDataToUrlSearchParams(formData) {
+    const searchParams = new URLSearchParams();
+    formData.forEach((value, key)=>{
+        if ('string' == typeof value) searchParams.append(key, value);
+    });
+    return searchParams;
+}
+function formDataToTextPlain(formData) {
+    return Array.from(formData.entries()).map(([key, value])=>`${key}=${String(value)}`).join('\n');
+}
+function toFormData(target) {
+    if (target instanceof HTMLFormElement) return new FormData(target);
+    if (target instanceof FormData) return target;
+    if (target instanceof URLSearchParams) {
+        const formData = new FormData();
+        target.forEach((value, key)=>{
+            formData.append(key, value);
+        });
+        return formData;
+    }
+    const formData = new FormData();
+    Object.entries(target).forEach(([key, value])=>{
+        if (null == value) return;
+        formData.append(key, String(value));
+    });
+    return formData;
+}
+function getSubmitter(event) {
+    const nativeEvent = event.nativeEvent;
+    const submitter = nativeEvent?.submitter;
+    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
+    return null;
+}
+function createFormDataFromSubmit({ form, submitter }) {
+    if (submitter) try {
+        return new FormData(form, submitter);
+    } catch  {}
+    return new FormData(form);
+}
+function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType }) {
+    const resolvedAction = submitter?.getAttribute('formaction') || action || form.getAttribute('action') || '.';
+    const resolvedMethod = (submitter?.getAttribute('formmethod') || method || form.getAttribute('method') || 'get').toLowerCase();
+    const resolvedEncType = submitter?.getAttribute('formenctype') || encType || form.getAttribute('enctype') || 'application/x-www-form-urlencoded';
+    return {
+        action: resolvedAction,
+        method: resolvedMethod,
+        encType: resolvedEncType
+    };
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = formDataToUrlSearchParams(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: search ? `${resolved.href}?${search}` : resolved.href
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = formDataToUrlSearchParams(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+function Form({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest }) {
+    const router = (0, react_router_namespaceObject.useRouter)();
+    const handleSubmit = (0, external_react_namespaceObject.useCallback)(async (event)=>{
+        onSubmit?.(event);
+        if (event.defaultPrevented || reloadDocument) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const formData = createFormDataFromSubmit({
+            form: event.currentTarget,
+            submitter
+        });
+        const normalizedOptions = resolveSubmitOptionsFromForm({
+            form: event.currentTarget,
+            submitter,
+            action,
+            method,
+            encType
+        });
+        await submitRouteAction({
+            router,
+            target: formData,
+            options: normalizedOptions
+        });
+    }, [
+        action,
+        encType,
+        method,
+        onSubmit,
+        reloadDocument,
+        router
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("form", {
+        ...rest,
+        action: action,
+        method: method,
+        encType: encType,
+        onSubmit: handleSubmit
+    });
+}
+function useFetcher() {
+    const router = (0, react_router_namespaceObject.useRouter)();
+    const [state, setState] = (0, external_react_namespaceObject.useState)('idle');
+    const [data, setData] = (0, external_react_namespaceObject.useState)(void 0);
+    const [error, setError] = (0, external_react_namespaceObject.useState)(void 0);
+    const requestStatesRef = (0, external_react_namespaceObject.useRef)(new Map());
+    const requestIdRef = (0, external_react_namespaceObject.useRef)(0);
+    const syncStateFromRequests = (0, external_react_namespaceObject.useCallback)(()=>{
+        let hasSubmitting = false;
+        let hasLoading = false;
+        requestStatesRef.current.forEach((requestState)=>{
+            if ('submitting' === requestState) hasSubmitting = true;
+            else if ('loading' === requestState) hasLoading = true;
+        });
+        if (hasSubmitting) return void setState('submitting');
+        if (hasLoading) return void setState('loading');
+        setState('idle');
+    }, []);
+    const setRequestState = (0, external_react_namespaceObject.useCallback)((requestId, requestState)=>{
+        requestStatesRef.current.set(requestId, requestState);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const clearRequestState = (0, external_react_namespaceObject.useCallback)((requestId)=>{
+        requestStatesRef.current.delete(requestId);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const submit = (0, external_react_namespaceObject.useCallback)(async (target, options)=>{
+        setError(void 0);
+        const requestId = ++requestIdRef.current;
+        const normalizedMethod = (options?.method || 'post').toLowerCase();
+        const isLoaderSubmit = 'get' === normalizedMethod;
+        setRequestState(requestId, isLoaderSubmit ? 'loading' : 'submitting');
+        try {
+            const result = await submitRouteAction({
+                router,
+                target,
+                options,
+                isFetcher: true,
+                onInvalidateStart: ()=>{
+                    if (!isLoaderSubmit) setRequestState(requestId, 'loading');
+                }
+            });
+            setData(result);
+        } catch (err) {
+            setError(err);
+            throw err;
+        } finally{
+            clearRequestState(requestId);
+        }
+    }, [
+        clearRequestState,
+        router,
+        setRequestState
+    ]);
+    const FetcherForm = (0, external_react_namespaceObject.useCallback)(({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest })=>{
+        const handleSubmit = async (event)=>{
+            onSubmit?.(event);
+            if (event.defaultPrevented || reloadDocument) return;
+            event.preventDefault();
+            const submitter = getSubmitter(event);
+            const formData = createFormDataFromSubmit({
+                form: event.currentTarget,
+                submitter
+            });
+            const normalizedOptions = resolveSubmitOptionsFromForm({
+                form: event.currentTarget,
+                submitter,
+                action,
+                method,
+                encType
+            });
+            await submit(formData, normalizedOptions);
+        };
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("form", {
+            ...rest,
+            action: action,
+            method: method,
+            encType: encType,
+            onSubmit: handleSubmit
+        });
+    }, [
+        submit
+    ]);
+    return {
+        state,
+        data,
+        error,
+        Form: FetcherForm,
+        submit
+    };
+}
+exports.Form = __webpack_exports__.Form;
+exports.RouteActionResponseError = __webpack_exports__.RouteActionResponseError;
+exports.useFetcher = __webpack_exports__.useFetcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Form",
+    "RouteActionResponseError",
+    "useFetcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/hooks.js

@@ -0,0 +1,57 @@
+"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__, {
+    modifyRoutes: ()=>modifyRoutes,
+    onAfterCreateRouter: ()=>onAfterCreateRouter,
+    onAfterHydrateRouter: ()=>onAfterHydrateRouter,
+    onBeforeCreateRouter: ()=>onBeforeCreateRouter,
+    onBeforeCreateRoutes: ()=>onBeforeCreateRoutes,
+    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
+});
+const plugin_namespaceObject = require("@modern-js/plugin");
+const modifyRoutes = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeCreateRoutes = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onAfterCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onAfterHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
+exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
+exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
+exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
+exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "modifyRoutes",
+    "onAfterCreateRouter",
+    "onAfterHydrateRouter",
+    "onBeforeCreateRouter",
+    "onBeforeCreateRoutes",
+    "onBeforeHydrateRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/index.js

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_modules__ = {
+    "./dataMutation" (module) {
+        module.exports = require("./dataMutation.js");
+    },
+    "./plugin" (module) {
+        module.exports = require("./plugin.js");
+    },
+    "./prefetchLink" (module) {
+        module.exports = require("./prefetchLink.js");
+    },
+    "./rsc/client" (module) {
+        module.exports = require("./rsc/client.js");
+    },
+    "@tanstack/react-router" (module) {
+        module.exports = require("@tanstack/react-router");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        CompositeComponent: ()=>_rsc_client__rspack_import_4.CompositeComponent,
+        Form: ()=>_dataMutation__rspack_import_1.Form,
+        Link: ()=>_prefetchLink__rspack_import_3.Link,
+        NavLink: ()=>_prefetchLink__rspack_import_3.NavLink,
+        RouteActionResponseError: ()=>_dataMutation__rspack_import_1.RouteActionResponseError,
+        default: ()=>_plugin__rspack_import_2.tanstackRouterPlugin,
+        tanstackRouterPlugin: ()=>_plugin__rspack_import_2.tanstackRouterPlugin,
+        useFetcher: ()=>_dataMutation__rspack_import_1.useFetcher,
+        useMatch: ()=>_tanstack_react_router__rspack_import_0.useMatch
+    });
+    var _tanstack_react_router__rspack_import_0 = __webpack_require__("@tanstack/react-router");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _tanstack_react_router__rspack_import_0)if ([
+        "default",
+        "NavLink",
+        "useMatch",
+        "tanstackRouterPlugin",
+        "useFetcher",
+        "CompositeComponent",
+        "RouteActionResponseError",
+        "Form",
+        "Link"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_tanstack_react_router__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _dataMutation__rspack_import_1 = __webpack_require__("./dataMutation");
+    var _plugin__rspack_import_2 = __webpack_require__("./plugin");
+    var _prefetchLink__rspack_import_3 = __webpack_require__("./prefetchLink");
+    var _rsc_client__rspack_import_4 = __webpack_require__("./rsc/client");
+})();
+exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.Form = __webpack_exports__.Form;
+exports.Link = __webpack_exports__.Link;
+exports.NavLink = __webpack_exports__.NavLink;
+exports.RouteActionResponseError = __webpack_exports__.RouteActionResponseError;
+exports["default"] = __webpack_exports__["default"];
+exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
+exports.useFetcher = __webpack_exports__.useFetcher;
+exports.useMatch = __webpack_exports__.useMatch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CompositeComponent",
+    "Form",
+    "Link",
+    "NavLink",
+    "RouteActionResponseError",
+    "default",
+    "tanstackRouterPlugin",
+    "useFetcher",
+    "useMatch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});