esbuild-runner/jest.js

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
var __export = (target, all) => {
  __markAsModule(target);
  for (var name in all)
    __defProp(target, name, {get: all[name], enumerable: true});
};
var __exportStar = (target, module3, desc) => {
  __markAsModule(target);
  if (module3 && typeof module3 === "object" || typeof module3 === "function") {
    for (let key of __getOwnPropNames(module3))
      if (!__hasOwnProp.call(target, key) && key !== "default")
        __defProp(target, key, {get: () => module3[key], enumerable: !(desc = __getOwnPropDesc(module3, key)) || desc.enumerable});
  }
  return target;
};
var __toModule = (module3) => {
  if (module3 && module3.__esModule)
    return module3;
  return __exportStar(__defProp(module3 != null ? __create(__getProtoOf(module3)) : {}, "default", {value: module3, enumerable: true}), module3);
};

// src/jest.ts
__export(exports, {
  process: () => process2
});

// src/esbuild.ts
var esbuild = __toModule(require("esbuild"));
var fs = __toModule(require("fs"));
var path = __toModule(require("path"));
var pkgPath = path.default.resolve(".", "package.json");
var externals = [];
var _a, _b;
if (fs.default.existsSync(pkgPath)) {
  const pkg = JSON.parse(fs.default.readFileSync(pkgPath, {encoding: "utf-8"}));
  externals = [
    ...Object.keys((_a = pkg.dependencies) != null ? _a : {}),
    ...Object.keys((_b = pkg.devDependencies) != null ? _b : {})
  ];
}
var loaders = {
  ".mjs": "js",
  ".cjs": "js",
  ".jsx": "jsx",
  ".ts": "ts",
  ".tsx": "tsx",
  ".json": "json"
};
function supports(filename) {
  if (filename.includes("node_modules"))
    return false;
  return path.default.extname(filename) in loaders;
}
function _transform(code, filename) {
  const ret = esbuild.transformSync(code, {
    loader: loaders[path.default.extname(filename)],
    format: "cjs",
    logLevel: "error",
    target: [`node${process.version.slice(1)}`],
    minify: false,
    sourcemap: "inline",
    sourcefile: filename
  });
  return ret.code;
}
function _bundle(code, filename) {
  const ext = path.default.extname(filename);
  return esbuild.buildSync({
    loader: loaders,
    bundle: true,
    platform: "node",
    logLevel: "error",
    stdin: {
      sourcefile: filename,
      contents: code,
      resolveDir: path.default.dirname(filename),
      loader: loaders[ext]
    },
    external: externals,
    format: "cjs",
    target: [`node${process.version.slice(1)}`],
    minify: false,
    sourcemap: "inline",
    write: false
  }).outputFiles.map((f) => f.text).join("\n");
}
function _transpile(code, filename, options) {
  return options.bundle ? _bundle(code, filename) : _transform(code, filename);
}
function transpile(code, filename, options = {cache: false, bundle: true}) {
  if (options.cache) {
    const compiledPath = path.default.resolve(".", ".build", path.default.relative(path.default.resolve("."), filename));
    if (!fs.default.existsSync(compiledPath) || fs.default.statSync(compiledPath).mtime < fs.default.statSync(filename).mtime) {
      code = _transpile(code, filename, options);
      const compiledDir = path.default.dirname(compiledPath);
      if (!fs.default.existsSync(compiledDir))
        fs.default.mkdirSync(compiledDir, {recursive: true});
      fs.default.writeFileSync(compiledPath, code, {encoding: "utf-8"});
      return code;
    }
    return fs.default.readFileSync(compiledPath, {encoding: "utf-8"});
  } else {
    return _transpile(code, filename, options);
  }
}

// src/register.ts
var source_map_support = __toModule(require("source-map-support"));

// src/hook.ts
var module2 = __toModule(require("module"));
var Module = module2.default;
function install() {
  const defaultLoaderJS = Module._extensions[".js"];
  for (const ext in loaders) {
    const defaultLoader = Module._extensions[ext] || defaultLoaderJS;
    Module._extensions[ext] = (mod, filename) => {
      if (supports(filename)) {
        const defaultCompile = mod._compile;
        mod._compile = (code) => {
          mod._compile = defaultCompile;
          return mod._compile(transpile(code, filename, {bundle: true, cache: false}), filename);
        };
      }
      defaultLoader(mod, filename);
    };
  }
}

// src/register.ts
source_map_support.install({hookRequire: true});
install();

// src/jest.ts
function process2(src, filename) {
  return transpile(src, filename);
}