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

package/dist/cjs/index.js

@@ -1,57 +1,172 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __webpack_modules__ = {
+    "./api" (module) {
+        module.exports = require("./api.js");
+    },
+    "./client" (module) {
+        module.exports = require("./client/index.js");
+    },
+    "./errors/http" (module) {
+        module.exports = require("./errors/http.js");
+    },
+    "./operators/http" (module) {
+        module.exports = require("./operators/http.js");
+    },
+    "./router" (module) {
+        module.exports = require("./router/index.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "./utils?637c" (module) {
+        module.exports = require("./utils/index.js");
+    }
 };
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  Api: () => import_api.Api,
-  HANDLER_WITH_META: () => import_utils.HANDLER_WITH_META,
-  HttpError: () => import_http.HttpError,
-  INPUT_PARAMS_DECIDER: () => import_utils.INPUT_PARAMS_DECIDER,
-  ValidationError: () => import_http.ValidationError,
-  createStorage: () => import_utils.createStorage,
-  getRelativeRuntimePath: () => import_utils.getRelativeRuntimePath,
-  isInputParamsDeciderHandler: () => import_utils.isInputParamsDeciderHandler,
-  isWithMetaHandler: () => import_utils.isWithMetaHandler,
-  registerPaths: () => import_utils.registerPaths
-});
-module.exports = __toCommonJS(src_exports);
-var import_api = require("./api");
-var import_http = require("./errors/http");
-__reExport(src_exports, require("./router"), module.exports);
-__reExport(src_exports, require("./types"), module.exports);
-__reExport(src_exports, require("./client"), module.exports);
-__reExport(src_exports, require("./operators/http"), module.exports);
-var import_utils = require("./utils");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Api,
-  HANDLER_WITH_META,
-  HttpError,
-  INPUT_PARAMS_DECIDER,
-  ValidationError,
-  createStorage,
-  getRelativeRuntimePath,
-  isInputParamsDeciderHandler,
-  isWithMetaHandler,
-  registerPaths,
-  ...require("./router"),
-  ...require("./types"),
-  ...require("./client"),
-  ...require("./operators/http")
+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__, {
+        Api: ()=>_api__rspack_import_0.Api,
+        HANDLER_WITH_META: ()=>_utils__rspack_import_6.HANDLER_WITH_META,
+        HttpError: ()=>_errors_http__rspack_import_1.HttpError,
+        INPUT_PARAMS_DECIDER: ()=>_utils__rspack_import_6.INPUT_PARAMS_DECIDER,
+        ValidationError: ()=>_errors_http__rspack_import_1.ValidationError,
+        createStorage: ()=>_utils__rspack_import_6.createStorage,
+        getRelativeRuntimePath: ()=>_utils__rspack_import_6.getRelativeRuntimePath,
+        isInputParamsDeciderHandler: ()=>_utils__rspack_import_6.isInputParamsDeciderHandler,
+        isWithMetaHandler: ()=>_utils__rspack_import_6.isWithMetaHandler,
+        registerPaths: ()=>_utils__rspack_import_6.registerPaths
+    });
+    var _api__rspack_import_0 = __webpack_require__("./api");
+    var _errors_http__rspack_import_1 = __webpack_require__("./errors/http");
+    var _router__rspack_import_2 = __webpack_require__("./router");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _router__rspack_import_2)if ([
+        "HttpError",
+        "registerPaths",
+        "isWithMetaHandler",
+        "createStorage",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_router__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_3 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_3)if ([
+        "HttpError",
+        "registerPaths",
+        "isWithMetaHandler",
+        "createStorage",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _client__rspack_import_4 = __webpack_require__("./client");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _client__rspack_import_4)if ([
+        "HttpError",
+        "registerPaths",
+        "isWithMetaHandler",
+        "createStorage",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_client__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _operators_http__rspack_import_5 = __webpack_require__("./operators/http");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _operators_http__rspack_import_5)if ([
+        "HttpError",
+        "registerPaths",
+        "isWithMetaHandler",
+        "createStorage",
+        "default",
+        "HANDLER_WITH_META",
+        "ValidationError",
+        "getRelativeRuntimePath",
+        "INPUT_PARAMS_DECIDER",
+        "isInputParamsDeciderHandler",
+        "Api"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_operators_http__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _utils__rspack_import_6 = __webpack_require__("./utils?637c");
+})();
+exports.Api = __webpack_exports__.Api;
+exports.HANDLER_WITH_META = __webpack_exports__.HANDLER_WITH_META;
+exports.HttpError = __webpack_exports__.HttpError;
+exports.INPUT_PARAMS_DECIDER = __webpack_exports__.INPUT_PARAMS_DECIDER;
+exports.ValidationError = __webpack_exports__.ValidationError;
+exports.createStorage = __webpack_exports__.createStorage;
+exports.getRelativeRuntimePath = __webpack_exports__.getRelativeRuntimePath;
+exports.isInputParamsDeciderHandler = __webpack_exports__.isInputParamsDeciderHandler;
+exports.isWithMetaHandler = __webpack_exports__.isWithMetaHandler;
+exports.registerPaths = __webpack_exports__.registerPaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Api",
+    "HANDLER_WITH_META",
+    "HttpError",
+    "INPUT_PARAMS_DECIDER",
+    "ValidationError",
+    "createStorage",
+    "getRelativeRuntimePath",
+    "isInputParamsDeciderHandler",
+    "isWithMetaHandler",
+    "registerPaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/operators/http.js

@@ -1,219 +1,220 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var http_exports = {};
-__export(http_exports, {
-  Connect: () => Connect,
-  Data: () => Data,
-  Delete: () => Delete,
-  Get: () => Get,
-  Head: () => Head,
-  Headers: () => Headers,
-  HttpCode: () => HttpCode,
-  Options: () => Options,
-  Params: () => Params,
-  Patch: () => Patch,
-  Post: () => Post,
-  Put: () => Put,
-  Query: () => Query,
-  Redirect: () => Redirect,
-  SetHeaders: () => SetHeaders,
-  Trace: () => Trace,
-  Upload: () => Upload,
-  createHttpOperator: () => createHttpOperator
-});
-module.exports = __toCommonJS(http_exports);
-var import_http = require("../errors/http");
-var import_types = require("../types");
-const validateInput = async (schema, input) => {
-  try {
-    return await schema.parseAsync(input);
-  } catch (error) {
-    if ("name" in error && error.name === "ZodError") {
-      throw new import_http.ValidationError(400, error.message);
-    }
-    throw error;
-  }
-};
-const createHttpOperator = (method) => {
-  return (urlPath) => {
-    return {
-      name: method,
-      metadata({ setMetadata }) {
-        setMetadata(import_types.OperatorType.Trigger, {
-          type: import_types.TriggerType.Http,
-          path: urlPath,
-          method
+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]
         });
-      }
     };
-  };
-};
-const Get = createHttpOperator(import_types.HttpMethod.Get);
-const Post = createHttpOperator(import_types.HttpMethod.Post);
-const Put = createHttpOperator(import_types.HttpMethod.Put);
-const Delete = createHttpOperator(import_types.HttpMethod.Delete);
-const Connect = createHttpOperator(import_types.HttpMethod.Connect);
-const Trace = createHttpOperator(import_types.HttpMethod.Trace);
-const Patch = createHttpOperator(import_types.HttpMethod.Patch);
-const Options = createHttpOperator(import_types.HttpMethod.Options);
-const Head = createHttpOperator(import_types.HttpMethod.Head);
-const Data = (schema) => {
-  return {
-    name: import_types.HttpMetadata.Data,
-    metadata({ setMetadata }) {
-      setMetadata(import_types.HttpMetadata.Data, schema);
-    },
-    async validate(helper, next) {
-      const { inputs: { data } } = helper;
-      helper.inputs = {
-        ...helper.inputs,
-        data: await validateInput(schema, data)
-      };
-      return next();
-    }
-  };
-};
-const Query = (schema) => {
-  return {
-    name: import_types.HttpMetadata.Query,
-    metadata({ setMetadata }) {
-      setMetadata(import_types.HttpMetadata.Query, schema);
-    },
-    async validate(helper, next) {
-      const { inputs: { query } } = helper;
-      helper.inputs = {
-        ...helper.inputs,
-        query: await validateInput(schema, query)
-      };
-      return next();
-    }
-  };
-};
-const Params = (schema) => {
-  return {
-    name: import_types.HttpMetadata.Params,
-    metadata({ setMetadata }) {
-      setMetadata(import_types.HttpMetadata.Params, schema);
-    },
-    async validate(helper, next) {
-      const { inputs: { params } } = helper;
-      helper.inputs = {
-        ...helper.inputs,
-        params: await validateInput(schema, params)
-      };
-      return next();
-    }
-  };
-};
-const Headers = (schema) => {
-  return {
-    name: import_types.HttpMetadata.Headers,
-    metadata({ setMetadata }) {
-      setMetadata(import_types.HttpMetadata.Headers, schema);
-    },
-    async validate(helper, next) {
-      const { inputs: { headers } } = helper;
-      helper.inputs = {
-        ...helper.inputs,
-        headers: await validateInput(schema, headers)
-      };
-      return next();
-    }
-  };
-};
-const setResponseMeta = (helper, type, value) => {
-  const responseMetaData = helper.getMetadata(import_types.HttpMetadata.Response) || [];
-  helper.setMetadata(import_types.HttpMetadata.Response, [
-    ...responseMetaData,
-    {
-      type,
-      value
-    }
-  ]);
-};
-const HttpCode = (statusCode) => {
-  return {
-    name: "HttpCode",
-    metadata(helper) {
-      setResponseMeta(helper, import_types.ResponseMetaType.StatusCode, statusCode);
-    }
-  };
-};
-const SetHeaders = (headers) => {
-  return {
-    name: "SetHeaders",
-    metadata(helper) {
-      setResponseMeta(helper, import_types.ResponseMetaType.Headers, headers);
-    }
-  };
-};
-const Redirect = (url) => {
-  return {
-    name: "Redirect",
-    metadata(helper) {
-      setResponseMeta(helper, import_types.ResponseMetaType.Redirect, url);
+})();
+(()=>{
+    __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__, {
+    Post: ()=>Post,
+    Redirect: ()=>Redirect,
+    Connect: ()=>Connect,
+    Params: ()=>Params,
+    Upload: ()=>Upload,
+    Patch: ()=>Patch,
+    Delete: ()=>Delete,
+    Head: ()=>Head,
+    Options: ()=>Options,
+    Query: ()=>Query,
+    Get: ()=>Get,
+    HttpCode: ()=>HttpCode,
+    Data: ()=>Data,
+    Put: ()=>Put,
+    SetHeaders: ()=>SetHeaders,
+    Trace: ()=>Trace,
+    createHttpOperator: ()=>createHttpOperator,
+    Headers: ()=>Headers
+});
+const http_js_namespaceObject = require("../errors/http.js");
+const external_types_js_namespaceObject = require("../types.js");
+const validateInput = async (schema, input)=>{
+    try {
+        return await schema.parseAsync(input);
+    } catch (error) {
+        if ('name' in error && 'ZodError' === error.name) throw new http_js_namespaceObject.ValidationError(400, error.message);
+        throw error;
     }
-  };
 };
-const Upload = (urlPath, schema) => {
-  return {
-    name: "Upload",
-    metadata({ setMetadata }) {
-      setMetadata(import_types.OperatorType.Trigger, {
-        type: import_types.TriggerType.Http,
-        path: urlPath,
-        method: import_types.HttpMethod.Post,
-        action: "upload"
-      });
-      setMetadata(import_types.HttpMetadata.Files, schema);
-    },
-    async validate(helper, next) {
-      if (!schema) {
-        return next();
-      }
-      const { inputs: { formData: files } } = helper;
-      helper.inputs = {
-        ...helper.inputs,
-        files: await validateInput(schema, files)
-      };
-      return next();
-    }
-  };
+const createHttpOperator = (method)=>(urlPath)=>({
+            name: method,
+            metadata ({ setMetadata }) {
+                setMetadata(external_types_js_namespaceObject.OperatorType.Trigger, {
+                    type: external_types_js_namespaceObject.TriggerType.Http,
+                    path: urlPath,
+                    method
+                });
+            }
+        });
+const Get = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Get);
+const Post = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Post);
+const Put = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Put);
+const Delete = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Delete);
+const Connect = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Connect);
+const Trace = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Trace);
+const Patch = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Patch);
+const Options = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Options);
+const Head = createHttpOperator(external_types_js_namespaceObject.HttpMethod.Head);
+const Data = (schema)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Data,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Data, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { data } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                data: await validateInput(schema, data)
+            };
+            return next();
+        }
+    });
+const Query = (schema)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Query,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Query, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { query } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                query: await validateInput(schema, query)
+            };
+            return next();
+        }
+    });
+const Params = (schema)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Params,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Params, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { params } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                params: await validateInput(schema, params)
+            };
+            return next();
+        }
+    });
+const Headers = (schema)=>({
+        name: external_types_js_namespaceObject.HttpMetadata.Headers,
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Headers, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { headers } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                headers: await validateInput(schema, headers)
+            };
+            return next();
+        }
+    });
+const setResponseMeta = (helper, type, value)=>{
+    const responseMetaData = helper.getMetadata(external_types_js_namespaceObject.HttpMetadata.Response) || [];
+    helper.setMetadata(external_types_js_namespaceObject.HttpMetadata.Response, [
+        ...responseMetaData,
+        {
+            type,
+            value
+        }
+    ]);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Connect,
-  Data,
-  Delete,
-  Get,
-  Head,
-  Headers,
-  HttpCode,
-  Options,
-  Params,
-  Patch,
-  Post,
-  Put,
-  Query,
-  Redirect,
-  SetHeaders,
-  Trace,
-  Upload,
-  createHttpOperator
+const HttpCode = (statusCode)=>({
+        name: 'HttpCode',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.StatusCode, statusCode);
+        }
+    });
+const SetHeaders = (headers)=>({
+        name: 'SetHeaders',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.Headers, headers);
+        }
+    });
+const Redirect = (url)=>({
+        name: 'Redirect',
+        metadata (helper) {
+            setResponseMeta(helper, external_types_js_namespaceObject.ResponseMetaType.Redirect, url);
+        }
+    });
+const Upload = (urlPath, schema)=>({
+        name: 'Upload',
+        metadata ({ setMetadata }) {
+            setMetadata(external_types_js_namespaceObject.OperatorType.Trigger, {
+                type: external_types_js_namespaceObject.TriggerType.Http,
+                path: urlPath,
+                method: external_types_js_namespaceObject.HttpMethod.Post,
+                action: 'upload'
+            });
+            setMetadata(external_types_js_namespaceObject.HttpMetadata.Files, schema);
+        },
+        async validate (helper, next) {
+            if (!schema) return next();
+            const { inputs: { formData: files } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                files: await validateInput(schema, files)
+            };
+            return next();
+        }
+    });
+exports.Connect = __webpack_exports__.Connect;
+exports.Data = __webpack_exports__.Data;
+exports.Delete = __webpack_exports__.Delete;
+exports.Get = __webpack_exports__.Get;
+exports.Head = __webpack_exports__.Head;
+exports.Headers = __webpack_exports__.Headers;
+exports.HttpCode = __webpack_exports__.HttpCode;
+exports.Options = __webpack_exports__.Options;
+exports.Params = __webpack_exports__.Params;
+exports.Patch = __webpack_exports__.Patch;
+exports.Post = __webpack_exports__.Post;
+exports.Put = __webpack_exports__.Put;
+exports.Query = __webpack_exports__.Query;
+exports.Redirect = __webpack_exports__.Redirect;
+exports.SetHeaders = __webpack_exports__.SetHeaders;
+exports.Trace = __webpack_exports__.Trace;
+exports.Upload = __webpack_exports__.Upload;
+exports.createHttpOperator = __webpack_exports__.createHttpOperator;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Connect",
+    "Data",
+    "Delete",
+    "Get",
+    "Head",
+    "Headers",
+    "HttpCode",
+    "Options",
+    "Params",
+    "Patch",
+    "Post",
+    "Put",
+    "Query",
+    "Redirect",
+    "SetHeaders",
+    "Trace",
+    "Upload",
+    "createHttpOperator"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });