@sanity/pkg-utils 1.7.1 → 1.7.3

package/dist/index.js

@@ -1,3 +1,15 @@
+const _excluded = ["_path"];
+
+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; }
+
 import path from 'path';
 import { register } from 'esbuild-register/dist/node';
 import findConfig from 'find-config';
@@ -8,8 +20,6 @@ import chalk from 'chalk';
 import ts from 'typescript';
 import fs$1, { statSync } from 'fs';
 import { Observable, switchMap } from 'rxjs';
-import { promisify } from 'util';
-import rimrafCallback from 'rimraf';
 import { ExtractorConfig, Extractor } from '@microsoft/api-extractor';
 import mkdirp from 'mkdirp';
 import prettier from 'prettier';
@@ -17,11 +27,13 @@ import { TSDocConfigFile } from '@microsoft/tsdoc-config';
 import { parse } from 'jsonc-parser';
 import { rollup, watch as watch$1 } from 'rollup';
 import alias from '@rollup/plugin-alias';
+import { getBabelOutputPlugin } from '@rollup/plugin-babel';
 import commonjs from '@rollup/plugin-commonjs';
 import json from '@rollup/plugin-json';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
 import replace from '@rollup/plugin-replace';
 import esbuild from 'rollup-plugin-esbuild';
+import { terser } from 'rollup-plugin-terser';
 import browserslist from 'browserslist';
 import esbuild$1 from 'esbuild';
 import treeify from 'treeify';
@@ -29,14 +41,8 @@ import prettyBytes from 'pretty-bytes';
 import { scan, startWith, distinctUntilChanged } from 'rxjs/operators';
 import globby from 'globby';
 import chokidar from 'chokidar';
-
 const _DEFAULTS = {
-  browserslist: [
-    "> 0.2% and supports es6-module and supports es6-module-dynamic-import",
-    "not dead",
-    "not IE 11",
-    "maintained node versions"
-  ]
+  browserslist: ["> 0.2% and supports es6-module and supports es6-module-dynamic-import", "not dead", "not IE 11", "maintained node versions"]
 };
 
 function _isRecord(value) {
@@ -44,40 +50,68 @@ function _isRecord(value) {
 }
 
 async function _loadConfig(options) {
-  const { cwd } = options;
-  const pkgPath = await pkgUp({ cwd });
-  if (!pkgPath)
-    return void 0;
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp({
+    cwd
+  });
+  if (!pkgPath) return void 0;
   const root = path.dirname(pkgPath);
+
   const configFile = _findConfigFile(root);
+
   if (!configFile) {
     return void 0;
   }
+
+  if (!configFile.path.startsWith(cwd)) {
+    return void 0;
+  }
+
   try {
-    const { unregister } = configFile.transform ? register({ extensions: [".js", ".ts"] }) : { unregister: () => void 0 };
+    const {
+      unregister
+    } = configFile.transform ? register({
+      extensions: [".js", ".ts"]
+    }) : {
+      unregister: () => void 0
+    };
+
     const mod = require(configFile.path);
+
     unregister();
     return (mod == null ? void 0 : mod.default) || mod || void 0;
   } catch (_) {
     return void 0;
   }
 }
+
 function _findConfigFile(cwd) {
-  const ts = findConfig("package.config.ts", { cwd });
-  if (ts)
-    return { path: ts, transform: true };
-  const cjs = findConfig("package.config.cjs", { cwd });
-  if (cjs)
-    return { path: cjs, transform: false };
+  const ts = findConfig("package.config.ts", {
+    cwd
+  });
+  if (ts) return {
+    path: ts,
+    transform: true
+  };
+  const cjs = findConfig("package.config.cjs", {
+    cwd
+  });
+  if (cjs) return {
+    path: cjs,
+    transform: false
+  };
   return null;
 }
 
 function _resolveConfigProperty(prop, initialValue) {
-  if (!prop)
-    return initialValue;
+  if (!prop) return initialValue;
+
   if (typeof prop === "function") {
     return prop(initialValue);
   }
+
   return prop;
 }
 
@@ -98,36 +132,32 @@ const pkgSchema = z.object({
   browser: z.optional(z.record(z.string())),
   module: z.optional(z.string()),
   types: z.optional(z.string()),
-  exports: z.optional(
-    z.record(
-      z.object({
-        types: z.optional(z.string()),
-        source: z.string(),
-        browser: z.optional(
-          z.object({
-            require: z.optional(z.string()),
-            import: z.optional(z.string())
-          })
-        ),
-        node: z.optional(
-          z.object({
-            require: z.optional(z.string()),
-            import: z.optional(z.string())
-          })
-        ),
-        require: z.optional(z.string()),
-        import: z.optional(z.string()),
-        default: z.string()
-      })
-    )
-  ),
+  exports: z.optional(z.record(z.object({
+    types: z.optional(z.string()),
+    source: z.string(),
+    browser: z.optional(z.object({
+      require: z.optional(z.string()),
+      import: z.optional(z.string())
+    })),
+    node: z.optional(z.object({
+      require: z.optional(z.string()),
+      import: z.optional(z.string())
+    })),
+    require: z.optional(z.string()),
+    import: z.optional(z.string()),
+    default: z.string()
+  }))),
   browserslist: z.optional(z.array(z.string()))
 });
+
 async function _loadPkg(options) {
-  const { cwd } = options;
-  const pkgPath = await pkgUp({ cwd });
-  if (!pkgPath)
-    throw new Error("no package.json found");
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp({
+    cwd
+  });
+  if (!pkgPath) throw new Error("no package.json found");
   const buf = await fs.readFile(pkgPath);
   return pkgSchema.parse(JSON.parse(buf.toString()));
 }
@@ -139,22 +169,21 @@ async function _loadPkgWithReporting(options) {
     if (err instanceof ZodError) {
       for (const issue of err.issues) {
         if (issue.code === "invalid_type") {
-          console.log(
-            `${chalk.red("invalid type")} in ./package.json at ${chalk.magenta(
-              `\`${issue.path.join("")}\``
-            )} (expected ${issue.expected}, received ${issue.received})`
-          );
+          console.log("".concat(chalk.red("invalid type"), " in ./package.json at ").concat(chalk.magenta("`".concat(issue.path.join("."), "`")), " (expected ").concat(issue.expected, ", received ").concat(issue.received, ")"));
         }
       }
     } else {
       console.error(err);
     }
+
     process.exit(1);
   }
 }
 
 function _parseExports(options) {
-  const { pkg } = options;
+  const {
+    pkg
+  } = options;
   const rootExport = {
     _exported: true,
     _path: ".",
@@ -169,17 +198,18 @@ function _parseExports(options) {
     default: pkg.module || pkg.main || "./index.js"
   };
   const extraExports = [];
+
   if (pkg.exports) {
     for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
       if (_isRecord(exportEntry)) {
         if (exportPath === ".") {
           Object.assign(rootExport, exportEntry);
         } else {
-          const extraExport = {
+          const extraExport = _objectSpread({
             _exported: true,
-            _path: exportPath,
-            ...exportEntry
-          };
+            _path: exportPath
+          }, exportEntry);
+
           extraExports.push(extraExport);
         }
       } else {
@@ -187,179 +217,171 @@ function _parseExports(options) {
       }
     }
   }
+
   return [rootExport, ...extraExports];
 }
 
 async function _loadTSConfig(options) {
-  const { cwd, tsconfigPath } = options;
+  const {
+    cwd,
+    tsconfigPath
+  } = options;
   const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+
   if (!configPath) {
-    throw new Error(`could not find a valid '${tsconfigPath}'`);
+    throw new Error("could not find a valid '".concat(tsconfigPath, "'"));
   }
+
   const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
   return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
 }
 
-const TS_TARGETS = {
-  0: "es3",
-  1: "es5",
-  2: "es2015",
-  3: "es2016",
-  4: "es2017",
-  5: "es2018",
-  6: "es2019",
-  7: "es2020",
-  8: "es2021",
-  9: "es2022",
-  99: "esnext",
-  100: "esnext"
-};
-function _resolveEsTarget(ctx) {
-  var _a;
-  const { ts } = ctx;
-  const tsTarget = ((_a = ts.config) == null ? void 0 : _a.options.target) || 99;
-  return TS_TARGETS[tsTarget] || "esnext";
-}
-
 function _resolveBuildTasks(ctx) {
   var _a, _b, _c, _d, _e;
-  const { cwd, pkg, target } = ctx;
-  const esTarget = _resolveEsTarget(ctx);
+
+  const {
+    cwd,
+    pkg,
+    target
+  } = ctx;
   const tasks = [];
-  const exports = Object.entries(ctx.exports || {}).map(
-    ([_path, exp]) => ({ _path, ...exp })
-  );
-  const dtsTasks = {};
+  const exports = Object.entries(ctx.exports || {}).map(_ref => {
+    let [_path, exp] = _ref;
+    return _objectSpread({
+      _path
+    }, exp);
+  });
+  const dtsTask = {
+    type: "build:dts",
+    entries: []
+  };
   const rollupTasks = {};
+
   function _addRollupTaskEntry(format, runtime, entry) {
-    const buildId = `${format}:${runtime}`;
-    if (!rollupTasks[buildId]) {
+    const buildId = "".concat(format, ":").concat(runtime);
+
+    if (rollupTasks[buildId]) {
+      rollupTasks[buildId].entries.push(entry);
+    } else {
       rollupTasks[buildId] = {
         type: "build:js",
         buildId,
         entries: [entry],
         runtime,
         format,
-        target: [esTarget].concat(target[runtime])
+        target: target[runtime]
       };
-    } else {
-      rollupTasks[buildId].entries.push(entry);
     }
   }
+
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path);
+
     if (exp.types) {
-      if (!dtsTasks[importId]) {
-        dtsTasks[importId] = {
-          type: "build:dts",
-          importId,
-          exportPath: exp._path,
-          sourcePath: exp.source,
-          targetPath: exp.types
-        };
-      }
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPath: exp.types
+      });
     }
   }
+
   for (const exp of exports) {
     const output = exp.require;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("commonjs", ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = (_a = exp.browser) == null ? void 0 : _a.require;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("commonjs", "browser", {
       path: exp._path,
       source: ((_b = exp.browser) == null ? void 0 : _b.source) || exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = exp.import;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("esm", ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = (_c = exp.browser) == null ? void 0 : _c.import;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("esm", "browser", {
       path: exp._path,
       source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
       output
     });
   }
-  tasks.push(...Object.values(dtsTasks));
+
+  if (dtsTask.entries.length) {
+    tasks.push(dtsTask);
+  }
+
   tasks.push(...Object.values(rollupTasks));
+
   for (const exp of exports) {
     if (exp._exported && exp._path !== ".") {
       const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
+
       if (relativeTargetPath) {
-        fs$1.writeFileSync(
-          path.resolve(cwd, `${exp._path}.js`),
-          [
-            `// AUTO-GENERATED \u2013 DO NOT EDIT`,
-            ``,
-            `export * from '${relativeTargetPath}'`,
-            ``
-          ].join("\n")
-        );
+        fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
       }
     }
   }
+
   return tasks;
 }
 
 function _printExtractMessages(ctx, messages) {
-  const { cwd, logger } = ctx;
-  const warnings = messages.filter((msg) => msg.logLevel === "warning");
+  const {
+    cwd,
+    logger
+  } = ctx;
+  const warnings = messages.filter(msg => msg.logLevel === "warning");
+
   if (warnings.length) {
     logger.log();
   }
+
   for (const msg of warnings) {
     const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
+
     if (msg.messageId === "TS6307") {
       continue;
     }
-    logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || "?")}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.yellow("warning")} ${chalk.gray(msg.messageId)}
-`,
-        msg.text,
-        "\n"
-      ].join("")
-    );
+
+    logger.log(["".concat(chalk.cyan(sourceFilePath || "?")), ":".concat(chalk.yellow(msg.sourceFileLine), ":").concat(chalk.yellow(msg.sourceFileColumn)), " - ".concat(chalk.yellow("warning"), " ").concat(chalk.gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
   }
-  const errors = messages.filter((msg) => msg.logLevel === "error");
+
+  const errors = messages.filter(msg => msg.logLevel === "error");
+
   if (!warnings.length && errors.length) {
     logger.log("");
   }
+
   for (const msg of errors) {
     const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
-    logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || "?")}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.red("error")} ${chalk.gray(msg.messageId)}
-`,
-        msg.text,
-        "\n"
-      ].join("")
-    );
+    logger.log(["".concat(chalk.cyan(sourceFilePath || "?")), ":".concat(chalk.yellow(msg.sourceFileLine), ":").concat(chalk.yellow(msg.sourceFileColumn)), " - ".concat(chalk.red("error"), " ").concat(chalk.gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
   }
+
   if (errors.length) {
     process.exit(1);
   }
@@ -368,49 +390,47 @@ function _printExtractMessages(ctx, messages) {
 const formatHost = {
   getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
   getNewLine: () => ts.sys.newLine,
-  getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+  getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? f => f : f => f.toLowerCase()
 };
+
 async function _buildTypes(options) {
-  const { cwd, outDir, sourcePath, tsconfig } = options;
-  const compilerOptions = {
-    ...tsconfig.options,
+  const {
+    outDir,
+    tsconfig
+  } = options;
+
+  const compilerOptions = _objectSpread(_objectSpread({}, tsconfig.options), {}, {
     declaration: true,
     declarationDir: outDir,
     emitDeclarationOnly: true,
     noEmit: false,
     outDir
-  };
-  const rootDir = path.relative(
-    cwd,
-    compilerOptions.rootDir ? path.resolve(cwd, compilerOptions.rootDir) : path.dirname(path.resolve(cwd, sourcePath))
-  ) || ".";
+  });
+
   const program = ts.createProgram(tsconfig.fileNames, compilerOptions);
-  const sourceFiles = program.getSourceFiles();
-  const sourceFile = sourceFiles.find((f) => f.fileName === path.resolve(cwd, sourcePath));
-  if (!sourceFile) {
-    throw new Error(`source file not found: ${sourcePath}`);
-  }
   const emitResult = program.emit();
   const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  allDiagnostics.forEach((diagnostic) => {
+  allDiagnostics.forEach(diagnostic => {
     if (diagnostic.file && diagnostic.start) {
-      const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const {
+        line,
+        character
+      } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
       const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      console.log(`${diagnostic.file.fileName} ${line + 1}:${character + 1}
-${message}`);
+      console.log("".concat(diagnostic.file.fileName, " ").concat(line + 1, ":").concat(character + 1, "\n").concat(message));
     } else {
       console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
     }
   });
+
   if (emitResult.emitSkipped) {
-    const errors = allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error);
+    const errors = allDiagnostics.filter(diag => diag.category === ts.DiagnosticCategory.Error);
+
     if (errors.length) {
       console.error(ts.formatDiagnostics(errors, formatHost));
       throw new Error("failed to compile");
     }
   }
-  const typesPath = path.resolve(outDir, path.relative(rootDir, path.resolve(cwd, sourcePath))).replace(/\.[jt]sx?$/, ".d.ts");
-  return { path: typesPath };
 }
 
 class _DtsError extends Error {
@@ -418,10 +438,19 @@ class _DtsError extends Error {
     super(message);
     this.messages = messages;
   }
+
 }
 
 function _createApiExtractorConfig(options) {
-  const { distPath, exportPath, filePath, messages, projectPath, sourcePath, tsconfigPath } = options;
+  const {
+    distPath,
+    exportPath,
+    filePath,
+    messages,
+    projectPath,
+    sourcePath,
+    tsconfigPath
+  } = options;
   return {
     apiReport: {
       enabled: false,
@@ -432,7 +461,7 @@ function _createApiExtractorConfig(options) {
     },
     docModel: {
       enabled: false,
-      apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`)
+      apiJsonFilePath: path.resolve(distPath, "".concat(exportPath, ".api.json"))
     },
     dtsRollup: {
       enabled: true,
@@ -448,31 +477,33 @@ function _createApiExtractorConfig(options) {
 }
 
 async function _createTSDocConfig(opts) {
-  const { customTags } = opts;
+  const {
+    customTags
+  } = opts;
+
   if (customTags.length === 0) {
     return void 0;
   }
-  const tsDocBaseBuf = await readFile(
-    require.resolve("@microsoft/api-extractor/extends/tsdoc-base.json")
-  );
+
+  const tsDocBaseBuf = await readFile(require.resolve("@microsoft/api-extractor/extends/tsdoc-base.json"));
   const tsDocBaseConfig = parse(tsDocBaseBuf.toString());
-  const tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
-    customTags.map((t) => ({
-      tagName: `@${t.name}`,
-      syntaxKind: t.syntaxKind,
-      allowMultiple: t.allowMultiple
-    }))
-  );
-  const supportForTags = { ...tsDocBaseConfig.supportForTags };
+  const tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(customTags.map(t => ({
+    tagName: "@".concat(t.name),
+    syntaxKind: t.syntaxKind,
+    allowMultiple: t.allowMultiple
+  })));
+
+  const supportForTags = _objectSpread({}, tsDocBaseConfig.supportForTags);
+
   for (const customTag of customTags) {
-    supportForTags[`@${customTag.name}`] = true;
+    supportForTags["@".concat(customTag.name)] = true;
   }
-  return TSDocConfigFile.loadFromObject({
-    ...tsDocBaseConfig,
+
+  return TSDocConfigFile.loadFromObject(_objectSpread(_objectSpread({}, tsDocBaseConfig), {}, {
     noStandardTags: false,
     tagDefinitions,
     supportForTags
-  });
+  }));
 }
 
 const _LOG_LEVELS = {
@@ -481,15 +512,27 @@ const _LOG_LEVELS = {
   off: "none",
   warn: "warning"
 };
+
 async function _extractTypes(options) {
-  const { distPath, exportPath, files, filePath, projectPath, rules, sourcePath, tsconfigPath } = options;
+  const {
+    distPath,
+    exportPath,
+    files,
+    filePath,
+    projectPath,
+    rules,
+    sourcePath,
+    tsconfigPath
+  } = options;
   const tsdocConfigFile = await _createTSDocConfig({
     customTags: []
   });
+
   function _ruleToLogLevel(key, defaultLevel) {
     const r = rules == null ? void 0 : rules[key];
     return r ? _LOG_LEVELS[r] : defaultLevel || "warning";
   }
+
   const messagesConfig = {
     compilerMessageReporting: {
       default: {
@@ -547,79 +590,91 @@ async function _extractTypes(options) {
   const extractorResult = Extractor.invoke(extractorConfig, {
     localBuild: true,
     showVerboseMessages: true,
+
     messageCallback(message) {
       messages.push(message);
       message.handled = true;
     }
+
   });
   const typesPath = path.resolve(distPath, filePath);
   const typesBuf = await fs.readFile(typesPath);
   const prettierConfig = await prettier.resolveConfig(typesPath);
   await mkdirp(path.dirname(typesPath));
-  await fs.writeFile(
-    typesPath,
-    prettier.format(typesBuf.toString(), {
-      ...prettierConfig,
-      filepath: typesPath
-    })
-  );
+  await fs.writeFile(typesPath, prettier.format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
+    filepath: typesPath
+  })));
   files.push({
     type: "types",
     path: typesPath
   });
-  return { extractorResult, messages };
+  return {
+    extractorResult,
+    messages
+  };
 }
 
-const rimraf = promisify(rimrafCallback);
 async function _doExtract(ctx, task) {
   var _a;
-  const { config, cwd, dist, files, ts } = ctx;
-  if (!ts.config || !ts.configPath)
-    return { type: "dts", messages: [] };
-  const sourcePath = task.sourcePath;
-  const exportPath = task.exportPath === "." ? "./index" : task.exportPath;
-  const distPath = path.resolve(cwd, dist);
-  const filePath = path.relative(distPath, path.resolve(cwd, task.targetPath));
-  const tmpDirPath = path.resolve(distPath, "__dts__");
-  const tmpDir = {
-    path: tmpDirPath,
-    removeCallback: () => rimraf(tmpDirPath)
+
+  const {
+    config,
+    cwd,
+    dist,
+    files,
+    ts
+  } = ctx;
+  if (!ts.config || !ts.configPath) return {
+    type: "dts",
+    messages: []
   };
-  const types = await _buildTypes({
+  const distPath = path.resolve(cwd, dist);
+  const {
+    outDir = distPath,
+    rootDir = cwd
+  } = ts.config.options;
+  await _buildTypes({
     cwd,
-    outDir: tmpDir.path,
-    sourcePath,
+    outDir,
     tsconfig: ts.config
   });
-  const { messages } = await _extractTypes({
-    cwd,
-    exportPath,
-    files,
-    filePath,
-    projectPath: cwd,
-    rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
-    sourcePath: types.path,
-    tsconfigPath: path.resolve(cwd, ts.configPath),
-    distPath
-  });
-  await tmpDir.removeCallback();
-  if (messages.some((msg) => msg.logLevel === "error")) {
-    throw new _DtsError("encountered errors when extracting types", messages);
+  const messages = [];
+
+  for (const entry of task.entries) {
+    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath;
+    const filePath = path.relative(distPath, path.resolve(cwd, entry.targetPath));
+    const result = await _extractTypes({
+      cwd,
+      exportPath,
+      files,
+      filePath,
+      projectPath: cwd,
+      rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
+      sourcePath: path.resolve(outDir, path.relative(cwd, rootDir), entry.sourcePath.replace(/\.ts$/, ".d.ts")),
+      tsconfigPath: path.resolve(cwd, ts.configPath),
+      distPath
+    });
+    messages.push(...result.messages);
+
+    if (result.messages.some(msg => msg.logLevel === "error")) {
+      throw new _DtsError("encountered errors when extracting types", result.messages);
+    }
   }
-  return { type: "dts", messages };
+
+  return {
+    type: "dts",
+    messages
+  };
 }
 
 const _dtsTask = {
-  name: (_ctx, task) => [
-    `build type definitions`,
-    `       ${chalk.blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
-  ].join("\n"),
+  name: (_ctx, task) => ["build type definitions", ...task.entries.map(entry => "       ".concat(chalk.blue(entry.importId), ": ").concat(entry.sourcePath, " -> ").concat(entry.targetPath))].join("\n"),
   exec: (ctx, task) => {
-    return new Observable((observer) => {
-      _doExtract(ctx, task).then((result) => {
+    return new Observable(observer => {
+      _doExtract(ctx, task).then(result => {
         observer.next(result);
         observer.complete();
-      }).catch((err) => {
+      }).catch(err => {
         observer.error(err);
       });
     });
@@ -628,7 +683,10 @@ const _dtsTask = {
     _printExtractMessages(ctx, result.messages);
   },
   error: (ctx, _task, err) => {
-    const { logger } = ctx;
+    const {
+      logger
+    } = ctx;
+
     if (err instanceof _DtsError) {
       _printExtractMessages(ctx, err.messages);
     } else if (err instanceof Error) {
@@ -636,28 +694,31 @@ const _dtsTask = {
     }
   }
 };
-
 const _dtsWatchTask = {
-  name: (_ctx, task) => [
-    `build type definitions`,
-    `       ${chalk.blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
-  ].join("\n"),
+  name: (_ctx, task) => ["build type definitions", ...task.entries.map(entry => "       ".concat(chalk.blue(entry.importId), ": ").concat(entry.sourcePath, " -> ").concat(entry.targetPath))].join("\n"),
   exec: (ctx, task) => {
-    return new Observable((observer) => {
-      _doExtract(ctx, task).then((result) => {
+    return new Observable(observer => {
+      _doExtract(ctx, task).then(result => {
         observer.next(result);
         observer.complete();
-      }).catch((err) => observer.error(err));
+      }).catch(err => observer.error(err));
     });
   },
   complete: (ctx, _task, result) => {
-    const { logger } = ctx;
+    const {
+      logger
+    } = ctx;
+
     _printExtractMessages(ctx, result.messages);
+
     logger.warn("watching typescript definitions is currently not supported");
     logger.log();
   },
   error: (ctx, _task, err) => {
-    const { logger } = ctx;
+    const {
+      logger
+    } = ctx;
+
     if (err instanceof _DtsError) {
       _printExtractMessages(ctx, err.messages);
     } else if (err instanceof Error) {
@@ -667,124 +728,184 @@ const _dtsWatchTask = {
 };
 
 function _resolveRollupConfig(ctx, buildTask) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const { format, runtime, target } = buildTask;
-  const { config, cwd, external, dist: outDir, pkg, ts } = ctx;
-  const outputExt = format === "commonjs" ? ".cjs" : pkg.type === "module" ? ".mjs" : ".js";
-  const pathAliases = Object.fromEntries(
-    Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(([key, val]) => {
-      var _a2;
-      return [key, path.resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
-    })
-  );
-  const entries = buildTask.entries.map((entry) => {
-    return {
-      ...entry,
+  var _ref2, _ref4, _ref5, _ref6, _ref7, _ref8;
+
+  var _a;
+
+  const {
+    format,
+    runtime,
+    target
+  } = buildTask;
+  const {
+    config,
+    cwd,
+    exports: _exports,
+    external,
+    dist: outDir,
+    logger,
+    pkg,
+    ts
+  } = ctx;
+  const outputExt = format === "commonjs" ? ".cjs" : ".js";
+  const minify = (_ref2 = config == null ? void 0 : config.minify) !== null && _ref2 !== void 0 ? _ref2 : true;
+  const pathAliases = Object.fromEntries(Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(_ref3 => {
+    let [key, val] = _ref3;
+
+    var _a2;
+
+    return [key, path.resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
+  }));
+  const entries = buildTask.entries.map(entry => {
+    return _objectSpread(_objectSpread({}, entry), {}, {
       name: path.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
-    };
+    });
   }, {});
+
+  const exportIds = _exports && Object.keys(_exports).map(exportPath => path.join(pkg.name, exportPath));
+
+  const sourcePaths = _exports && Object.values(_exports).map(e => path.resolve(cwd, e.source));
+
   return {
     inputOptions: {
       context: cwd,
-      external: (id) => {
+      external: (id, importer) => {
+        if (exportIds == null ? void 0 : exportIds.includes(id)) {
+          return true;
+        }
+
+        if (importer && (id.startsWith(".") || id.startsWith("/"))) {
+          const idPath = path.resolve(path.dirname(importer), id);
+
+          if (sourcePaths == null ? void 0 : sourcePaths.includes(idPath)) {
+            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path.relative(cwd, idPath)));
+            return true;
+          }
+        }
+
         const idParts = id.split("/");
-        const name = idParts[0].startsWith("@") ? `${idParts[0]}/${idParts[1]}` : idParts[0];
+        const name = idParts[0].startsWith("@") ? "".concat(idParts[0], "/").concat(idParts[1]) : idParts[0];
+
         if (name && external.includes(name)) {
           return true;
         }
+
         return false;
       },
       input: entries.reduce((acc, entry) => {
-        return { ...acc, [entry.name]: entry.source };
+        return _objectSpread(_objectSpread({}, acc), {}, {
+          [entry.name]: entry.source
+        });
       }, {}),
+
       onwarn(warning, rollupWarn) {
         if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
           rollupWarn(warning);
         }
       },
-      plugins: [
-        replace({
-          preventAssignment: true,
-          values: {
-            ...pkg.name === "@sanity/pkg-utils" ? {} : {
-              "process.env.PKG_FILE_PATH": (arg) => {
-                const sourcePath = "./" + path.relative(cwd, arg);
-                const entry = entries.find((e) => e.source === sourcePath);
-                if (!entry) {
-                  throw new Error(`could not find source entry: ${sourcePath}`);
-                }
-                return JSON.stringify(
-                  path.relative(cwd, path.resolve(outDir, entry.name + outputExt))
-                );
-              },
-              "process.env.PKG_FORMAT": JSON.stringify(format),
-              "process.env.PKG_RUNTIME": JSON.stringify(runtime),
-              "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version)
+
+      plugins: [replace({
+        preventAssignment: true,
+        values: _objectSpread({}, pkg.name === "@sanity/pkg-utils" ? {} : {
+          "process.env.PKG_FILE_PATH": arg => {
+            const sourcePath = "./" + path.relative(cwd, arg);
+            const entry = entries.find(e => e.source === sourcePath);
+
+            if (!entry) {
+              throw new Error("could not find source entry: ".concat(sourcePath));
             }
-          }
-        }),
-        alias({
-          entries: { ...pathAliases }
-        }),
-        nodeResolve({
-          browser: runtime === "browser",
-          extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
-          preferBuiltins: true
-        }),
-        commonjs({
-          esmExternals: false,
-          extensions: [".js"]
-        }),
-        json(),
-        esbuild({
-          minify: (_b = config == null ? void 0 : config.minify) != null ? _b : true,
-          jsx: (_c = config == null ? void 0 : config.jsx) != null ? _c : "automatic",
-          jsxFactory: (_d = config == null ? void 0 : config.jsxFactory) != null ? _d : "createElement",
-          jsxFragment: (_e = config == null ? void 0 : config.jsxFragment) != null ? _e : "Fragment",
-          jsxImportSource: (_f = config == null ? void 0 : config.jsxImportSource) != null ? _f : "react",
-          target,
-          tsconfig: ctx.ts.configPath || "tsconfig.json"
+
+            return JSON.stringify(path.relative(cwd, path.resolve(outDir, entry.name + outputExt)));
+          },
+          "process.env.PKG_FORMAT": JSON.stringify(format),
+          "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+          "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version)
         })
-      ],
+      }), alias({
+        entries: _objectSpread({}, pathAliases)
+      }), nodeResolve({
+        browser: runtime === "browser",
+        extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+        preferBuiltins: true
+      }), commonjs({
+        esmExternals: false,
+        extensions: [".js"]
+      }), json(), esbuild({
+        jsx: (_ref4 = config == null ? void 0 : config.jsx) !== null && _ref4 !== void 0 ? _ref4 : "automatic",
+        jsxFactory: (_ref5 = config == null ? void 0 : config.jsxFactory) !== null && _ref5 !== void 0 ? _ref5 : "createElement",
+        jsxFragment: (_ref6 = config == null ? void 0 : config.jsxFragment) !== null && _ref6 !== void 0 ? _ref6 : "Fragment",
+        jsxImportSource: (_ref7 = config == null ? void 0 : config.jsxImportSource) !== null && _ref7 !== void 0 ? _ref7 : "react",
+        target,
+        tsconfig: ctx.ts.configPath || "tsconfig.json"
+      }), getBabelOutputPlugin({
+        babelrc: false,
+        plugins: ["@babel/plugin-proposal-object-rest-spread"],
+        presets: [["@babel/preset-env", {
+          targets: pkg.browserslist || _DEFAULTS.browserslist
+        }]]
+      }), minify && terser({
+        output: {
+          comments: (_node, comment) => {
+            const text = comment.value;
+            const type = comment.type;
+
+            if (type == "comment2") {
+              return /@preserve|@license|@cc_on/i.test(text);
+            }
+
+            return false;
+          }
+        }
+      })].filter(Boolean),
       treeshake: {
         propertyReadSideEffects: false
       }
     },
     outputOptions: {
-      chunkFileNames: () => `_[name]-[hash]${outputExt}`,
+      chunkFileNames: () => "_[name]-[hash]".concat(outputExt),
       dir: outDir,
-      entryFileNames: () => `[name]${outputExt}`,
+      entryFileNames: () => "[name]".concat(outputExt),
       format,
       exports: "auto",
-      sourcemap: (_g = config == null ? void 0 : config.sourcemap) != null ? _g : true
+      sourcemap: (_ref8 = config == null ? void 0 : config.sourcemap) !== null && _ref8 !== void 0 ? _ref8 : true
     }
   };
 }
 
 const _rollupTask = {
-  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
-       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`,
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
   exec: (ctx, task) => {
-    return new Observable((observer) => {
-      _execPromise(ctx, task).then((result) => {
+    return new Observable(observer => {
+      _execPromise(ctx, task).then(result => {
         observer.next(result);
         observer.complete();
-      }).catch((err) => observer.error(err));
+      }).catch(err => observer.error(err));
     });
   },
-  complete: () => {
-  },
+  complete: () => {},
   error: (_ctx, _task, err) => {
     if (err instanceof Error) {
       console.log(err);
     }
   }
 };
+
 async function _execPromise(ctx, task) {
-  const { files, dist: outDir } = ctx;
-  const { inputOptions, outputOptions } = _resolveRollupConfig(ctx, task);
+  const {
+    files,
+    dist: outDir
+  } = ctx;
+
+  const {
+    inputOptions,
+    outputOptions
+  } = _resolveRollupConfig(ctx, task);
+
   const bundle = await rollup(inputOptions);
-  const { output } = await bundle.generate(outputOptions);
+  const {
+    output
+  } = await bundle.generate(outputOptions);
+
   for (const chunkOrAsset of output) {
     if (chunkOrAsset.type === "asset") {
       files.push({
@@ -798,22 +919,26 @@ async function _execPromise(ctx, task) {
       });
     }
   }
+
   await bundle.write(outputOptions);
   await bundle.close();
 }
 
 const _rollupWatchTask = {
-  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
-       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`,
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
   exec: (ctx, task) => {
-    const { inputOptions, outputOptions } = _resolveRollupConfig(ctx, task);
-    return new Observable((observer) => {
-      const watchOptions = {
-        ...inputOptions,
+    const {
+      inputOptions,
+      outputOptions
+    } = _resolveRollupConfig(ctx, task);
+
+    return new Observable(observer => {
+      const watchOptions = _objectSpread(_objectSpread({}, inputOptions), {}, {
         output: outputOptions
-      };
+      });
+
       const watcher = watch$1(watchOptions);
-      watcher.on("event", (event) => {
+      watcher.on("event", event => {
         observer.next(event);
       });
       return () => {
@@ -822,37 +947,43 @@ const _rollupWatchTask = {
     });
   },
   complete: (ctx, task, event) => {
-    const { logger } = ctx;
+    const {
+      logger
+    } = ctx;
+
     if (event.code === "BUNDLE_END") {
-      logger.success(
-        `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
-       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join("\n       ")}`
-      );
+      logger.success("build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk.blue(path.join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")));
       logger.log("");
       return;
     }
+
     if (event.code === "BUNDLE_START") {
       return;
     }
+
     if (event.code === "END") {
       return;
     }
+
     if (event.code === "ERROR") {
       logger.error(event.code, event);
       return;
     }
+
     if (event.code === "START") {
       return;
     }
   },
   error: (ctx, _task, err) => {
-    const { logger } = ctx;
+    const {
+      logger
+    } = ctx;
+
     if (err instanceof Error) {
       logger.log(err);
     }
   }
 };
-
 const _buildTaskHandlers = {
   "build:dts": _dtsTask,
   "build:js": _rollupTask
@@ -867,29 +998,33 @@ function _sortAsNumber(a, b) {
   const bVersion = Number(b);
   return aVersion - bVersion;
 }
+
 function _resolveBrowserslistVersions(query) {
   const result = browserslist(query);
-  const entries = result.map((key) => {
+  const entries = result.map(key => {
     const [name, version] = key.split(" ");
-    return { name, version: version.split("-")[0].split(".")[0] };
+    return {
+      name,
+      version: version.split("-")[0].split(".")[0]
+    };
   });
-  const andChr = entries.filter((b) => b.name === "and_chr");
-  const andFf = entries.filter((b) => b.name === "and_ff");
-  const chrome = entries.filter((b) => b.name === "chrome");
-  const edge = entries.filter((b) => b.name === "edge");
-  const ff = entries.filter((b) => b.name === "firefox");
-  const iosSaf = entries.filter((b) => b.name === "ios_saf");
-  const saf = entries.filter((b) => b.name === "safari");
-  const opera = entries.filter((b) => b.name === "opera");
-  const node = entries.filter((b) => b.name === "node");
+  const andChr = entries.filter(b => b.name === "and_chr");
+  const andFf = entries.filter(b => b.name === "and_ff");
+  const chrome = entries.filter(b => b.name === "chrome");
+  const edge = entries.filter(b => b.name === "edge");
+  const ff = entries.filter(b => b.name === "firefox");
+  const iosSaf = entries.filter(b => b.name === "ios_saf");
+  const saf = entries.filter(b => b.name === "safari");
+  const opera = entries.filter(b => b.name === "opera");
+  const node = entries.filter(b => b.name === "node");
   const versions = {
-    chrome: andChr.concat(chrome).map((b) => b.version),
-    ff: andFf.concat(ff).map((b) => b.version),
-    edge: edge.map((b) => b.version),
-    iosSaf: iosSaf.map((b) => b.version),
-    saf: saf.map((b) => b.version),
-    opera: opera.map((b) => b.version),
-    node: node.map((b) => b.version)
+    chrome: andChr.concat(chrome).map(b => b.version),
+    ff: andFf.concat(ff).map(b => b.version),
+    edge: edge.map(b => b.version),
+    iosSaf: iosSaf.map(b => b.version),
+    saf: saf.map(b => b.version),
+    opera: opera.map(b => b.version),
+    node: node.map(b => b.version)
   };
   versions.chrome.sort(_sortAsNumber);
   versions.ff.sort(_sortAsNumber);
@@ -903,71 +1038,108 @@ function _resolveBrowserslistVersions(query) {
 
 function _resolveBrowserTarget(versions) {
   const target = [];
+
   if (versions.chrome.length) {
-    target.push(`chrome${versions.chrome[0]}`);
+    target.push("chrome".concat(versions.chrome[0]));
   }
+
   if (versions.ff.length) {
-    target.push(`firefox${versions.ff[0]}`);
+    target.push("firefox".concat(versions.ff[0]));
   }
+
   if (versions.edge.length) {
-    target.push(`edge${versions.edge[0]}`);
+    target.push("edge".concat(versions.edge[0]));
   }
+
   if (versions.iosSaf.length) {
-    target.push(`ios${versions.iosSaf[0]}`);
+    target.push("ios".concat(versions.iosSaf[0]));
   }
+
   if (versions.saf.length) {
-    target.push(`safari${versions.saf[0]}`);
+    target.push("safari".concat(versions.saf[0]));
   }
+
   if (versions.opera.length) {
-    target.push(`opera${versions.opera[0]}`);
+    target.push("opera".concat(versions.opera[0]));
   }
+
   if (target.length === 0) {
     return void 0;
   }
+
   return target;
 }
 
 function _resolveNodeTarget(versions) {
   const target = [];
+
   if (versions.node.length) {
-    target.push(`node${versions.node[0]}`);
+    target.push("node".concat(versions.node[0]));
   }
+
   if (target.length === 0) {
     return void 0;
   }
+
   return target;
 }
 
 async function _resolveBuildContext(options) {
-  var _a;
-  const { config, cwd, pkg, tsconfig: tsconfigPath } = options;
-  const tsconfig = await _loadTSConfig({ cwd, tsconfigPath });
+  var _ref9;
+
+  const {
+    config,
+    cwd,
+    pkg,
+    tsconfig: tsconfigPath
+  } = options;
+  const tsconfig = await _loadTSConfig({
+    cwd,
+    tsconfigPath
+  });
+
   const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist);
+
   const srcPath = path.resolve(cwd, (config == null ? void 0 : config.src) || "src");
   const distPath = path.resolve(cwd, (config == null ? void 0 : config.dist) || "dist");
+
   const nodeTarget = _resolveNodeTarget(targetVersions);
+
   const webTarget = _resolveBrowserTarget(targetVersions);
+
   if (!nodeTarget) {
     throw new Error("no matching `node` target");
   }
+
   if (!webTarget) {
     throw new Error("no matching `web` target");
   }
+
   const target = {
     "*": webTarget.concat(nodeTarget),
     browser: webTarget,
     node: nodeTarget
   };
-  const parsedExports = _parseExports({ pkg }).reduce((acc, x) => {
-    const { _path: exportPath, ...exportEntry } = x;
-    return { ...acc, [exportPath]: exportEntry };
+
+  const parsedExports = _parseExports({
+    pkg
+  }).reduce((acc, x) => {
+    const {
+      _path: exportPath
+    } = x,
+          exportEntry = _objectWithoutProperties(x, _excluded);
+
+    return _objectSpread(_objectSpread({}, acc), {}, {
+      [exportPath]: exportEntry
+    });
   }, {});
+
   const exports = _resolveConfigProperty(config == null ? void 0 : config.exports, parsedExports);
-  const parsedExternal = [
-    ...pkg.dependencies ? Object.keys(pkg.dependencies) : [],
-    ...pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []
-  ];
+
+  const parsedExternal = [...(pkg.dependencies ? Object.keys(pkg.dependencies) : []), ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : [])];
+
   const external = _resolveConfigProperty(config == null ? void 0 : config.external, parsedExternal);
+
   const ctx = {
     config,
     cwd,
@@ -976,25 +1148,41 @@ async function _resolveBuildContext(options) {
     external,
     files: [],
     logger: {
-      log: (...args) => {
-        console.log(...args);
+      log: function () {
+        console.log(...arguments);
       },
-      info: (...args) => {
+      info: function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
         console.log(chalk.blue("  info"), ...args);
       },
-      warn: (...args) => {
+      warn: function () {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+
         console.log(chalk.yellow("  warn"), ...args);
       },
-      error: (...args) => {
+      error: function () {
+        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          args[_key3] = arguments[_key3];
+        }
+
         console.log(chalk.red("  fail"), ...args);
       },
-      success: (...args) => {
+      success: function () {
+        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+          args[_key4] = arguments[_key4];
+        }
+
         console.log(chalk.green("  ok  "), ...args);
       }
     },
     pkg,
     src: path.relative(cwd, srcPath),
-    runtime: (_a = config == null ? void 0 : config.runtime) != null ? _a : "*",
+    runtime: (_ref9 = config == null ? void 0 : config.runtime) !== null && _ref9 !== void 0 ? _ref9 : "*",
     target,
     ts: {
       config: tsconfig,
@@ -1006,27 +1194,43 @@ async function _resolveBuildContext(options) {
 
 function _spinner(msg) {
   const startTime = Date.now();
-  console.log(`${chalk.yellow("run   ")} ${msg}`);
+  console.log("".concat(chalk.yellow("run   "), " ").concat(msg));
   return {
     complete: () => {
-      console.log(`${chalk.green("ok    ")} ${chalk.gray(`${Date.now() - startTime}ms`)}`);
+      console.log("".concat(chalk.green("ok    "), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
     },
     error: () => {
-      console.log(`${chalk.red(`failed`)} ${chalk.gray(`${Date.now() - startTime}ms`)}`);
+      console.log("".concat(chalk.red("failed"), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
     }
   };
 }
 
 async function build(options) {
-  const { cwd, tsconfig = "tsconfig.json" } = options;
-  const pkg = await _loadPkgWithReporting({ cwd });
-  const config = await _loadConfig({ cwd });
-  const ctx = await _resolveBuildContext({ config, cwd, pkg, tsconfig });
+  const {
+    cwd,
+    tsconfig = "tsconfig.json"
+  } = options;
+  const pkg = await _loadPkgWithReporting({
+    cwd
+  });
+  const config = await _loadConfig({
+    cwd
+  });
+  const ctx = await _resolveBuildContext({
+    config,
+    cwd,
+    pkg,
+    tsconfig
+  });
+
   const buildTasks = _resolveBuildTasks(ctx);
+
   for (const task of buildTasks) {
     const handler = _buildTaskHandlers[task.type];
     const taskName = handler.name(ctx, task);
+
     const spinner = _spinner(taskName);
+
     try {
       const result = await handler.exec(ctx, task).toPromise();
       spinner.complete();
@@ -1034,11 +1238,13 @@ async function build(options) {
       handler.complete(ctx, task, result);
     } catch (err) {
       spinner.error();
+
       if (err instanceof Error) {
-        const RE_CWD = new RegExp(`${cwd}`, "g");
+        const RE_CWD = new RegExp("".concat(cwd), "g");
         ctx.logger.error(err.message.replace(RE_CWD, "."));
         ctx.logger.log();
       }
+
       handler.error(ctx, task, err);
       process.exit(1);
     }
@@ -1058,93 +1264,131 @@ function _fileExists(file) {
     return false;
   }
 }
+
 function _getFileInfo(cwd, filePath) {
   const p = path.resolve(cwd, filePath);
+
   const exists = _fileExists(p);
+
   const size = exists ? _getFilesize(p) : void 0;
-  return { exists, size };
+  return {
+    exists,
+    size
+  };
 }
+
 function _printPackageTree(ctx) {
-  const { cwd, exports, logger, pkg } = ctx;
-  if (!exports)
-    return;
-  logger.log(`${chalk.blue(pkg.name)}@${chalk.green(pkg.version)}`);
+  const {
+    cwd,
+    exports,
+    logger,
+    pkg
+  } = ctx;
+  if (!exports) return;
+  logger.log("".concat(chalk.blue(pkg.name), "@").concat(chalk.green(pkg.version)));
   const tree = {};
+
   if (pkg.bin) {
     tree.bin = pkg.bin;
   }
+
   function _fileInfo(file) {
     const info = _getFileInfo(cwd, file);
+
     if (!info.size) {
-      return `${chalk.gray(file)} ${chalk.red("does not exist")}`;
+      return "".concat(chalk.gray(file), " ").concat(chalk.red("does not exist"));
     }
-    return `${file} ${chalk.gray(info.size)}`;
+
+    return "".concat(file, " ").concat(chalk.gray(info.size));
   }
-  tree.exports = Object.fromEntries(
-    Object.entries(exports).filter(([, entry]) => entry._exported).map(([exportPath, entry]) => {
-      const exp = { source: entry.source, default: entry.default };
-      if (entry.browser) {
-        exp.browser = {};
-        if (entry.browser.import)
-          exp.browser.import = _fileInfo(entry.browser.import);
-        if (entry.browser.require)
-          exp.browser.import = _fileInfo(entry.browser.require);
-      }
-      if (entry.import)
-        exp.import = _fileInfo(entry.import);
-      if (entry.require)
-        exp.require = _fileInfo(entry.require);
-      if (entry.types)
-        exp.types = _fileInfo(entry.types);
-      exp.default = _fileInfo(entry.default);
-      return [chalk.green(path.join(pkg.name, exportPath)), exp];
-    })
-  );
+
+  tree.exports = Object.fromEntries(Object.entries(exports).filter(_ref10 => {
+    let [, entry] = _ref10;
+    return entry._exported;
+  }).map(_ref11 => {
+    let [exportPath, entry] = _ref11;
+    const exp = {
+      source: entry.source,
+      default: entry.default
+    };
+
+    if (entry.browser) {
+      exp.browser = {};
+      if (entry.browser.import) exp.browser.import = _fileInfo(entry.browser.import);
+      if (entry.browser.require) exp.browser.import = _fileInfo(entry.browser.require);
+    }
+
+    if (entry.import) exp.import = _fileInfo(entry.import);
+    if (entry.require) exp.require = _fileInfo(entry.require);
+    if (entry.types) exp.types = _fileInfo(entry.types);
+    exp.default = _fileInfo(entry.default);
+    return [chalk.green(path.join(pkg.name, exportPath)), exp];
+  }));
   logger.log(treeify.asTree(tree, true, true));
 }
 
 async function check(options) {
-  const { cwd, strict, tsconfig = "tsconfig.json" } = options;
-  const pkg = await _loadPkgWithReporting({ cwd });
-  const config = await _loadConfig({ cwd });
-  const ctx = await _resolveBuildContext({ config, cwd, pkg, tsconfig });
+  const {
+    cwd,
+    strict,
+    tsconfig = "tsconfig.json"
+  } = options;
+  const pkg = await _loadPkgWithReporting({
+    cwd
+  });
+  const config = await _loadConfig({
+    cwd
+  });
+  const ctx = await _resolveBuildContext({
+    config,
+    cwd,
+    pkg,
+    tsconfig
+  });
+
   _printPackageTree(ctx);
+
   if (strict) {
     const missingFiles = [];
+
     for (const [, exp] of Object.entries(ctx.exports || {})) {
       if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
         missingFiles.push(exp.source);
       }
+
       if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
         missingFiles.push(exp.require);
       }
+
       if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
         missingFiles.push(exp.import);
       }
+
       if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
         missingFiles.push(exp.types);
       }
     }
+
     if (missingFiles.length) {
       throw new Error("missing files");
     }
+
     const _paths = {
       require: [],
       import: []
     };
+
     for (const [exportPath, exp] of Object.entries(ctx.exports || {})) {
-      if (!exp._exported)
-        continue;
-      if (exp.require)
-        _paths.require.push(exportPath);
-      if (exp.import)
-        _paths.import.push(exportPath);
+      if (!exp._exported) continue;
+      if (exp.require) _paths.require.push(exportPath);
+      if (exp.import) _paths.import.push(exportPath);
     }
-    const external = Object.keys(pkg.dependencies || {}).concat(
-      Object.keys(pkg.devDependencies || {})
-    );
+
+    const external = Object.keys(pkg.dependencies || {}).concat(Object.keys(pkg.devDependencies || {}));
+
     if (_paths.import.length) {
-      const code = _paths.import.map((id) => `import('${id}')`).join("\n");
+      const code = _paths.import.map(id => "import('".concat(id, "')")).join("\n");
+
       try {
         const esbuildResult = await esbuild$1.build({
           external,
@@ -1159,29 +1403,34 @@ async function check(options) {
           outfile: "/dev/null",
           platform: "node"
         });
+
         if (esbuildResult.warnings.length > 0) {
           console.warn(...esbuildResult.warnings);
         }
       } catch (err) {
-        const { errors } = err;
+        const {
+          errors
+        } = err;
+
         for (const _err of errors) {
           if (_err.location) {
             console.log(chalk.red("error"), _err.detail || _err.text);
-            console.log(`${_err.location.line} | ${_err.location.lineText}`);
-            console.log(
-              "in",
-              `./${_err.location.file}:${_err.location.line}:${_err.location.column}`
-            );
+            console.log("".concat(_err.location.line, " | ").concat(_err.location.lineText));
+            console.log("in", "./".concat(_err.location.file, ":").concat(_err.location.line, ":").concat(_err.location.column));
           } else {
             console.log(_err.detail || _err.text);
           }
+
           console.log();
         }
+
         process.exit(1);
       }
     }
+
     if (_paths.require.length) {
-      const code = _paths.require.map((id) => `require('${id}')`).join("\n");
+      const code = _paths.require.map(id => "require('".concat(id, "')")).join("\n");
+
       const esbuildResult = await esbuild$1.build({
         external,
         stdin: {
@@ -1194,9 +1443,11 @@ async function check(options) {
         outfile: "/dev/null",
         platform: "node"
       });
+
       if (esbuildResult.errors.length > 0) {
         throw new Error(esbuildResult.errors.join(", "));
       }
+
       if (esbuildResult.warnings.length > 0) {
         console.warn(...esbuildResult.warnings);
       }
@@ -1206,102 +1457,115 @@ async function check(options) {
 
 function _resolveWatchTasks(ctx) {
   var _a, _b, _c, _d, _e;
-  const { cwd, pkg, target } = ctx;
-  const esTarget = _resolveEsTarget(ctx);
+
+  const {
+    cwd,
+    pkg,
+    target
+  } = ctx;
   const tasks = [];
-  const exports = Object.entries(ctx.exports || {}).map(
-    ([_path, exp]) => ({ _path, ...exp })
-  );
-  const dtsTasks = {};
+  const exports = Object.entries(ctx.exports || {}).map(_ref12 => {
+    let [_path, exp] = _ref12;
+    return _objectSpread({
+      _path
+    }, exp);
+  });
+  const dtsTask = {
+    type: "watch:dts",
+    entries: []
+  };
   const rollupTasks = {};
+
   function _addRollupTaskEntry(format, runtime, entry) {
-    const buildId = `${format}:${runtime}`;
-    if (!rollupTasks[buildId]) {
+    const buildId = "".concat(format, ":").concat(runtime);
+
+    if (rollupTasks[buildId]) {
+      rollupTasks[buildId].entries.push(entry);
+    } else {
       rollupTasks[buildId] = {
         type: "watch:js",
         buildId,
         entries: [entry],
         runtime,
         format,
-        target: [esTarget].concat(target[runtime])
+        target: target[runtime]
       };
-    } else {
-      rollupTasks[buildId].entries.push(entry);
     }
   }
+
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path);
+
     if (exp.types) {
-      if (!dtsTasks[importId]) {
-        dtsTasks[importId] = {
-          type: "watch:dts",
-          importId,
-          exportPath: exp._path,
-          sourcePath: exp.source,
-          targetPath: exp.types
-        };
-      }
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPath: exp.types
+      });
     }
   }
+
   for (const exp of exports) {
     const output = exp.require;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("commonjs", ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = (_a = exp.browser) == null ? void 0 : _a.require;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("commonjs", "browser", {
       path: exp._path,
       source: ((_b = exp.browser) == null ? void 0 : _b.source) || exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = exp.import;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("esm", ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output
     });
   }
+
   for (const exp of exports) {
     const output = (_c = exp.browser) == null ? void 0 : _c.import;
-    if (!output)
-      continue;
+    if (!output) continue;
+
     _addRollupTaskEntry("esm", "browser", {
       path: exp._path,
       source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
       output
     });
   }
-  tasks.push(...Object.values(dtsTasks));
+
+  if (dtsTask.entries.length) {
+    tasks.push(dtsTask);
+  }
+
   tasks.push(...Object.values(rollupTasks));
+
   for (const exp of exports) {
     if (exp._exported && exp._path !== ".") {
       const relativeTargetPath = (((_e = exp.browser) == null ? void 0 : _e.import) || exp.import || "").replace(/\.[^/.]+$/, "");
+
       if (relativeTargetPath) {
-        fs$1.writeFileSync(
-          path.resolve(cwd, `${exp._path}.js`),
-          [
-            `// AUTO-GENERATED \u2013 DO NOT EDIT`,
-            ``,
-            `export {default} from '${relativeTargetPath}'`,
-            `export * from '${relativeTargetPath}'`,
-            ``
-          ].join("\n")
-        );
+        fs$1.writeFileSync(path.resolve(cwd, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
       }
     }
   }
+
   return tasks;
 }
 
@@ -1310,13 +1574,18 @@ function _globFiles(patterns) {
 }
 
 function _watchFiles(patterns) {
-  return new Observable((observer) => {
+  return new Observable(observer => {
     const watcher = chokidar.watch(patterns, {
       ignoreInitial: true
     });
+
     function _handleFileEvent(type, file) {
-      observer.next({ type, file });
+      observer.next({
+        type,
+        file
+      });
     }
+
     watcher.on("all", _handleFileEvent);
     return () => {
       watcher.off("all", _handleFileEvent);
@@ -1326,69 +1595,76 @@ function _watchFiles(patterns) {
 }
 
 async function _watchConfigFiles(options) {
-  const { cwd } = options;
-  const initialFiles = await _globFiles([
-    path.resolve(cwd, "package.json"),
-    path.resolve(cwd, "package.config.cjs"),
-    path.resolve(cwd, "package.config.js"),
-    path.resolve(cwd, "package.config.ts")
-  ]);
-  const fileEvent$ = _watchFiles([
-    path.resolve(cwd, "package.json"),
-    path.resolve(cwd, "package.config.cjs"),
-    path.resolve(cwd, "package.config.js"),
-    path.resolve(cwd, "package.config.ts")
-  ]);
-  return fileEvent$.pipe(
-    scan((files, fileEvent) => {
-      if (fileEvent.type === "add") {
-        return files.concat(fileEvent.file);
-      }
-      if (fileEvent.type === "unlink") {
-        return files.filter((f) => f !== fileEvent.file);
-      }
-      if (fileEvent.type === "change") {
-        console.log(
-          "--------------------------------------------------------------------------------"
-        );
-        console.log(chalk.blue("info  "), path.relative(cwd, fileEvent.file), "changed");
-        console.log("");
-        return files.slice(0);
-      }
-      return files;
-    }, initialFiles),
-    startWith(initialFiles),
-    distinctUntilChanged()
-  );
+  const {
+    cwd
+  } = options;
+  const initialFiles = await _globFiles([path.resolve(cwd, "package.json"), path.resolve(cwd, "package.config.cjs"), path.resolve(cwd, "package.config.js"), path.resolve(cwd, "package.config.ts")]);
+
+  const fileEvent$ = _watchFiles([path.resolve(cwd, "package.json"), path.resolve(cwd, "package.config.cjs"), path.resolve(cwd, "package.config.js"), path.resolve(cwd, "package.config.ts")]);
+
+  return fileEvent$.pipe(scan((files, fileEvent) => {
+    if (fileEvent.type === "add") {
+      return files.concat(fileEvent.file);
+    }
+
+    if (fileEvent.type === "unlink") {
+      return files.filter(f => f !== fileEvent.file);
+    }
+
+    if (fileEvent.type === "change") {
+      console.log("--------------------------------------------------------------------------------");
+      console.log(chalk.blue("info  "), path.relative(cwd, fileEvent.file), "changed");
+      console.log("");
+      return files.slice(0);
+    }
+
+    return files;
+  }, initialFiles), startWith(initialFiles), distinctUntilChanged());
 }
 
 async function watch(options) {
-  const { cwd, tsconfig = "tsconfig.json" } = options;
-  const configFiles$ = await _watchConfigFiles({ cwd });
-  const ctx$ = configFiles$.pipe(
-    switchMap(async (configFiles) => {
-      const _files = configFiles.map((f) => path.relative(cwd, f));
-      const packageJsonPath = _files.find((f) => f === "package.json");
-      if (!packageJsonPath) {
-        throw new Error("missing package.json");
-      }
-      const pkg = await _loadPkgWithReporting({ cwd });
-      const config = await _loadConfig({ cwd });
-      return _resolveBuildContext({ config, cwd, pkg, tsconfig });
-    })
-  );
-  ctx$.subscribe(async (ctx) => {
+  const {
+    cwd,
+    tsconfig = "tsconfig.json"
+  } = options;
+  const configFiles$ = await _watchConfigFiles({
+    cwd
+  });
+  const ctx$ = configFiles$.pipe(switchMap(async configFiles => {
+    const _files = configFiles.map(f => path.relative(cwd, f));
+
+    const packageJsonPath = _files.find(f => f === "package.json");
+
+    if (!packageJsonPath) {
+      throw new Error("missing package.json");
+    }
+
+    const pkg = await _loadPkgWithReporting({
+      cwd
+    });
+    const config = await _loadConfig({
+      cwd
+    });
+    return _resolveBuildContext({
+      config,
+      cwd,
+      pkg,
+      tsconfig
+    });
+  }));
+  ctx$.subscribe(async ctx => {
     const watchTasks = _resolveWatchTasks(ctx);
+
     for (const task of watchTasks) {
       const handler = _watchTaskHandlers[task.type];
       const result$ = handler.exec(ctx, task);
       result$.subscribe({
-        error: (err) => {
+        error: err => {
           ctx.logger.error(err);
           ctx.logger.log();
           process.exit(1);
         },
-        next: (result) => {
+        next: result => {
           handler.complete(ctx, task, result);
         },
         complete: () => {