@modern-js/runtime 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/js/node/core/compatible.js

@@ -1,243 +1,281 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  bootstrap: () => bootstrap,
+  createApp: () => createApp,
+  useRuntimeContext: () => useRuntimeContext
 });
-exports.useRuntimeContext = exports.createApp = exports.bootstrap = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));
-var _runtimeContext = require("../runtime-context");
-var _plugin = require("./plugin");
-var _loaderManager = require("./loader/loaderManager");
-var _jsxRuntime = require("react/jsx-runtime");
-const _excluded = ["context"];
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-const IS_REACT18 = process.env.IS_REACT18 === 'true';
-const ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
+module.exports = __toCommonJS(stdin_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_constants = require("@modern-js/utils/constants");
+var import_runtime_context = require("../runtime-context");
+var import_plugin = require("./plugin");
+var import_loaderManager = require("./loader/loaderManager");
+var __defProp2 = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const IS_REACT18 = process.env.IS_REACT18 === "true";
 function isClientArgs(id) {
-  return typeof id === 'string' || typeof HTMLElement !== 'undefined' && id instanceof HTMLElement;
+  return typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
 }
-const runnerMap = new WeakMap();
-const getInitialContext = runner => ({
-  loaderManager: (0, _loaderManager.createLoaderManager)({}),
+const runnerMap = /* @__PURE__ */ new WeakMap();
+const getInitialContext = (runner) => ({
+  loaderManager: (0, import_loaderManager.createLoaderManager)({}),
   runner,
   isBrowser: true,
-  routeManifest: typeof window !== 'undefined' && window[ROUTE_MANIFEST]
+  routeManifest: typeof window !== "undefined" && window[import_constants.ROUTE_MANIFEST]
 });
-const createApp = ({
-  plugins
-}) => {
-  const appRuntime = _plugin.runtime.clone();
+const createApp = ({ plugins }) => {
+  const appRuntime = import_plugin.runtime.clone();
   appRuntime.usePlugin(...plugins);
-  return App => {
+  return (App) => {
     const runner = appRuntime.init();
-    const WrapperComponent = props => {
-      const element = /*#__PURE__*/_react.default.createElement(App || _react.default.Fragment, _objectSpread({}, props), props.children);
-      const context = (0, _react.useContext)(_runtimeContext.RuntimeReactContext);
-      return runner.provide({
-        element,
-        props: _objectSpread({}, props),
-        context
-      }, {
-        onLast: ({
-          element
-        }) => element
-      });
+    const WrapperComponent = (props) => {
+      const element = import_react.default.createElement(
+        App || import_react.default.Fragment,
+        __spreadValues({}, props),
+        props.children
+      );
+      const context = (0, import_react.useContext)(import_runtime_context.RuntimeReactContext);
+      return runner.provide(
+        { element, props: __spreadValues({}, props), context },
+        {
+          onLast: ({ element: element2 }) => element2
+        }
+      );
     };
     if (App) {
-      (0, _hoistNonReactStatics.default)(WrapperComponent, App);
+      (0, import_hoist_non_react_statics.default)(WrapperComponent, App);
     }
-    const HOCApp = runner.hoc({
-      App: WrapperComponent
-    }, {
-      onLast: ({
-        App
-      }) => {
-        const WrapComponent = _ref => {
-          var _contextValue;
-          let {
-              context
-            } = _ref,
-            props = _objectWithoutProperties(_ref, _excluded);
-          let contextValue = context;
-
-          // We should construct the context, when root component is not passed into `bootstrap`.
-          if (!((_contextValue = contextValue) !== null && _contextValue !== void 0 && _contextValue.runner)) {
-            contextValue = getInitialContext(runner);
-            runner.init({
-              context: contextValue
-            }, {
-              onLast: ({
-                context: context1
-              }) => {
-                var _App$init;
-                return App === null || App === void 0 ? void 0 : (_App$init = App.init) === null || _App$init === void 0 ? void 0 : _App$init.call(App, context1);
-              }
+    const HOCApp = runner.hoc(
+      { App: WrapperComponent },
+      {
+        onLast: ({ App: App2 }) => {
+          const WrapComponent = (_a) => {
+            var _b = _a, { context } = _b, props = __objRest(_b, ["context"]);
+            let contextValue = context;
+            if (!(contextValue == null ? void 0 : contextValue.runner)) {
+              contextValue = getInitialContext(runner);
+              runner.init(
+                { context: contextValue },
+                {
+                  onLast: ({ context: context1 }) => {
+                    var _a2;
+                    return (_a2 = App2 == null ? void 0 : App2.init) == null ? void 0 : _a2.call(App2, context1);
+                  }
+                }
+              );
+            }
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_runtime_context.RuntimeReactContext.Provider, {
+              value: contextValue,
+              children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App2, __spreadValues({}, props))
             });
-          }
-          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_runtimeContext.RuntimeReactContext.Provider, {
-            value: contextValue,
-            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(App, _objectSpread({}, props))
-          });
-        };
-        return (0, _hoistNonReactStatics.default)(WrapComponent, App);
+          };
+          return (0, import_hoist_non_react_statics.default)(WrapComponent, App2);
+        }
       }
-    });
+    );
     runnerMap.set(HOCApp, runner);
     return HOCApp;
   };
 };
-exports.createApp = createApp;
-const bootstrap = async (BootApp,
-/**
- * When csr, id is root id.
- * When ssr, id is serverContext
- */
-id,
-/**
- * root.render need use root to run function
- */
-root, ReactDOM
-// eslint-disable-next-line consistent-return
-) => {
+const bootstrap = (BootApp, id, root, ReactDOM) => __async(void 0, null, function* () {
+  var _a, _b;
   let App = BootApp;
   let runner = runnerMap.get(App);
-
-  // ensure Component used is created by `createApp`
   if (!runner) {
-    App = createApp({
-      plugins: []
-    })(App);
+    App = createApp({ plugins: [] })(App);
     runner = runnerMap.get(App);
   }
   const context = getInitialContext(runner);
-  const runInit = _context => runner.init({
-    context: _context
-  }, {
-    onLast: ({
-      context: context1
-    }) => {
-      var _App, _App$init2;
-      return (_App = App) === null || _App === void 0 ? void 0 : (_App$init2 = _App.init) === null || _App$init2 === void 0 ? void 0 : _App$init2.call(_App, context1);
+  const runInit = (_context) => runner.init(
+    { context: _context },
+    {
+      onLast: ({ context: context1 }) => {
+        var _a2;
+        return (_a2 = App == null ? void 0 : App.init) == null ? void 0 : _a2.call(App, context1);
+      }
     }
-  });
-
-  // don't mount the App, let user in charge of it.
+  );
   if (!id) {
-    return /*#__PURE__*/_react.default.createElement(App, {
+    return import_react.default.createElement(App, {
       context
     });
   }
-  const isBrowser = typeof window !== 'undefined' && window.name !== 'nodejs';
+  const isBrowser = typeof window !== "undefined" && window.name !== "nodejs";
   if (isBrowser) {
     if (isClientArgs(id)) {
-      var _ssrData$data, _ssrData$data2;
       const ssrData = window._SSR_DATA;
-      const loadersData = (ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data = ssrData.data) === null || _ssrData$data === void 0 ? void 0 : _ssrData$data.loadersData) || {};
-      const initialLoadersState = Object.keys(loadersData).reduce((res, key) => {
-        const loaderData = loadersData[key];
-        if (loaderData.loading !== false) {
+      const loadersData = ((_a = ssrData == null ? void 0 : ssrData.data) == null ? void 0 : _a.loadersData) || {};
+      const initialLoadersState = Object.keys(loadersData).reduce(
+        (res, key) => {
+          const loaderData = loadersData[key];
+          if (loaderData.loading !== false) {
+            return res;
+          }
+          res[key] = loaderData;
           return res;
-        }
-        res[key] = loaderData;
-        return res;
-      }, {});
-      Object.assign(context, _objectSpread({
-        loaderManager: (0, _loaderManager.createLoaderManager)(initialLoadersState, {
+        },
+        {}
+      );
+      Object.assign(context, __spreadValues({
+        loaderManager: (0, import_loaderManager.createLoaderManager)(initialLoadersState, {
           skipStatic: true
         })
-      }, ssrData ? {
-        ssrContext: ssrData === null || ssrData === void 0 ? void 0 : ssrData.context
-      } : {}));
-      context.initialData = ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data2 = ssrData.data) === null || _ssrData$data2 === void 0 ? void 0 : _ssrData$data2.initialData;
-      const initialData = await runInit(context);
+      }, ssrData ? { ssrContext: ssrData == null ? void 0 : ssrData.context } : {}));
+      context.initialData = (_b = ssrData == null ? void 0 : ssrData.data) == null ? void 0 : _b.initialData;
+      const initialData = yield runInit(context);
       if (initialData) {
         context.initialData = initialData;
       }
-      const rootElement = typeof id !== 'string' ? id : document.getElementById(id || 'root');
+      const rootElement = typeof id !== "string" ? id : document.getElementById(id || "root");
       if (!ReactDOM) {
-        throw Error('The `bootstrap` need provide `ReactDOM` parameter');
+        throw Error("The `bootstrap` need provide `ReactDOM` parameter");
       }
-      // https://reactjs.org/blog/2022/03/08/react-18-upgrade-guide.html
-      const ModernRender = App => {
+      const ModernRender = (App2) => {
         if (IS_REACT18) {
           if (root) {
-            root.render(App);
+            root.render(App2);
           } else if (ReactDOM.createRoot) {
-            ReactDOM.createRoot(rootElement).render(App);
+            ReactDOM.createRoot(rootElement).render(App2);
           } else {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `createRoot` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `createRoot` method"
+            );
           }
         } else {
           if (!ReactDOM.render) {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `render` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `render` method"
+            );
           }
-          ReactDOM.render(App, rootElement);
+          ReactDOM.render(App2, rootElement);
         }
       };
-      const ModernHydrate = (App, callback) => {
+      const ModernHydrate = (App2, callback) => {
         if (IS_REACT18) {
           if (!ReactDOM.hydrateRoot) {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method"
+            );
           }
-          ReactDOM.hydrateRoot(rootElement, App);
+          ReactDOM.hydrateRoot(rootElement, App2);
         } else {
           if (!ReactDOM.hydrate) {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method"
+            );
           }
-          ReactDOM.hydrate(App, rootElement, callback);
+          ReactDOM.hydrate(App2, rootElement, callback);
         }
       };
-      return runner.client({
-        App,
-        context,
-        ModernRender,
-        ModernHydrate
-      }, {
-        onLast: ({
-          App
-        }) => {
-          ModernRender( /*#__PURE__*/_react.default.createElement(App, {
-            context
-          }));
+      return runner.client(
+        {
+          App,
+          context,
+          ModernRender,
+          ModernHydrate
+        },
+        {
+          onLast: ({ App: App2 }) => {
+            ModernRender(import_react.default.createElement(App2, { context }));
+          }
         }
-      });
+      );
     } else {
-      throw Error('`bootstrap` needs id in browser environment, it needs to be string or element');
+      throw Error(
+        "`bootstrap` needs id in browser environment, it needs to be string or element"
+      );
     }
   } else {
     Object.assign(context, {
       ssrContext: id,
       isBrowser: false,
-      loaderManager: (0, _loaderManager.createLoaderManager)({}, {
-        skipNonStatic: id.staticGenerate,
-        // if not static generate, only non-static loader can exec on prod env
-        skipStatic: process.env.NODE_ENV === 'production' && !id.staticGenerate
-      })
+      loaderManager: (0, import_loaderManager.createLoaderManager)(
+        {},
+        {
+          skipNonStatic: id.staticGenerate,
+          skipStatic: process.env.NODE_ENV === "production" && !id.staticGenerate
+        }
+      )
     });
-
-    // Handle redirects from React Router with an HTTP redirect
-    const isRedirectResponse = result => {
-      if (typeof Response !== 'undefined' &&
-      // fix: ssg workflow doesn't inject Web Response
-      result instanceof Response && result.status >= 300 && result.status <= 399) {
-        const {
-          status
-        } = result;
-        const redirectUrl = result.headers.get('Location') || '/';
-        const {
-          ssrContext
-        } = context;
+    const isRedirectResponse = (result) => {
+      if (typeof Response !== "undefined" && result instanceof Response && result.status >= 300 && result.status <= 399) {
+        const { status } = result;
+        const redirectUrl = result.headers.get("Location") || "/";
+        const { ssrContext } = context;
         if (ssrContext) {
           ssrContext.res.statusCode = status;
-          ssrContext.res.setHeader('Location', redirectUrl);
+          ssrContext.res.setHeader("Location", redirectUrl);
           ssrContext.redirection.status = status;
           ssrContext.redirection.url = redirectUrl;
         }
@@ -245,7 +283,7 @@ root, ReactDOM
       }
       return false;
     };
-    const initialData = await runInit(context);
+    const initialData = yield runInit(context);
     if (!isRedirectResponse(initialData)) {
       context.initialData = initialData;
       return runner.server({
@@ -254,18 +292,17 @@ root, ReactDOM
       });
     }
   }
-};
-exports.bootstrap = bootstrap;
+});
 const useRuntimeContext = () => {
-  const context = (0, _react.useContext)(_runtimeContext.RuntimeReactContext);
-  const memoizedContext = (0, _react.useMemo)(() => context.runner.pickContext({
-    context,
-    pickedContext: {}
-  }, {
-    onLast: ({
-      pickedContext
-    }) => pickedContext
-  }), [context]);
+  const context = (0, import_react.useContext)(import_runtime_context.RuntimeReactContext);
+  const memoizedContext = (0, import_react.useMemo)(
+    () => context.runner.pickContext(
+      { context, pickedContext: {} },
+      {
+        onLast: ({ pickedContext }) => pickedContext
+      }
+    ),
+    [context]
+  );
   return memoizedContext;
 };
-exports.useRuntimeContext = useRuntimeContext;

package/dist/js/node/core/index.js

@@ -1,102 +1,36 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  createPlugin: true,
-  createRuntime: true,
-  runtime: true,
-  registerInit: true,
-  defineConfig: true,
-  getConfig: true,
-  RuntimeReactContext: true,
-  ServerRouterContext: true
+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 });
 };
-Object.defineProperty(exports, "RuntimeReactContext", {
-  enumerable: true,
-  get: function () {
-    return _runtimeContext.RuntimeReactContext;
-  }
-});
-Object.defineProperty(exports, "ServerRouterContext", {
-  enumerable: true,
-  get: function () {
-    return _runtimeContext.ServerRouterContext;
-  }
-});
-Object.defineProperty(exports, "createPlugin", {
-  enumerable: true,
-  get: function () {
-    return _plugin.createPlugin;
+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 });
   }
-});
-Object.defineProperty(exports, "createRuntime", {
-  enumerable: true,
-  get: function () {
-    return _plugin.createRuntime;
-  }
-});
-Object.defineProperty(exports, "defineConfig", {
-  enumerable: true,
-  get: function () {
-    return _appConfig.defineConfig;
-  }
-});
-Object.defineProperty(exports, "getConfig", {
-  enumerable: true,
-  get: function () {
-    return _appConfig.getConfig;
-  }
-});
-Object.defineProperty(exports, "registerInit", {
-  enumerable: true,
-  get: function () {
-    return _plugin.registerInit;
-  }
-});
-Object.defineProperty(exports, "runtime", {
-  enumerable: true,
-  get: function () {
-    return _plugin.runtime;
-  }
-});
-var _plugin = require("./plugin");
-var _appConfig = require("./app-config");
-var _compatible = require("./compatible");
-Object.keys(_compatible).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _compatible[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _compatible[key];
-    }
-  });
-});
-var _runtimeContext = require("../runtime-context");
-var _loader = require("./loader");
-Object.keys(_loader).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _loader[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _loader[key];
-    }
-  });
-});
-var _plugin2 = require("@modern-js/plugin");
-Object.keys(_plugin2).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _plugin2[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _plugin2[key];
-    }
-  });
-});
+  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 stdin_exports = {};
+__export(stdin_exports, {
+  RuntimeReactContext: () => import_runtime_context.RuntimeReactContext,
+  ServerRouterContext: () => import_runtime_context.ServerRouterContext,
+  createPlugin: () => import_plugin.createPlugin,
+  createRuntime: () => import_plugin.createRuntime,
+  defineConfig: () => import_app_config.defineConfig,
+  getConfig: () => import_app_config.getConfig,
+  registerInit: () => import_plugin.registerInit,
+  runtime: () => import_plugin.runtime
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_plugin = require("./plugin");
+var import_app_config = require("./app-config");
+__reExport(stdin_exports, require("./compatible"), module.exports);
+var import_runtime_context = require("../runtime-context");
+__reExport(stdin_exports, require("./loader"), module.exports);
+__reExport(stdin_exports, require("@modern-js/plugin"), module.exports);