@modern-js/bff-core 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/router/index.js

@@ -1,298 +1,278 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var router_exports = {};
-__export(router_exports, {
-  ApiRouter: () => ApiRouter
-});
-module.exports = __toCommonJS(router_exports);
-var import_path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_reflect_metadata = require("reflect-metadata");
-var import_types = require("../types");
-var import_utils2 = require("../utils");
-var import_constants = require("./constants");
-var import_utils3 = require("./utils");
-__reExport(router_exports, require("./types"), module.exports);
-__reExport(router_exports, require("./constants"), module.exports);
-class ApiRouter {
-  isExistLambda() {
-    return this.existLambdaDir;
-  }
-  getApiMode() {
-    return this.apiMode;
-  }
-  getLambdaDir() {
-    return this.lambdaDir;
-  }
-  isApiFile(filename) {
-    if (this.apiFiles.includes(filename)) {
-      return true;
-    }
-    return false;
-  }
-  async getSingleModuleHandlers(filename) {
-    const moduleInfo = await this.getModuleInfo(filename);
-    if (moduleInfo) {
-      return this.getModuleHandlerInfos(moduleInfo);
+var __webpack_modules__ = {
+    "../types" (module) {
+        module.exports = require("../types.js");
+    },
+    "../utils" (module) {
+        module.exports = require("../utils/index.js");
+    },
+    "./constants" (module) {
+        module.exports = require("./constants.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "./utils?198b" (module) {
+        module.exports = require("./utils.js");
+    },
+    "@modern-js/utils" (module) {
+        module.exports = require("@modern-js/utils");
+    },
+    path (module) {
+        module.exports = require("path");
+    },
+    "reflect-metadata" (module) {
+        module.exports = require("reflect-metadata");
     }
-    return null;
-  }
-  getHandlerInfo(filename, originFuncName, handler) {
-    const httpMethod = this.getHttpMethod(originFuncName, handler);
-    const routeName = this.getRouteName(filename, handler);
-    const action = this.getAction(handler);
-    const responseObj = {
-      handler,
-      name: originFuncName,
-      httpMethod,
-      routeName,
-      filename,
-      routePath: this.getRoutePath(this.prefix, routeName)
+};
+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: {}
     };
-    if (action) {
-      responseObj.action = action;
-    }
-    if (httpMethod && routeName) {
-      return responseObj;
-    }
-    return null;
-  }
-  // TODO: 性能提升，开发环境，判断下 lambda 目录修改时间
-  getSafeRoutePath(filename, handler) {
-    this.loadApiFiles();
-    this.validateValidApifile(filename);
-    return this.getRouteName(filename, handler);
-  }
-  getRouteName(filename, handler) {
-    if (handler) {
-      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
-      if (trigger && trigger.type === import_types.TriggerType.Http) {
-        if (!trigger.path) {
-          throw new Error(`The http trigger ${trigger.name} needs to specify a path`);
-        }
-        return trigger.path;
-      }
-    }
-    let routePath = (0, import_utils3.getPathFromFilename)(this.lambdaDir, filename);
-    if (this.httpMethodDecider === "inputParams") {
-      if (routePath.endsWith("/")) {
-        routePath += `${handler === null || handler === void 0 ? void 0 : handler.name}`;
-      } else {
-        routePath += `/${handler === null || handler === void 0 ? void 0 : handler.name}`;
-      }
-    }
-    return routePath;
-  }
-  getHttpMethod(originHandlerName, handler) {
-    if (handler) {
-      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
-      if (trigger && import_types.httpMethods.includes(trigger.method)) {
-        return trigger.method;
-      }
-    }
-    if (this.httpMethodDecider === "functionName") {
-      const upperName = originHandlerName.toUpperCase();
-      switch (upperName) {
-        case "GET":
-          return import_types.HttpMethod.Get;
-        case "POST":
-          return import_types.HttpMethod.Post;
-        case "PUT":
-          return import_types.HttpMethod.Put;
-        case "DELETE":
-        case "DEL":
-          return import_types.HttpMethod.Delete;
-        case "CONNECT":
-          return import_types.HttpMethod.Connect;
-        case "TRACE":
-          return import_types.HttpMethod.Trace;
-        case "PATCH":
-          return import_types.HttpMethod.Patch;
-        case "OPTIONS":
-          return import_types.HttpMethod.Options;
-        case "DEFAULT": {
-          return import_types.HttpMethod.Get;
-        }
-        default:
-          if (process.env.NODE_ENV !== "test") {
-            import_utils.logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
-          }
-          return null;
-      }
-    } else {
-      if (!handler) {
-        return null;
-      }
-      if (typeof handler === "function" && handler.length > 0) {
-        return import_types.HttpMethod.Post;
-      }
-      return import_types.HttpMethod.Get;
-    }
-  }
-  getAction(handler) {
-    if (handler) {
-      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
-      if (trigger === null || trigger === void 0 ? void 0 : trigger.action) {
-        return trigger.action;
-      }
-    }
-  }
-  loadApiFiles() {
-    if (!this.existLambdaDir) {
-      return [];
-    }
-    const apiFiles = this.apiFiles = (0, import_utils3.getFiles)(this.lambdaDir, import_constants.API_FILE_RULES);
-    return apiFiles;
-  }
-  getApiFiles() {
-    if (!this.existLambdaDir) {
-      return [];
-    }
-    if (this.apiFiles.length > 0) {
-      return this.apiFiles;
-    }
-    return this.loadApiFiles();
-  }
-  async getApiHandlers() {
-    const filenames = this.getApiFiles();
-    const moduleInfos = await this.getModuleInfos(filenames);
-    const apiHandlers = this.getHandlerInfos(moduleInfos);
-    (0, import_utils2.debug)("apiHandlers", apiHandlers.length, apiHandlers);
-    return apiHandlers;
-  }
-  /**
-  * 如果用户未传入或传入空串，默认为 /api
-  * 如果传入 /，则 prefix 为 /
-  */
-  initPrefix(prefix) {
-    if (prefix === "/") {
-      return "";
-    }
-    return prefix || "/api";
-  }
-  validateAbsolute(filename, paramsName) {
-    if (typeof filename === "string" && !import_path.default.isAbsolute(filename)) {
-      throw new Error(`The ${paramsName} ${filename} is not a abolute path`);
-    }
-  }
-  async getModuleInfos(filenames) {
-    return Promise.all(filenames.map((filename) => this.getModuleInfo(filename)).filter((moduleInfo) => Boolean(moduleInfo)));
-  }
-  async getModuleInfo(filename) {
-    try {
-      const module2 = await (0, import_utils3.requireHandlerModule)(filename);
-      return {
-        filename,
-        module: module2
-      };
-    } catch (err) {
-      if (process.env.NODE_ENV === "production") {
-        throw err;
-      } else {
-        console.error(err);
-        return null;
-      }
-    }
-  }
-  getHandlerInfos(moduleInfos) {
-    let apiHandlers = [];
-    moduleInfos.forEach((moduleInfo) => {
-      const handlerInfos = this.getModuleHandlerInfos(moduleInfo);
-      if (handlerInfos) {
-        apiHandlers = apiHandlers.concat(handlerInfos);
-      }
-    });
-    const sortedHandlers = (0, import_utils3.sortRoutes)(apiHandlers);
-    return sortedHandlers;
-  }
-  getModuleHandlerInfos(moduleInfo) {
-    const { module: module2, filename } = moduleInfo;
-    const { httpMethodDecider } = this;
-    return Object.entries(module2).filter(([, handler]) => typeof handler === "function").map(([key]) => {
-      const handler = module2[key];
-      if (httpMethodDecider === "inputParams") {
-        Object.assign(handler, {
-          [import_utils2.INPUT_PARAMS_DECIDER]: true
+    __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
         });
-      }
-      const handlerInfo = this.getHandlerInfo(filename, key, handler);
-      return handlerInfo;
-    }).filter((handlerInfo) => Boolean(handlerInfo));
-  }
-  validateValidApifile(filename) {
-    if (!this.apiFiles.includes(filename)) {
-      throw new Error(`The ${filename} is not a valid api file.`);
-    }
-  }
-  getRoutePath(prefix, routeName) {
-    const finalRouteName = routeName === "/" ? "" : routeName;
-    if (prefix === "" && finalRouteName === "") {
-      return "/";
-    }
-    return `${prefix}${finalRouteName}`;
-  }
-  constructor({ appDir, apiDir, lambdaDir, prefix, isBuild, httpMethodDecider = "functionName" }) {
-    this.apiFiles = [];
-    this.getExactApiMode = (apiDir2, lambdaDir2) => {
-      const exist = this.createExistChecker(apiDir2);
-      const existLambdaDir = lambdaDir2 && import_utils.fs.pathExistsSync(lambdaDir2) || exist(import_constants.FRAMEWORK_MODE_LAMBDA_DIR);
-      const existAppDir = exist(import_constants.FRAMEWORK_MODE_APP_DIR);
-      const existAppFile = exist("app.ts") || exist("app.js");
-      if (existLambdaDir || existAppDir || existAppFile) {
-        return import_constants.APIMode.FARMEWORK;
-      }
-      return import_constants.APIMode.FUNCTION;
+        return getter;
     };
-    this.createExistChecker = (base) => (target) => import_utils.fs.pathExistsSync(import_path.default.resolve(base, target));
-    this.getExactLambdaDir = (apiDir2, originLambdaDir) => {
-      if (this.apiMode === import_constants.APIMode.FUNCTION) {
-        return apiDir2;
-      }
-      return originLambdaDir || import_path.default.join(apiDir2, import_constants.FRAMEWORK_MODE_LAMBDA_DIR);
+})();
+(()=>{
+    __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]
+        });
     };
-    this.validateAbsolute(apiDir, "apiDir");
-    this.validateAbsolute(lambdaDir, "lambdaDir");
-    this.prefix = this.initPrefix(prefix);
-    this.appDir = appDir;
-    this.apiDir = apiDir;
-    this.httpMethodDecider = httpMethodDecider;
-    this.isBuild = isBuild;
-    this.apiMode = this.getExactApiMode(apiDir, lambdaDir);
-    this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
-    this.existLambdaDir = import_utils.fs.existsSync(this.lambdaDir);
-    (0, import_utils2.debug)(`apiDir:`, this.apiDir, `lambdaDir:`, this.lambdaDir);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ApiRouter,
-  ...require("./types"),
-  ...require("./constants")
+})();
+(()=>{
+    __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__, {
+        ApiRouter: ()=>ApiRouter
+    });
+    var path__rspack_import_0 = __webpack_require__("path");
+    var path__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_0);
+    var _modern_js_utils__rspack_import_1 = __webpack_require__("@modern-js/utils");
+    __webpack_require__("reflect-metadata");
+    var _types__rspack_import_3 = __webpack_require__("../types");
+    var _utils__rspack_import_4 = __webpack_require__("../utils");
+    var _constants__rspack_import_5 = __webpack_require__("./constants");
+    var _utils__rspack_import_6 = __webpack_require__("./utils?198b");
+    var _types__rspack_import_7 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_7)if ([
+        "ApiRouter",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _constants__rspack_import_5)if ([
+        "ApiRouter",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_constants__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    class ApiRouter {
+        isExistLambda() {
+            return this.existLambdaDir;
+        }
+        getLambdaDir() {
+            return this.lambdaDir;
+        }
+        isApiFile(filename) {
+            if (this.apiFiles.includes(filename)) return true;
+            return false;
+        }
+        async getSingleModuleHandlers(filename) {
+            const moduleInfo = await this.getModuleInfo(filename);
+            if (moduleInfo) return this.getModuleHandlerInfos(moduleInfo);
+            return null;
+        }
+        getHandlerInfo(filename, originFuncName, handler) {
+            const httpMethod = this.getHttpMethod(originFuncName, handler);
+            const routeName = this.getRouteName(filename, handler);
+            const action = this.getAction(handler);
+            const responseObj = {
+                handler,
+                name: originFuncName,
+                httpMethod,
+                routeName,
+                filename,
+                routePath: this.getRoutePath(this.prefix, routeName)
+            };
+            if (action) responseObj.action = action;
+            if (httpMethod && routeName) return responseObj;
+            return null;
+        }
+        getSafeRoutePath(filename, handler) {
+            this.loadApiFiles();
+            this.validateValidApifile(filename);
+            return this.getRouteName(filename, handler);
+        }
+        getRouteName(filename, handler) {
+            if (handler) {
+                const trigger = Reflect.getMetadata(_types__rspack_import_3.OperatorType.Trigger, handler);
+                if (trigger && trigger.type === _types__rspack_import_3.TriggerType.Http) {
+                    if (!trigger.path) throw new Error(`The http trigger ${trigger.name} needs to specify a path`);
+                    return trigger.path;
+                }
+            }
+            let routePath = (0, _utils__rspack_import_6.getPathFromFilename)(this.lambdaDir, filename);
+            if ('inputParams' === this.httpMethodDecider) if (routePath.endsWith('/')) routePath += `${handler?.name}`;
+            else routePath += `/${handler?.name}`;
+            return routePath;
+        }
+        getHttpMethod(originHandlerName, handler) {
+            if (handler) {
+                const trigger = Reflect.getMetadata(_types__rspack_import_3.OperatorType.Trigger, handler);
+                if (trigger && _types__rspack_import_3.httpMethods.includes(trigger.method)) return trigger.method;
+            }
+            if ('functionName' === this.httpMethodDecider) {
+                const upperName = originHandlerName.toUpperCase();
+                switch(upperName){
+                    case 'GET':
+                        return _types__rspack_import_3.HttpMethod.Get;
+                    case 'POST':
+                        return _types__rspack_import_3.HttpMethod.Post;
+                    case 'PUT':
+                        return _types__rspack_import_3.HttpMethod.Put;
+                    case 'DELETE':
+                    case 'DEL':
+                        return _types__rspack_import_3.HttpMethod.Delete;
+                    case 'CONNECT':
+                        return _types__rspack_import_3.HttpMethod.Connect;
+                    case 'TRACE':
+                        return _types__rspack_import_3.HttpMethod.Trace;
+                    case 'PATCH':
+                        return _types__rspack_import_3.HttpMethod.Patch;
+                    case 'OPTIONS':
+                        return _types__rspack_import_3.HttpMethod.Options;
+                    case 'DEFAULT':
+                        return _types__rspack_import_3.HttpMethod.Get;
+                    default:
+                        if ('test' !== process.env.NODE_ENV) _modern_js_utils__rspack_import_1.logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
+                        return null;
+                }
+            }
+            if (!handler) return null;
+            if ('function' == typeof handler && handler.length > 0) return _types__rspack_import_3.HttpMethod.Post;
+            return _types__rspack_import_3.HttpMethod.Get;
+        }
+        getAction(handler) {
+            if (handler) {
+                const trigger = Reflect.getMetadata(_types__rspack_import_3.OperatorType.Trigger, handler);
+                if (trigger?.action) return trigger.action;
+            }
+        }
+        loadApiFiles() {
+            if (!this.existLambdaDir) return [];
+            const apiFiles = this.apiFiles = (0, _utils__rspack_import_6.getFiles)(this.lambdaDir, _constants__rspack_import_5.API_FILE_RULES);
+            return apiFiles;
+        }
+        getApiFiles() {
+            if (!this.existLambdaDir) return [];
+            if (this.apiFiles.length > 0) return this.apiFiles;
+            return this.loadApiFiles();
+        }
+        async getApiHandlers() {
+            const filenames = this.getApiFiles();
+            const moduleInfos = await this.getModuleInfos(filenames);
+            const apiHandlers = this.getHandlerInfos(moduleInfos);
+            (0, _utils__rspack_import_4.debug)('apiHandlers', apiHandlers.length, apiHandlers);
+            return apiHandlers;
+        }
+        initPrefix(prefix) {
+            if ('/' === prefix) return '';
+            return prefix || '/api';
+        }
+        validateAbsolute(filename, paramsName) {
+            if ('string' == typeof filename && !path__rspack_import_0_default().isAbsolute(filename)) throw new Error(`The ${paramsName} ${filename} is not a abolute path`);
+        }
+        async getModuleInfos(filenames) {
+            return Promise.all(filenames.map((filename)=>this.getModuleInfo(filename)).filter((moduleInfo)=>Boolean(moduleInfo)));
+        }
+        async getModuleInfo(filename) {
+            try {
+                const module = await (0, _utils__rspack_import_6.requireHandlerModule)(filename);
+                return {
+                    filename,
+                    module
+                };
+            } catch (err) {
+                if ('production' === process.env.NODE_ENV) throw err;
+                console.error(err);
+                return null;
+            }
+        }
+        getHandlerInfos(moduleInfos) {
+            let apiHandlers = [];
+            moduleInfos.forEach((moduleInfo)=>{
+                const handlerInfos = this.getModuleHandlerInfos(moduleInfo);
+                if (handlerInfos) apiHandlers = apiHandlers.concat(handlerInfos);
+            });
+            const sortedHandlers = (0, _utils__rspack_import_6.sortRoutes)(apiHandlers);
+            return sortedHandlers;
+        }
+        getModuleHandlerInfos(moduleInfo) {
+            const { module, filename } = moduleInfo;
+            const { httpMethodDecider } = this;
+            return Object.entries(module).filter(([, handler])=>'function' == typeof handler).map(([key])=>{
+                const handler = module[key];
+                if ('inputParams' === httpMethodDecider) Object.assign(handler, {
+                    [_utils__rspack_import_4.INPUT_PARAMS_DECIDER]: true
+                });
+                const handlerInfo = this.getHandlerInfo(filename, key, handler);
+                return handlerInfo;
+            }).filter((handlerInfo)=>Boolean(handlerInfo));
+        }
+        validateValidApifile(filename) {
+            if (!this.apiFiles.includes(filename)) throw new Error(`The ${filename} is not a valid api file.`);
+        }
+        getRoutePath(prefix, routeName) {
+            const finalRouteName = '/' === routeName ? '' : routeName;
+            if ('' === prefix && '' === finalRouteName) return '/';
+            return `${prefix}${finalRouteName}`;
+        }
+        constructor({ appDir, apiDir, lambdaDir, prefix, isBuild, httpMethodDecider = 'functionName' }){
+            this.apiFiles = [];
+            this.getExactLambdaDir = (apiDir, originLambdaDir)=>originLambdaDir || path__rspack_import_0_default().join(apiDir, _constants__rspack_import_5.FRAMEWORK_MODE_LAMBDA_DIR);
+            this.validateAbsolute(apiDir, 'apiDir');
+            this.validateAbsolute(lambdaDir, 'lambdaDir');
+            this.prefix = this.initPrefix(prefix);
+            this.appDir = appDir;
+            this.apiDir = apiDir;
+            this.httpMethodDecider = httpMethodDecider;
+            this.isBuild = isBuild;
+            this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
+            this.existLambdaDir = _modern_js_utils__rspack_import_1.fs.existsSync(this.lambdaDir);
+            (0, _utils__rspack_import_4.debug)("apiDir:", this.apiDir, "lambdaDir:", this.lambdaDir);
+        }
+    }
+})();
+exports.ApiRouter = __webpack_exports__.ApiRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ApiRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/router/types.js

@@ -1,16 +1,18 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});