@bleedingdev/modern-js-plugin-data-loader 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/cli/createRequest.js

@@ -0,0 +1,133 @@
+"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__, {
+    createActionRequest: ()=>createActionRequest,
+    createRequest: ()=>createRequest,
+    getRequestUrl: ()=>getRequestUrl
+});
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const external_path_to_regexp_namespaceObject = require("path-to-regexp");
+const constants_js_namespaceObject = require("../common/constants.js");
+const external_data_js_namespaceObject = require("./data.js");
+const getRequestUrl = ({ params, request, routeId })=>{
+    const url = new URL(request.url);
+    const toPath = (0, external_path_to_regexp_namespaceObject.compile)(url.pathname, {
+        encode: encodeURIComponent
+    });
+    const newPathName = toPath(params);
+    url.pathname = newPathName;
+    url.searchParams.append(constants_js_namespaceObject.LOADER_ID_PARAM, routeId);
+    url.searchParams.append(constants_js_namespaceObject.DIRECT_PARAM, 'true');
+    return url;
+};
+const handleRedirectResponse = (res)=>{
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    if (location) throw (0, router_namespaceObject.redirect)(location);
+    return res;
+};
+const isDeferredResponse = (res)=>res.headers.get('Content-Type')?.match(constants_js_namespaceObject.CONTENT_TYPE_DEFERRED) && res.body;
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+const isErrorResponse = (res)=>null != res.headers.get('X-Modernjs-Error');
+function isOtherErrorResponse(res) {
+    return res.status >= 400 && null == res.headers.get('X-Modernjs-Error') && null == res.headers.get('X-Modernjs-Catch') && null == res.headers.get('X-Modernjs-Response');
+}
+const isCatchResponse = (res)=>null != res.headers.get('X-Modernjs-Catch');
+const handleErrorResponse = async (res)=>{
+    const data = await res.json();
+    const error = new Error(data.message);
+    error.stack = data.stack;
+    throw error;
+};
+const handleNetworkErrorResponse = async (res)=>{
+    const text = await res.text();
+    const error = new Error(text);
+    error.stack = void 0;
+    throw error;
+};
+const createRequest = (routeId, method = 'get')=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        let res;
+        res = await fetch(url, {
+            method,
+            signal: request.signal
+        }).catch((error)=>{
+            throw error;
+        });
+        if (isRedirectResponse(res)) return handleRedirectResponse(res);
+        if (isErrorResponse(res)) return await handleErrorResponse(res);
+        if (isCatchResponse(res)) throw res;
+        if (isDeferredResponse(res)) {
+            const deferredData = await (0, external_data_js_namespaceObject.parseDeferredReadableStream)(res.body);
+            return deferredData.data;
+        }
+        if (isOtherErrorResponse(res)) return await handleNetworkErrorResponse(res);
+        return res;
+    };
+const createActionRequest = (routeId)=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        const init = {
+            signal: request.signal
+        };
+        if ('GET' !== request.method) {
+            init.method = request.method;
+            const contentType = request.headers.get('Content-Type');
+            if (contentType && /\bapplication\/json\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = JSON.stringify(await request.json());
+            } else if (contentType && /\btext\/plain\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = await request.text();
+            } else if (contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)) init.body = new URLSearchParams(await request.text());
+            else init.body = await request.formData();
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) throw res;
+        return res;
+    };
+exports.createActionRequest = __webpack_exports__.createActionRequest;
+exports.createRequest = __webpack_exports__.createRequest;
+exports.getRequestUrl = __webpack_exports__.getRequestUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createActionRequest",
+    "createRequest",
+    "getRequestUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/data.js

@@ -0,0 +1,145 @@
+"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__, {
+    parseDeferredReadableStream: ()=>parseDeferredReadableStream
+});
+const browser_namespaceObject = require("@modern-js/runtime-utils/browser");
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+async function parseDeferredReadableStream(stream) {
+    if (!stream) throw new Error('parseDeferredReadableStream requires stream argument');
+    let deferredData;
+    const deferredResolvers = {};
+    try {
+        const sectionReader = readStreamSections(stream);
+        const initialSectionResult = await sectionReader.next();
+        const initialSection = initialSectionResult.value;
+        if (!initialSection) throw new Error('no critical data');
+        const criticalData = JSON.parse(initialSection);
+        if ('object' == typeof criticalData && null !== criticalData) {
+            for (const [eventKey, value] of Object.entries(criticalData))if ('string' == typeof value && value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
+                deferredData = deferredData || {};
+                deferredData[eventKey] = new Promise((resolve, reject)=>{
+                    deferredResolvers[eventKey] = {
+                        resolve: (value)=>{
+                            resolve(value);
+                            delete deferredResolvers[eventKey];
+                        },
+                        reject: (error)=>{
+                            reject(error);
+                            delete deferredResolvers[eventKey];
+                        }
+                    };
+                });
+            }
+        }
+        (async ()=>{
+            try {
+                for await (const section of sectionReader){
+                    const [event, ...sectionDataStrings] = section.split(':');
+                    const sectionDataString = sectionDataStrings.join(':');
+                    const data = JSON.parse(sectionDataString);
+                    if ('data' === event) {
+                        for (const [key, value] of Object.entries(data))if (deferredResolvers[key]) deferredResolvers[key].resolve(value);
+                    } else if ('error' === event) for (const [key, value] of Object.entries(data)){
+                        const err = new Error(value.message);
+                        err.stack = value.stack;
+                        if (deferredResolvers[key]) deferredResolvers[key].reject(err);
+                    }
+                }
+                for (const [key, resolver] of Object.entries(deferredResolvers))resolver.reject(new browser_namespaceObject.AbortedDeferredError(`Deferred ${key} will never resolved`));
+            } catch (error) {
+                for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+            }
+        })();
+        return new browser_namespaceObject.DeferredData({
+            ...criticalData,
+            ...deferredData
+        });
+    } catch (error) {
+        for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+        throw error;
+    }
+}
+async function* readStreamSections(stream) {
+    const reader = stream.getReader();
+    let buffer = [];
+    let sections = [];
+    let closed = false;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const readStreamSection = async ()=>{
+        if (sections.length > 0) return sections.shift();
+        while(!closed && 0 === sections.length){
+            const chunk = await reader.read();
+            if (chunk.done) {
+                closed = true;
+                break;
+            }
+            buffer.push(chunk.value);
+            try {
+                const bufferedString = decoder.decode(mergeArrays(...buffer));
+                const splitSections = bufferedString.split('\n\n');
+                if (splitSections.length >= 2) {
+                    sections.push(...splitSections.slice(0, -1));
+                    buffer = [
+                        encoder.encode(splitSections.slice(-1).join('\n\n'))
+                    ];
+                }
+                if (sections.length > 0) break;
+            } catch  {
+                continue;
+            }
+        }
+        if (sections.length > 0) return sections.shift();
+        if (buffer.length > 0) {
+            const bufferedString = decoder.decode(mergeArrays(...buffer));
+            sections = bufferedString.split('\n\n').filter((s)=>s);
+            buffer = [];
+        }
+        return sections.shift();
+    };
+    let section = await readStreamSection();
+    while(section){
+        yield section;
+        section = await readStreamSection();
+    }
+}
+function mergeArrays(...arrays) {
+    const out = new Uint8Array(arrays.reduce((total, arr)=>total + arr.length, 0));
+    let offset = 0;
+    for (const arr of arrays){
+        out.set(arr, offset);
+        offset += arr.length;
+    }
+    return out;
+}
+exports.parseDeferredReadableStream = __webpack_exports__.parseDeferredReadableStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseDeferredReadableStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/generateClient.js

@@ -0,0 +1,66 @@
+"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__, {
+    generateClient: ()=>generateClient
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const generateClient = ({ inline, action, routeId })=>{
+    let requestCode = "";
+    const requestCreatorPath = external_path_default().join(__dirname, './createRequest').replace('/cjs/cli/', '/esm/cli/').replace(/\\/g, '/');
+    const importCode = `
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
+  `;
+    requestCode = inline ? action ? `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    ` : `
+      export const loader = createRequest('${routeId}');
+    ` : `
+    export default createRequest('${routeId}');
+  `;
+    const generatedCode = `
+    ${importCode}
+    ${requestCode}
+  `;
+    return generatedCode;
+};
+exports.generateClient = __webpack_exports__.generateClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/loader.js

@@ -0,0 +1,68 @@
+"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__, {
+    default: ()=>loader
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_util_namespaceObject = require("util");
+const external_generateClient_js_namespaceObject = require("./generateClient.js");
+async function loader(source) {
+    this.cacheable();
+    const target = this._compiler?.options.target;
+    const shouldSkip = (compileTarget)=>target === compileTarget || Array.isArray(target) && target.includes(compileTarget);
+    if (shouldSkip('node') || shouldSkip('webworker') || shouldSkip('async-node')) return source;
+    const { resourceQuery } = this;
+    const options = resourceQuery.slice(1).split('&').reduce((pre, cur)=>{
+        const [key, value] = cur.split('=');
+        if (key && value) pre[key] = 'true' === value ? true : 'false' === value ? false : value;
+        return pre;
+    }, {});
+    if (!options.loaderId || options.retain) return source;
+    if (options.clientData) {
+        const readFile = (0, external_util_namespaceObject.promisify)(this.fs.readFile);
+        try {
+            const clientDataPath = this.resourcePath.includes('.loader.') ? this.resourcePath.replace('.loader.', '.data.client.') : this.resourcePath.replace('.data.', '.data.client.');
+            this.addDependency(clientDataPath);
+            const clientDataContent = await readFile(clientDataPath);
+            return clientDataContent;
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) utils_namespaceObject.logger.error(`Failed to read the clientData file ${options.clientData}`);
+        }
+    }
+    const code = (0, external_generateClient_js_namespaceObject.generateClient)({
+        inline: options.inline,
+        action: options.action,
+        routeId: options.routeId
+    });
+    return code;
+}
+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/common/constants.js

@@ -0,0 +1,44 @@
+"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__, {
+    CONTENT_TYPE_DEFERRED: ()=>CONTENT_TYPE_DEFERRED,
+    DIRECT_PARAM: ()=>DIRECT_PARAM,
+    LOADER_ID_PARAM: ()=>LOADER_ID_PARAM
+});
+const LOADER_ID_PARAM = '__loader';
+const DIRECT_PARAM = '__ssrDirect';
+const CONTENT_TYPE_DEFERRED = 'text/modernjs-deferred';
+exports.CONTENT_TYPE_DEFERRED = __webpack_exports__.CONTENT_TYPE_DEFERRED;
+exports.DIRECT_PARAM = __webpack_exports__.DIRECT_PARAM;
+exports.LOADER_ID_PARAM = __webpack_exports__.LOADER_ID_PARAM;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CONTENT_TYPE_DEFERRED",
+    "DIRECT_PARAM",
+    "LOADER_ID_PARAM"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/errors.js

@@ -0,0 +1,98 @@
+"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__, {
+    errorResponseToJson: ()=>errorResponseToJson,
+    sanitizeError: ()=>sanitizeError,
+    sanitizeErrors: ()=>sanitizeErrors,
+    serializeError: ()=>serializeError,
+    serializeErrors: ()=>serializeErrors
+});
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+function sanitizeError(error) {
+    if (error instanceof Error && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV) {
+        const sanitized = new Error(error.message || 'Unexpected Server Error');
+        sanitized.stack = void 0;
+        return sanitized;
+    }
+    return error;
+}
+function sanitizeErrors(errors) {
+    return Object.entries(errors).reduce((acc, [routeId, error])=>Object.assign(acc, {
+            [routeId]: sanitizeError(error)
+        }), {});
+}
+function serializeError(error) {
+    const sanitized = sanitizeError(error);
+    return {
+        message: sanitized.message,
+        stack: sanitized.stack
+    };
+}
+function serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if ((0, router_namespaceObject.isRouteErrorResponse)(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) {
+        const sanitized = sanitizeError(val);
+        serialized[key] = {
+            message: sanitized.message,
+            stack: sanitized.stack,
+            __type: 'Error',
+            ...'Error' !== sanitized.name ? {
+                __subType: sanitized.name
+            } : {}
+        };
+    } else serialized[key] = val;
+    return serialized;
+}
+function errorResponseToJson(errorResponse) {
+    return Response.json(serializeError(errorResponse.error || new Error('Unexpected Server Error')), {
+        status: errorResponse.status,
+        statusText: errorResponse.statusText,
+        headers: {
+            'X-Modernjs-Error': 'yes'
+        }
+    });
+}
+exports.errorResponseToJson = __webpack_exports__.errorResponseToJson;
+exports.sanitizeError = __webpack_exports__.sanitizeError;
+exports.sanitizeErrors = __webpack_exports__.sanitizeErrors;
+exports.serializeError = __webpack_exports__.serializeError;
+exports.serializeErrors = __webpack_exports__.serializeErrors;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "errorResponseToJson",
+    "sanitizeError",
+    "sanitizeErrors",
+    "serializeError",
+    "serializeErrors"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});