@modern-js/plugin-testing 2.20.0 → 2.20.1-alpha.0

package/dist/js/node/base/config/patches/assetsModule.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 __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 assetsModule_exports = {};
+__export(assetsModule_exports, {
+  patchAssetsModule: () => patchAssetsModule
+});
+module.exports = __toCommonJS(assetsModule_exports);
+const patchAssetsModule = (testOperator) => {
+  testOperator.mergeJestConfig({
+    moduleNameMapper: {
+      "\\.(css|less|scss|sass)$": require.resolve("identity-obj-proxy"),
+      "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": require.resolve("./filemock.js")
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  patchAssetsModule
+});

package/dist/js/node/base/config/patches/filemock.js

@@ -0,0 +1,25 @@
+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 filemock_exports = {};
+__export(filemock_exports, {
+  default: () => filemock_default
+});
+module.exports = __toCommonJS(filemock_exports);
+var filemock_default = "test-file-stub";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/base/config/patches/index.js

@@ -0,0 +1,57 @@
+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 __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());
+  });
+};
+var patches_exports = {};
+__export(patches_exports, {
+  applyPatches: () => applyPatches
+});
+module.exports = __toCommonJS(patches_exports);
+var import_transformer = require("./transformer");
+var import_assetsModule = require("./assetsModule");
+const _applyPatches = (patches2, testOperator) => __async(void 0, null, function* () {
+  for (const patch of patches2) {
+    yield patch(testOperator);
+  }
+});
+const patches = [import_transformer.patchTransformer, import_assetsModule.patchAssetsModule];
+const applyPatches = (testConfig) => __async(void 0, null, function* () {
+  yield _applyPatches(patches, testConfig);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyPatches
+});

package/dist/js/node/base/config/patches/transformer.js

@@ -0,0 +1,67 @@
+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 transformer_exports = {};
+__export(transformer_exports, {
+  patchTransformer: () => patchTransformer
+});
+module.exports = __toCommonJS(transformer_exports);
+var import_utils = require("../../utils");
+const resolveTsCompilerOptions = () => {
+  const tsCompilerOptions = (0, import_utils.readCompilerOptions)() || {};
+  const { jsx } = tsCompilerOptions;
+  if (!jsx) {
+    return null;
+  }
+  tsCompilerOptions.jsx = "react-jsx";
+  return tsCompilerOptions;
+};
+const patchTransformer = (testOperator) => {
+  const { transformer } = testOperator.testConfig;
+  if (transformer === "babel-jest") {
+    testOperator.mergeJestConfig({
+      transform: {
+        "\\.[jt]sx?$": require.resolve("../transformer/babelTransformer")
+      }
+    });
+  }
+  if (transformer === "ts-jest") {
+    testOperator.mergeJestConfig({
+      transform: {
+        "\\.[jt]sx?$": require.resolve("ts-jest")
+      }
+    });
+    const compilerOptions = resolveTsCompilerOptions();
+    compilerOptions && testOperator.mergeJestConfig({
+      globals: {
+        "ts-jest": {
+          tsconfig: compilerOptions
+        }
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  patchTransformer
+});

package/dist/js/node/base/config/resolver.js

@@ -0,0 +1,30 @@
+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 __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 import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+const resolver = import_enhanced_resolve.default.create.sync({
+  conditionNames: ["require", "node", "default"],
+  extensions: [".js", ".json", ".node", ".ts", ".tsx"]
+});
+const shouldResolveByEnhance = (url) => /^@[^/]+\/[^/]+\/.*/.test(url);
+module.exports = function(request, options) {
+  if (shouldResolveByEnhance(request)) {
+    return resolver(options.basedir, request);
+  }
+  return options.defaultResolver(request, options);
+};

package/dist/js/node/base/config/testConfigOperator.js

@@ -0,0 +1,90 @@
+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 testConfigOperator_exports = {};
+__export(testConfigOperator_exports, {
+  TestConfigOperator: () => TestConfigOperator
+});
+module.exports = __toCommonJS(testConfigOperator_exports);
+var import_lodash = require("@modern-js/utils/lodash");
+class TestConfigOperator {
+  constructor(testConfig) {
+    this.defaultTestConfig = {
+      transformer: "babel-jest"
+    };
+    this._testConfig = testConfig;
+    this._jestConfig = {};
+    this.userJestConfig = testConfig.jest;
+    this.initial();
+  }
+  initial() {
+    this._testConfig = (0, import_lodash.merge)({}, this.defaultTestConfig, this.testConfig);
+  }
+  get jestConfig() {
+    return this._jestConfig;
+  }
+  get testConfig() {
+    return this._testConfig;
+  }
+  mergeJestConfig(sourceConfig) {
+    this._jestConfig = (0, import_lodash.merge)({}, this._jestConfig, sourceConfig);
+  }
+  setJestUserConfig() {
+    const { userJestConfig } = this;
+    if (typeof userJestConfig === "object") {
+      this.setJestConfig(userJestConfig);
+    }
+  }
+  setJestConfig(sourceConfig, options) {
+    if (options) {
+      const { force } = options;
+      if (force) {
+        this._jestConfig = sourceConfig;
+        return;
+      }
+    }
+    this._jestConfig = __spreadValues(__spreadValues({}, this._jestConfig), sourceConfig);
+  }
+  getFinalConfig() {
+    const { userJestConfig } = this;
+    if (!userJestConfig) {
+      return this._jestConfig;
+    }
+    if (typeof userJestConfig === "function") {
+      return userJestConfig(this._jestConfig);
+    }
+    return this.jestConfig;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestConfigOperator
+});

package/dist/js/node/base/config/transformer/babelTransformer.js

@@ -0,0 +1,46 @@
+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 babelTransformer_exports = {};
+__export(babelTransformer_exports, {
+  default: () => babelTransformer_default
+});
+module.exports = __toCommonJS(babelTransformer_exports);
+var import_babel_jest = __toESM(require("babel-jest"));
+var _a, _b;
+const babelTransformer = (_b = (_a = import_babel_jest.default).createTransformer) == null ? void 0 : _b.call(_a, {
+  presets: [
+    [
+      require.resolve("@modern-js/babel-preset-app"),
+      {
+        appDirectory: process.cwd(),
+        modules: "cjs"
+      }
+    ]
+  ],
+  configFile: false,
+  babelrc: false
+});
+var babelTransformer_default = babelTransformer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/base/hook.js

@@ -0,0 +1,37 @@
+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 hook_exports = {};
+__export(hook_exports, {
+  afterTestHook: () => afterTestHook,
+  jestConfigHook: () => jestConfigHook,
+  testingHooks: () => testingHooks
+});
+module.exports = __toCommonJS(hook_exports);
+var import_plugin = require("@modern-js/plugin");
+const jestConfigHook = (0, import_plugin.createAsyncPipeline)();
+const afterTestHook = (0, import_plugin.createParallelWorkflow)();
+const testingHooks = {
+  jestConfig: (0, import_plugin.createAsyncPipeline)(),
+  afterTest: (0, import_plugin.createParallelWorkflow)()
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterTestHook,
+  jestConfigHook,
+  testingHooks
+});

package/dist/js/node/base/index.js

@@ -0,0 +1,43 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  DEFAULT_RESOLVER_PATH: () => import_config.DEFAULT_RESOLVER_PATH,
+  TestConfigOperator: () => import_testConfigOperator.TestConfigOperator,
+  getModuleNameMapper: () => import_utils.getModuleNameMapper,
+  runJest: () => import_runJest.runJest,
+  runTest: () => import_runJest.runTest,
+  testingHooks: () => import_hook.testingHooks
+});
+module.exports = __toCommonJS(base_exports);
+var import_runJest = require("./runJest");
+var import_utils = require("./utils");
+var import_config = require("./config");
+var import_testConfigOperator = require("./config/testConfigOperator");
+var import_hook = require("./hook");
+__reExport(base_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RESOLVER_PATH,
+  TestConfigOperator,
+  getModuleNameMapper,
+  runJest,
+  runTest,
+  testingHooks
+});

package/dist/js/node/base/runJest.js

@@ -0,0 +1,132 @@
+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 __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());
+  });
+};
+var runJest_exports = {};
+__export(runJest_exports, {
+  runJest: () => runJest,
+  runTest: () => runTest
+});
+module.exports = __toCommonJS(runJest_exports);
+var import_yargs = __toESM(require("yargs/yargs"));
+var import_jest = require("jest");
+var import_utils = require("@modern-js/utils");
+var import_config = require("./config");
+var import_utils2 = require("./utils");
+const buildArgv = (rawArgv, config) => __async(void 0, null, function* () {
+  const argv = yield (0, import_yargs.default)(rawArgv).argv;
+  const result = {
+    $0: argv.$0,
+    _: argv._.slice(1)
+  };
+  Object.keys(argv).forEach((key) => {
+    if (key.includes("-") || key === "_") {
+      return;
+    }
+    result[key] = argv[key];
+  });
+  if (config) {
+    result.config = JSON.stringify(config);
+  }
+  return result;
+});
+const readResultsAndExit = (result, globalConfig) => {
+  const code = !result || result.success ? 0 : globalConfig.testFailureExitCode;
+  process.on("exit", () => {
+    if (typeof code === "number" && code !== 0) {
+      process.exitCode = code;
+    }
+  });
+  if (globalConfig.forceExit) {
+    if (!globalConfig.detectOpenHandles) {
+      console.warn(
+        `${import_utils.chalk.bold(
+          "Force exiting Jest: "
+        )}Have you considered using \`--detectOpenHandles\` to detect async operations that kept running after all tests finished?`
+      );
+    }
+    process.exit(code);
+  } else if (!globalConfig.detectOpenHandles) {
+    setTimeout(() => {
+      console.warn(
+        import_utils.chalk.yellow.bold(
+          "Jest did not exit one second after the test run has completed.\n\n"
+        ) + import_utils.chalk.yellow(
+          "This usually means that there are asynchronous operations that weren't stopped in your tests. Consider running Jest with `--detectOpenHandles` to troubleshoot this issue."
+        )
+      );
+    }, 1e3).unref();
+  }
+};
+function runJest(_0) {
+  return __async(this, arguments, function* (config, pwd = process.cwd()) {
+    try {
+      const argvConfig = yield buildArgv(process.argv.slice(2), config);
+      const { results, globalConfig } = yield (0, import_jest.runCLI)(argvConfig, [pwd]);
+      readResultsAndExit(results, globalConfig);
+    } catch (e) {
+      console.error(import_utils.chalk.red((e == null ? void 0 : e.stack) || e));
+      process.exit(1);
+    }
+  });
+}
+function runTest(_0, _1) {
+  return __async(this, arguments, function* (api, config, pwd = process.cwd()) {
+    process.env.NODE_ENV = "test";
+    const jestUtils = (0, import_config.getJestUtils)(config);
+    yield (0, import_config.patchConfig)(jestUtils);
+    jestUtils.setJestUserConfig();
+    const hookRunners = api.useHookRunners();
+    const testConfigOperator = yield hookRunners.jestConfig(jestUtils, {
+      onLast: (input) => input
+    });
+    const finalConfig = testConfigOperator.getFinalConfig();
+    (0, import_utils2.debug)("Jest config:", finalConfig);
+    yield runJest(finalConfig, pwd);
+    yield hookRunners.afterTest();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runJest,
+  runTest
+});

package/dist/js/node/base/types/index.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);