@modern-js/runtime 2.14.0 → 2.15.1-alpha.0

package/dist/js/node/ssr/utils.js

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.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 __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 utils_exports = {};
+__export(utils_exports, {
+  formatClient: () => formatClient,
+  formatServer: () => formatServer,
+  isCrossOrigin: () => isCrossOrigin,
+  isReact18: () => isReact18,
+  mockResponse: () => mockResponse
+});
+module.exports = __toCommonJS(utils_exports);
+const isReact18 = () => process.env.IS_REACT18 === "true";
+const formatServer = (request) => {
+  const {
+    cookie = "",
+    "user-agent": userAgent = "",
+    referer
+  } = request.headers || {};
+  return __spreadValues({
+    cookie,
+    userAgent,
+    referer
+  }, request);
+};
+const getQuery = () => window.location.search.substring(1).split("&").reduce((res, item) => {
+  const [key, value] = item.split("=");
+  if (key) {
+    res[key] = value;
+  }
+  return res;
+}, {});
+const formatClient = (request) => {
+  var _a, _b;
+  return {
+    params: request.params || {},
+    host: request.host || location.host,
+    pathname: request.pathname || location.pathname,
+    headers: request.headers || {},
+    cookieMap: request.cookieMap || {},
+    cookie: ((_a = request.headers) == null ? void 0 : _a.cookie) || document.cookie,
+    userAgent: ((_b = request.headers) == null ? void 0 : _b["user-agent"]) || navigator.userAgent,
+    referer: request.referer || document.referrer,
+    query: request.query || getQuery(),
+    url: location.href
+  };
+};
+const mockResponse = () => {
+  return {
+    setHeader() {
+      console.warn("response.setHeader() can only be used in the server side");
+    },
+    status() {
+      console.warn("response.status() can only be used in the server side");
+    },
+    get locals() {
+      console.warn("response.locals can only be used in the server side");
+      return {};
+    }
+  };
+};
+const isCrossOrigin = (url = "", base) => {
+  if (url.startsWith("/") || url.startsWith("./")) {
+    return false;
+  } else if (!url.includes(base)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatClient,
+  formatServer,
+  isCrossOrigin,
+  isReact18,
+  mockResponse
+});

package/dist/js/node/state/cli/index.js

@@ -0,0 +1,100 @@
+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 cli_exports = {};
+__export(cli_exports, {
+  default: () => cli_default
+});
+module.exports = __toCommonJS(cli_exports);
+var import_utils = require("@modern-js/utils");
+const PLUGIN_IDENTIFIER = "state";
+var cli_default = () => ({
+  name: "@modern-js/plugin-state",
+  required: ["@modern-js/runtime"],
+  setup: (api) => {
+    const stateConfigMap = /* @__PURE__ */ new Map();
+    let pluginsExportsUtils;
+    return {
+      config() {
+        const appContext = api.useAppContext();
+        pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(
+          appContext.internalDirectory,
+          "plugins"
+        );
+        return {
+          source: {
+            alias: {
+              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
+            }
+          }
+        };
+      },
+      modifyEntryImports({ entrypoint, imports }) {
+        var _a;
+        const { entryName } = entrypoint;
+        const userConfig = api.useResolvedConfigContext();
+        const { packageName } = api.useAppContext();
+        const stateConfig = (_a = (0, import_utils.getEntryOptions)(
+          entryName,
+          userConfig.runtime,
+          userConfig.runtimeByEntries,
+          packageName
+        )) == null ? void 0 : _a.state;
+        stateConfigMap.set(entryName, stateConfig);
+        if (stateConfig) {
+          imports.push({
+            value: "@modern-js/runtime/plugins",
+            specifiers: [
+              {
+                imported: PLUGIN_IDENTIFIER
+              }
+            ]
+          });
+        }
+        return {
+          entrypoint,
+          imports
+        };
+      },
+      modifyEntryRuntimePlugins({ entrypoint, plugins }) {
+        const stateOptions = stateConfigMap.get(entrypoint.entryName);
+        if (stateOptions) {
+          plugins.push({
+            name: PLUGIN_IDENTIFIER,
+            options: `${JSON.stringify(
+              stateConfigMap.get(entrypoint.entryName)
+            )}`
+          });
+        }
+        return {
+          entrypoint,
+          plugins
+        };
+      },
+      validateSchema() {
+        return import_utils.PLUGIN_SCHEMAS["@modern-js/plugin-state"];
+      },
+      addRuntimeExports() {
+        pluginsExportsUtils.addExport(
+          `export { default as state } from '@modern-js/runtime/model'`
+        );
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/state/index.js

@@ -0,0 +1,37 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_exports = {};
+__export(state_exports, {
+  default: () => import_runtime2.default,
+  state: () => import_runtime.default
+});
+module.exports = __toCommonJS(state_exports);
+var import_runtime = __toESM(require("./runtime"));
+var import_runtime2 = __toESM(require("./runtime"));
+__reExport(state_exports, require("./runtime"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  state
+});

package/dist/js/node/state/plugins.js

@@ -0,0 +1,45 @@
+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 plugins_exports = {};
+__export(plugins_exports, {
+  autoActions: () => autoActions,
+  devtools: () => import_plugin_devtools.default,
+  effects: () => effects,
+  immer: () => immer
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_plugin_effects = require("@modern-js-reduck/plugin-effects");
+var import_plugin_auto_actions = __toESM(require("@modern-js-reduck/plugin-auto-actions"));
+var import_plugin_immutable = __toESM(require("@modern-js-reduck/plugin-immutable"));
+var import_plugin_devtools = __toESM(require("@modern-js-reduck/plugin-devtools"));
+const effects = () => import_plugin_effects.plugin;
+const immer = () => import_plugin_immutable.default;
+const autoActions = () => import_plugin_auto_actions.default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoActions,
+  devtools,
+  effects,
+  immer
+});

package/dist/js/node/state/runtime/index.js

@@ -0,0 +1,40 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  createStore: () => import_store.createStore,
+  default: () => import_plugin.default,
+  model: () => import_store.model
+});
+module.exports = __toCommonJS(runtime_exports);
+__reExport(runtime_exports, require("@modern-js-reduck/react"), module.exports);
+var import_store = require("@modern-js-reduck/store");
+var import_plugin = __toESM(require("./plugin"));
+__reExport(runtime_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStore,
+  model
+});

package/dist/js/node/state/runtime/plugin.js

@@ -0,0 +1,121 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_store = require("@modern-js-reduck/store");
+var import_react2 = require("@modern-js-reduck/react");
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_plugins = require("../plugins");
+var import_core = require("../../core");
+var import_common = require("../../common");
+__reExport(plugin_exports, require("../plugins"), module.exports);
+const StatePluginHandleMap = {
+  immer: import_plugins.immer,
+  effects: import_plugins.effects,
+  autoActions: import_plugins.autoActions,
+  devtools: import_plugins.devtools
+};
+const getStoreConfig = (config) => {
+  const internalPlugins = [
+    "immer",
+    "effects",
+    "autoActions",
+    "devtools"
+  ];
+  const plugins = [];
+  internalPlugins.filter((plugin) => config[plugin] !== false).forEach(
+    (plugin) => plugins.push(StatePluginHandleMap[plugin](config[plugin]))
+  );
+  const storeConfig = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (!internalPlugins.includes(key)) {
+      storeConfig[key] = value;
+    }
+  }
+  storeConfig.plugins = plugins;
+  return storeConfig;
+};
+const state = (config) => ({
+  name: "@modern-js/plugin-state",
+  setup: () => {
+    const storeConfig = getStoreConfig(config);
+    return {
+      hoc({ App }, next) {
+        const getStateApp = (props) => {
+          const context = (0, import_react.useContext)(import_core.RuntimeReactContext);
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react2.Provider, {
+            store: context.store,
+            config: storeConfig,
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, __spreadValues({}, props))
+          });
+        };
+        return next({
+          App: (0, import_hoist_non_react_statics.default)(getStateApp, App)
+        });
+      },
+      init({ context }, next) {
+        var _a, _b;
+        if ((0, import_common.isBrowser)()) {
+          storeConfig.initialState = storeConfig.initialState || ((_b = (_a = window == null ? void 0 : window._SSR_DATA) == null ? void 0 : _a.data) == null ? void 0 : _b.storeState) || {};
+        }
+        context.store = (0, import_store.createStore)(storeConfig);
+        return next({ context });
+      },
+      pickContext({ context, pickedContext }, next) {
+        return next({
+          context,
+          pickedContext: __spreadProps(__spreadValues({}, pickedContext), {
+            store: context.store
+          })
+        });
+      }
+    };
+  }
+});
+var plugin_default = state;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/state/types.js

@@ -0,0 +1,15 @@
+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);

package/dist/js/treeshaking/cli/index.js

@@ -0,0 +1,186 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import path from "path";
+import { PLUGIN_SCHEMAS, cleanRequireCache, isReact18 } from "@modern-js/utils";
+import PluginState from "../state/cli";
+import PluginSSR from "../ssr/cli";
+import PluginRouter from "../router/cli";
+import Document from "../document/cli";
+var cli_default = function() {
+    return {
+        name: "@modern-js/runtime",
+        post: [
+            "@modern-js/plugin-router",
+            "@modern-js/plugin-ssr",
+            "@modern-js/plugin-document",
+            "@modern-js/plugin-state",
+            "@modern-js/plugin-design-token"
+        ],
+        usePlugins: [
+            PluginState(),
+            PluginSSR(),
+            PluginRouter(),
+            Document()
+        ],
+        setup: function(api) {
+            return {
+                config: function config() {
+                    var dir = api.useAppContext().internalDirectory || "";
+                    process.env.IS_REACT18 = isReact18(path.join(dir, "../../")).toString();
+                    return {
+                        runtime: {},
+                        runtimeByEntries: {},
+                        source: {
+                            alias: {
+                                "styled-components": require.resolve("styled-components")
+                            },
+                            globalVars: {
+                                "process.env.IS_REACT18": process.env.IS_REACT18
+                            }
+                        }
+                    };
+                },
+                validateSchema: function validateSchema() {
+                    return PLUGIN_SCHEMAS["@modern-js/runtime"];
+                },
+                beforeRestart: function beforeRestart() {
+                    return _asyncToGenerator(function() {
+                        return __generator(this, function(_state) {
+                            cleanRequireCache([
+                                require.resolve("../state/cli"),
+                                require.resolve("../router/cli"),
+                                require.resolve("../ssr/cli")
+                            ]);
+                            return [
+                                2
+                            ];
+                        });
+                    })();
+                }
+            };
+        }
+    };
+};
+export { cli_default as default };

package/dist/js/treeshaking/common.js

@@ -0,0 +1,4 @@
+var isBrowser = function() {
+    return typeof window !== "undefined" && window.name !== "nodejs";
+};
+export { isBrowser };

package/dist/js/treeshaking/config.js

@@ -0,0 +1 @@
+"use strict";

package/dist/js/treeshaking/core/app-config.js

@@ -0,0 +1,9 @@
+var APP_CONFIG_SYMBOL = "config";
+var getConfig = function(Component) {
+    return Component[APP_CONFIG_SYMBOL];
+};
+var defineConfig = function(Component, config) {
+    Component[APP_CONFIG_SYMBOL] = config;
+    return Component;
+};
+export { defineConfig, getConfig };