@modern-js/plugin-v2 2.63.7 → 2.63.8-alpha.1

package/dist/cjs/cli/run/create.js

@@ -33,9 +33,27 @@ var import_commander2 = require("./utils/commander");
 var import_createFileWatcher = require("./utils/createFileWatcher");
 var import_initAppDir = require("./utils/initAppDir");
 var import_loadEnv = require("./utils/loadEnv");
+const debug = (0, import_utils.createDebugger)("plugin-v2");
 const createCli = () => {
   let initOptions;
   const pluginManager = (0, import_manager.createPluginManager)();
+  const existListenerMap = /* @__PURE__ */ new Map();
+  function createExistListener(event, context) {
+    return async function(err) {
+      await context.hooks.onBeforeExit.call();
+      let hasError = false;
+      if (err instanceof Error) {
+        import_utils.logger.error(err.stack);
+        hasError = true;
+      } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+        console.trace("Unknown Error", err);
+        hasError = true;
+      }
+      process.nextTick(() => {
+        process.exit(hasError ? 1 : 0);
+      });
+    };
+  }
   async function init(options) {
     var _context_hooks_onAfterPrepare, _context_hooks;
     pluginManager.clear();
@@ -53,6 +71,7 @@ const createCli = () => {
     (0, import_checkIsDuplicationPlugin.checkIsDuplicationPlugin)(allPlugins.map((plugin) => plugin.name), loaded.config.autoLoadPlugins);
     pluginManager.addPlugins(allPlugins);
     const plugins = await pluginManager.getPlugins();
+    debug("CLI Plugins:", plugins.map((p) => p.name));
     const context = await (0, import_context.createContext)({
       appContext: (0, import_context.initAppContext)({
         packageName: loaded.packageName,
@@ -82,20 +101,12 @@ const createCli = () => {
       "unhandledRejection",
       "uncaughtException"
     ].forEach((event) => {
-      process.on(event, async (err) => {
-        await context.hooks.onBeforeExit.call();
-        let hasError = false;
-        if (err instanceof Error) {
-          import_utils.logger.error(err.stack);
-          hasError = true;
-        } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
-          console.trace("Unknown Error", err);
-          hasError = true;
-        }
-        process.nextTick(() => {
-          process.exit(hasError ? 1 : 0);
-        });
-      });
+      if (existListenerMap.get(event)) {
+        process.off(event, existListenerMap.get(event));
+      }
+      const existListener = createExistListener(event, context);
+      existListenerMap.set(event, existListener);
+      process.on(event, existListener);
     });
     const extraConfigs = await context.hooks.config.call();
     const normalizedConfig = await (0, import_createResolvedConfig.createResolveConfig)(loaded, extraConfigs);

package/dist/cjs/hooks.js

@@ -19,9 +19,58 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var hooks_exports = {};
 __export(hooks_exports, {
   createAsyncHook: () => createAsyncHook,
-  createCollectAsyncHook: () => createCollectAsyncHook
+  createAsyncInterruptHook: () => createAsyncInterruptHook,
+  createCollectAsyncHook: () => createCollectAsyncHook,
+  createCollectSyncHook: () => createCollectSyncHook,
+  createSyncHook: () => createSyncHook
 });
 module.exports = __toCommonJS(hooks_exports);
+function createAsyncInterruptHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    let interrupted = false;
+    let interruptResult;
+    const interrupt = (info) => {
+      interrupted = true;
+      interruptResult = info;
+    };
+    for (const callback of callbacks) {
+      if (interrupted)
+        break;
+      const result = await callback(...params, interrupt);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return interrupted ? interruptResult : params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
+function createSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    for (const callback of callbacks) {
+      const result = callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return params[0];
+  };
+  return {
+    tap,
+    call
+  };
+}
 function createAsyncHook() {
   const callbacks = [];
   const tap = (cb) => {
@@ -61,8 +110,31 @@ function createCollectAsyncHook() {
     call
   };
 }
+function createCollectSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    const results = [];
+    for (const callback of callbacks) {
+      const result = callback(params);
+      if (result !== void 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  };
+  return {
+    tap,
+    call
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAsyncHook,
-  createCollectAsyncHook
+  createAsyncInterruptHook,
+  createCollectAsyncHook,
+  createCollectSyncHook,
+  createSyncHook
 });

package/dist/cjs/index.js

@@ -19,8 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   createAsyncHook: () => import_hooks.createAsyncHook,
+  createAsyncInterruptHook: () => import_hooks.createAsyncInterruptHook,
   createCollectAsyncHook: () => import_hooks.createCollectAsyncHook,
-  createPluginManager: () => import_manager.createPluginManager
+  createCollectSyncHook: () => import_hooks.createCollectSyncHook,
+  createPluginManager: () => import_manager.createPluginManager,
+  createSyncHook: () => import_hooks.createSyncHook
 });
 module.exports = __toCommonJS(src_exports);
 var import_manager = require("./manager");
@@ -28,6 +31,9 @@ var import_hooks = require("./hooks");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAsyncHook,
+  createAsyncInterruptHook,
   createCollectAsyncHook,
-  createPluginManager
+  createCollectSyncHook,
+  createPluginManager,
+  createSyncHook
 });

package/dist/cjs/manager.js

@@ -21,8 +21,7 @@ __export(manager_exports, {
   createPluginManager: () => createPluginManager
 });
 module.exports = __toCommonJS(manager_exports);
-var import_utils = require("@modern-js/utils");
-var import_debug = require("./cli/run/utils/debug");
+const isFunction = (obj) => typeof obj === "function";
 function validatePlugin(plugin) {
   const type = typeof plugin;
   if (type !== "object" || plugin === null) {
@@ -30,7 +29,7 @@ function validatePlugin(plugin) {
   }
   if (!plugin.setup)
     return;
-  if ((0, import_utils.isFunction)(plugin.setup)) {
+  if (isFunction(plugin.setup)) {
     return;
   }
   throw new Error(`Expect CLI Plugin plugin.setup to be a function, but got ${type}.`);
@@ -70,7 +69,7 @@ function createPluginManager() {
     validatePlugin(newPlugin);
     const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
     if (plugins.has(name)) {
-      import_utils.logger.warn(`Plugin ${name} already exists.`);
+      console.warn(`Plugin ${name} already exists.`);
       return;
     }
     plugins.set(name, newPlugin);
@@ -135,7 +134,6 @@ function createPluginManager() {
       visit(name);
     });
     result = result.filter((result2) => result2);
-    (0, import_debug.debug)("CLI Plugins:", result.map((p) => p.name));
     return result;
   };
   const clear = () => {

package/dist/cjs/runtime/api.js

@@ -0,0 +1,79 @@
+"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 api_exports = {};
+__export(api_exports, {
+  initPluginAPI: () => initPluginAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_merge = require("@modern-js/runtime-utils/merge");
+function initPluginAPI({ context, plugins }) {
+  const { hooks, extendsHooks } = context;
+  function getRuntimeContext() {
+    if (context) {
+      const { hooks: hooks2, extendsHooks: extendsHooks2, config, pluginAPI, ...runtimeContext } = context;
+      runtimeContext._internalContext = context;
+      return runtimeContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function updateRuntimeContext(updateContext) {
+    context = (0, import_merge.merge)(context, updateContext);
+  }
+  function getHooks() {
+    return {
+      ...hooks,
+      ...extendsHooks
+    };
+  }
+  function getRuntimeConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  const extendsPluginApi = {};
+  plugins.forEach((plugin) => {
+    const { _registryApi } = plugin;
+    if (_registryApi) {
+      const apis = _registryApi(getRuntimeContext, updateRuntimeContext);
+      Object.keys(apis).forEach((apiName) => {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach((hookName) => {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  return {
+    updateRuntimeContext,
+    getHooks,
+    getRuntimeConfig,
+    modifyRuntimeConfig: hooks.modifyRuntimeConfig.tap,
+    onBeforeRender: hooks.onBeforeRender.tap,
+    wrapRoot: hooks.wrapRoot.tap,
+    pickContext: hooks.pickContext.tap,
+    ...extendsPluginApi
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initPluginAPI
+});

package/dist/cjs/runtime/context.js

@@ -0,0 +1,51 @@
+"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 context_exports = {};
+__export(context_exports, {
+  createRuntimeContext: () => createRuntimeContext,
+  initRuntimeContext: () => initRuntimeContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_hooks = require("./hooks");
+function initRuntimeContext() {
+  return {};
+}
+function createRuntimeContext({ runtimeContext, config, plugins }) {
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...runtimeContext,
+    hooks: {
+      ...(0, import_hooks.initHooks)(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRuntimeContext,
+  initRuntimeContext
+});

package/dist/cjs/runtime/hooks.js

@@ -0,0 +1,36 @@
+"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 hooks_exports = {};
+__export(hooks_exports, {
+  initHooks: () => initHooks
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_hooks = require("../hooks");
+function initHooks() {
+  return {
+    onBeforeRender: (0, import_hooks.createAsyncInterruptHook)(),
+    wrapRoot: (0, import_hooks.createSyncHook)(),
+    pickContext: (0, import_hooks.createSyncHook)(),
+    modifyRuntimeConfig: (0, import_hooks.createCollectSyncHook)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initHooks
+});

package/dist/cjs/runtime/index.js

@@ -0,0 +1,39 @@
+"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 runtime_exports = {};
+__export(runtime_exports, {
+  createRuntimeContext: () => import_context.createRuntimeContext,
+  initHooks: () => import_hooks.initHooks,
+  initPluginAPI: () => import_api.initPluginAPI,
+  initRuntimeContext: () => import_context.initRuntimeContext,
+  runtime: () => import_run.runtime
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_api = require("./api");
+var import_context = require("./context");
+var import_hooks = require("./hooks");
+var import_run = require("./run");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRuntimeContext,
+  initHooks,
+  initPluginAPI,
+  initRuntimeContext,
+  runtime
+});

package/dist/cjs/runtime/run/create.js

@@ -0,0 +1,74 @@
+"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 create_exports = {};
+__export(create_exports, {
+  createRuntime: () => createRuntime
+});
+module.exports = __toCommonJS(create_exports);
+var import_merge = require("@modern-js/runtime-utils/merge");
+var import_manager = require("../../manager");
+var import_api = require("../../runtime/api");
+var import_context = require("../../runtime/context");
+const createRuntime = () => {
+  let initOptions;
+  const pluginManager = (0, import_manager.createPluginManager)();
+  function init(options) {
+    pluginManager.clear();
+    initOptions = options;
+    const { plugins: allPlugins, handleSetupResult } = options;
+    pluginManager.addPlugins(allPlugins);
+    const plugins = pluginManager.getPlugins();
+    const context = (0, import_context.createRuntimeContext)({
+      runtimeContext: (0, import_context.initRuntimeContext)(),
+      config: initOptions.config,
+      plugins
+    });
+    const pluginAPI = (0, import_api.initPluginAPI)({
+      context,
+      pluginManager,
+      plugins
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins) {
+      var _plugin_setup;
+      const setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI);
+      if (handleSetupResult) {
+        handleSetupResult(setupResult, pluginAPI);
+      }
+    }
+    return {
+      runtimeContext: context
+    };
+  }
+  function run(options) {
+    const { runtimeContext } = init(options);
+    const configs = runtimeContext.hooks.modifyRuntimeConfig.call(runtimeContext.config).filter((config) => Boolean(config));
+    runtimeContext.config = (0, import_merge.merge)({}, ...configs);
+    return {
+      runtimeContext
+    };
+  }
+  return {
+    run
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRuntime
+});

package/dist/cjs/runtime/run/index.js

@@ -0,0 +1,29 @@
+"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 run_exports = {};
+__export(run_exports, {
+  runtime: () => runtime
+});
+module.exports = __toCommonJS(run_exports);
+var import_create = require("./create");
+const runtime = (0, import_create.createRuntime)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runtime
+});

package/dist/cjs/runtime/run/types.js

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

package/dist/cjs/types/runtime/api.js

@@ -0,0 +1,16 @@
+"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 api_exports = {};
+module.exports = __toCommonJS(api_exports);

package/dist/cjs/types/runtime/context.js

@@ -0,0 +1,16 @@
+"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 context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/cjs/types/runtime/hooks.js

@@ -0,0 +1,16 @@
+"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 hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);

package/dist/cjs/types/runtime/index.js

@@ -0,0 +1,16 @@
+"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 runtime_exports = {};
+module.exports = __toCommonJS(runtime_exports);

package/dist/cjs/types/runtime/plugin.js

@@ -0,0 +1,16 @@
+"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 plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);