@sanity/pkg-utils 1.20.4 → 2.0.0-beta.2

package/dist/index.js

@@ -1,70 +1,1821 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-var resolveBuildContext = require('./_chunks/resolveBuildContext-904acf0f.js');
-var build = require('./_chunks/build-f3246aa2.js');
-var index = require('./_chunks/index-b617f475.js');
-var check = require('./_chunks/check-6c4e87a9.js');
-var watch = require('./_chunks/watch-15eb636a.js');
-require('path');
-require('esbuild-register/dist/node');
-require('pkg-up');
-require('fs/promises');
-require('find-config');
-require('chalk');
-require('zod');
-require('typescript');
-require('browserslist');
-require('fs');
-require('rxjs');
-require('util');
-require('rimraf');
-require('@microsoft/api-extractor');
-require('mkdirp');
-require('prettier');
-require('@microsoft/tsdoc-config');
-require('jsonc-parser');
-require('recast');
-require('recast/parsers/typescript');
-require('rollup');
-require('@rollup/plugin-alias');
-require('@rollup/plugin-babel');
-require('@rollup/plugin-commonjs');
-require('@rollup/plugin-json');
-require('@rollup/plugin-node-resolve');
-require('@rollup/plugin-replace');
-require('@rollup/plugin-terser');
-require('rollup-plugin-esbuild');
-require('esbuild');
-require('treeify');
-require('pretty-bytes');
-require('rxjs/operators');
-require('globby');
-require('chokidar');
+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) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import path from 'path';
+import { register } from 'esbuild-register/dist/node';
+import pkgUp from 'pkg-up';
+import fs, { stat, readFile } from 'fs/promises';
+import findConfig from 'find-config';
+import { z, ZodError } from 'zod';
+import chalk from 'chalk';
+import ts from 'typescript';
+import browserslist from 'browserslist';
+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';
+import { TSDocConfigFile } from '@microsoft/tsdoc-config';
+import { parse } from 'jsonc-parser';
+import { parse as parse$1, print } from 'recast';
+import typeScriptParser from 'recast/parsers/typescript';
+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 terser from '@rollup/plugin-terser';
+import esbuild from 'rollup-plugin-esbuild';
+import esbuild$1 from 'esbuild';
+import treeify from 'treeify';
+import prettyBytes from 'pretty-bytes';
+import { scan, startWith, distinctUntilChanged } from 'rxjs/operators';
+import globby from 'globby';
+import chokidar from 'chokidar';
+const MODULE_EXT = {
+  commonjs: {
+    commonjs: ".js",
+    esm: ".mjs"
+  },
+  module: {
+    commonjs: ".cjs",
+    esm: ".js"
+  }
+};
+const DEFAULT_BROWSERSLIST_QUERY = ["> 0.2% and supports es6-module and supports es6-module-dynamic-import", "not dead", "not IE 11", "maintained node versions"];
+function isRecord(value) {
+  return Boolean(value) && !Array.isArray(value) && typeof value === "object";
+}
+const CONFIG_FILE_NAMES = ["package.config.ts", "package.config.js", "package.config.cjs", "package.config.mjs"];
+async function findConfigFile(cwd) {
+  const pkgJsonPath = findConfig("package.json", {
+    cwd
+  });
+  if (!pkgJsonPath) return void 0;
+  const pkgPath = path.dirname(pkgJsonPath);
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = path.resolve(pkgPath, fileName);
+    const exists = await fileExists$1(configPath);
+    if (exists) {
+      return configPath;
+    }
+  }
+  return void 0;
+}
+async function fileExists$1(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+async function loadConfig(options) {
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp({
+    cwd
+  });
+  if (!pkgPath) return void 0;
+  const root = path.dirname(pkgPath);
+  const configFile = await findConfigFile(root);
+  if (!configFile) {
+    return void 0;
+  }
+  if (!configFile.startsWith(cwd)) {
+    return void 0;
+  }
+  const esbuildOptions = {
+    extensions: [".js", ".mjs", ".ts"]
+  };
+  const {
+    unregister
+  } = globalThis.__DEV__ ? {
+    unregister: () => void 0
+  } : register(esbuildOptions);
+  const mod = require(configFile);
+  unregister();
+  return (mod == null ? void 0 : mod.default) || mod || void 0;
+}
+function resolveConfigProperty(prop, initialValue) {
+  if (!prop) return initialValue;
+  if (typeof prop === "function") {
+    return prop(initialValue);
+  }
+  return prop;
+}
 function defineConfig(configOptions) {
   return configOptions;
 }
-exports.DEFAULT_BROWSERSLIST_QUERY = resolveBuildContext.DEFAULT_BROWSERSLIST_QUERY;
-exports.MODULE_EXT = resolveBuildContext.MODULE_EXT;
-exports.isRecord = resolveBuildContext.isRecord;
-exports.loadConfig = resolveBuildContext.loadConfig;
-exports.loadPkg = resolveBuildContext.loadPkg;
-exports.loadPkgWithReporting = resolveBuildContext.loadPkgWithReporting;
-exports.loadTSConfig = resolveBuildContext.loadTSConfig;
-exports.parseExports = resolveBuildContext.parseExports;
-exports.resolveConfigProperty = resolveBuildContext.resolveConfigProperty;
-exports.build = build.build;
-exports.resolveBuildTasks = build.resolveBuildTasks;
-exports.buildTaskHandlers = index.buildTaskHandlers;
-exports.dtsTask = index.dtsTask;
-exports.dtsWatchTask = index.dtsWatchTask;
-exports.getExtractMessagesConfig = index.getExtractMessagesConfig;
-exports.rollupTask = index.rollupTask;
-exports.rollupWatchTask = index.rollupWatchTask;
-exports.watchTaskHandlers = index.watchTaskHandlers;
-exports.check = check.check;
-exports.watch = watch.watch;
-exports.defineConfig = defineConfig;
+const pkgSchema = z.object({
+  type: z.enum(["commonjs", "module"]),
+  name: z.string(),
+  version: z.string(),
+  license: z.string(),
+  bin: z.optional(z.record(z.string())),
+  dependencies: z.optional(z.record(z.string())),
+  devDependencies: z.optional(z.record(z.string())),
+  peerDependencies: z.optional(z.record(z.string())),
+  source: z.optional(z.string()),
+  main: z.optional(z.string()),
+  browser: z.optional(z.record(z.string())),
+  module: z.optional(z.string()),
+  types: z.optional(z.string()),
+  exports: z.optional(z.record(z.union([z.custom(val => /^\.\/.*\.json$/.test(val)), z.object({
+    types: z.optional(z.string()),
+    source: z.string(),
+    browser: z.optional(z.object({
+      source: z.string(),
+      require: z.optional(z.string()),
+      import: z.optional(z.string())
+    })),
+    node: z.optional(z.object({
+      source: z.string(),
+      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()))
+});
+function validatePkg(input) {
+  const pkg = pkgSchema.parse(input);
+  return _objectSpread(_objectSpread({}, pkg), {}, {
+    type: pkg.type || "commonjs"
+  });
+}
+async function loadPkg(options) {
+  const {
+    cwd
+  } = options;
+  const pkgPath = await pkgUp({
+    cwd
+  });
+  if (!pkgPath) throw new Error("no package.json found");
+  const buf = await fs.readFile(pkgPath);
+  return validatePkg(JSON.parse(buf.toString()));
+}
+async function loadPkgWithReporting(options) {
+  const {
+    cwd,
+    logger
+  } = options;
+  try {
+    return await loadPkg({
+      cwd
+    });
+  } catch (err) {
+    if (err instanceof ZodError) {
+      for (const issue of err.issues) {
+        if (issue.code === "invalid_type") {
+          logger.error(["`".concat(formatPath(issue.path), "` "), "in `./package.json` must be of type ".concat(chalk.magenta(issue.expected), " "), "(received ".concat(chalk.magenta(issue.received), ")")].join(""));
+        }
+      }
+    } else {
+      logger.error(err);
+    }
+    process.exit(1);
+  }
+}
+function formatPath(segments) {
+  return segments.map((s, idx) => {
+    if (idx === 0) return s;
+    if (typeof s === "number") {
+      return "[".concat(s, "]");
+    }
+    if (s.startsWith(".")) {
+      return "[\"".concat(s, "\"]");
+    }
+    return ".".concat(s);
+  }).join("");
+}
+function validateExports(_exports, options) {
+  const {
+    pkg
+  } = options;
+  const ext = MODULE_EXT[pkg.type];
+  const errors = [];
+  for (const exp of _exports) {
+    if (exp.require && !exp.require.endsWith(ext.commonjs)) {
+      errors.push("package.json with `type: \"".concat(pkg.type, "\"` - `exports[\"").concat(exp._path, "\"].require` must end with \"").concat(ext.commonjs, "\""));
+    }
+    if (exp.import && !exp.import.endsWith(ext.esm)) {
+      errors.push("package.json with `type: \"".concat(pkg.type, "\"` - `exports[\"").concat(exp._path, "\"].import` must end with \"").concat(ext.esm, "\""));
+    }
+  }
+  return errors;
+}
+function parseExports(options) {
+  const {
+    pkg,
+    strict
+  } = options;
+  const rootExport = {
+    _exported: true,
+    _path: ".",
+    types: pkg.types,
+    source: pkg.source || "",
+    browser: pkg.browser && {
+      source: pkg.source || "",
+      require: pkg.main && pkg.browser[pkg.main],
+      import: pkg.module && pkg.browser[pkg.module]
+    },
+    import: pkg.module,
+    require: pkg.main,
+    default: pkg.module || pkg.main || ""
+  };
+  const extraExports = [];
+  const errors = [];
+  if (pkg.exports) {
+    if (strict && !pkg.exports["./package.json"]) {
+      errors.push('package.json: `exports["./package.json"] must be declared.');
+    }
+    for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
+      if (exportPath.endsWith(".json")) {
+        if (exportPath === "./package.json") {
+          if (exportEntry !== "./package.json") {
+            errors.push('package.json: `exports["./package.json"] must be "./package.json".');
+          }
+        }
+      } else if (isRecord(exportEntry)) {
+        if (exportPath === ".") {
+          if (exportEntry.require && rootExport.require && exportEntry.require !== rootExport.require) {
+            errors.push('package.json: mismatch between "main" and "exports.require". These must be equal.');
+          }
+          if (exportEntry.import && rootExport.import && exportEntry.import !== rootExport.import) {
+            errors.push('package.json: mismatch between "module" and "exports.import" These must be equal.');
+          }
+          if (exportEntry.types && rootExport.types && exportEntry.types !== rootExport.types) {
+            errors.push('package.json: mismatch between "types" and "exports.types". These must be equal.');
+          }
+          if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
+            errors.push('package.json: mismatch between "source" and "exports.source". These must be equal.');
+          }
+          Object.assign(rootExport, exportEntry);
+        } else {
+          const extraExport = _objectSpread({
+            _exported: true,
+            _path: exportPath
+          }, exportEntry);
+          extraExports.push(extraExport);
+        }
+      } else {
+        errors.push("package.json: exports must be an object");
+      }
+    }
+  }
+  const _exports = [rootExport, ...extraExports];
+  errors.push(...validateExports(_exports, {
+    pkg
+  }));
+  if (errors.length) {
+    throw new Error("\n- " + errors.join("\n- "));
+  }
+  return _exports;
+}
+async function loadTSConfig(options) {
+  const {
+    cwd,
+    tsconfigPath
+  } = options;
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+  if (!configPath) {
+    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);
+}
+function createLogger() {
+  return {
+    log: function () {
+      console.log(...arguments);
+    },
+    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: function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      console.log(chalk.yellow("[warning]"), ...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("[error]"), ...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("[success]"), ...args);
+    }
+  };
+}
+function pathContains(containerPath, itemPath) {
+  return !path.relative(containerPath, itemPath).startsWith("..");
+}
+function findCommonDirPath(filePaths) {
+  let ret = void 0;
+  for (const filePath of filePaths) {
+    let dirPath = path.dirname(filePath);
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+    while (dirPath !== ret) {
+      dirPath = path.dirname(dirPath);
+      if (dirPath === ret) {
+        break;
+      }
+      if (pathContains(dirPath, ret)) {
+        ret = dirPath;
+        break;
+      }
+      if (dirPath === ".") return void 0;
+    }
+  }
+  return ret;
+}
+function sortAsNumber(a, b) {
+  const aVersion = Number(a);
+  const bVersion = Number(b);
+  return aVersion - bVersion;
+}
+function resolveBrowserslistVersions(query) {
+  const result = browserslist(query);
+  const entries = result.map(key => {
+    const [name, version] = key.split(" ");
+    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 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)
+  };
+  versions.chrome.sort(sortAsNumber);
+  versions.ff.sort(sortAsNumber);
+  versions.edge.sort(sortAsNumber);
+  versions.iosSaf.sort(sortAsNumber);
+  versions.saf.sort(sortAsNumber);
+  versions.opera.sort(sortAsNumber);
+  versions.node.sort(sortAsNumber);
+  return versions;
+}
+function resolveBrowserTarget(versions) {
+  const target = [];
+  if (versions.chrome.length) {
+    target.push("chrome".concat(versions.chrome[0]));
+  }
+  if (versions.ff.length) {
+    target.push("firefox".concat(versions.ff[0]));
+  }
+  if (versions.edge.length) {
+    target.push("edge".concat(versions.edge[0]));
+  }
+  if (versions.iosSaf.length) {
+    target.push("ios".concat(versions.iosSaf[0]));
+  }
+  if (versions.saf.length) {
+    target.push("safari".concat(versions.saf[0]));
+  }
+  if (versions.opera.length) {
+    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".concat(versions.node[0]));
+  }
+  if (target.length === 0) {
+    return void 0;
+  }
+  return target;
+}
+async function resolveBuildContext(options) {
+  var _ref;
+  const {
+    config,
+    cwd,
+    emitDeclarationOnly = false,
+    logger,
+    pkg,
+    strict,
+    tsconfig: tsconfigPath
+  } = options;
+  const tsconfig = await loadTSConfig({
+    cwd,
+    tsconfigPath
+  });
+  const targetVersions = resolveBrowserslistVersions(pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY);
+  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,
+    strict
+  }).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 external = config && Array.isArray(config.external) ? [...parsedExternal, ...config.external] : resolveConfigProperty(config == null ? void 0 : config.external, parsedExternal);
+  const outputPaths = Object.values(exports).flatMap(exportEntry => {
+    var _a, _b, _c, _d;
+    return [exportEntry.import, exportEntry.require, (_a = exportEntry.browser) == null ? void 0 : _a.import, (_b = exportEntry.browser) == null ? void 0 : _b.require, (_c = exportEntry.node) == null ? void 0 : _c.import, (_d = exportEntry.node) == null ? void 0 : _d.require].filter(Boolean);
+  }).map(p => path.resolve(cwd, p));
+  const commonDistPath = findCommonDirPath(outputPaths);
+  if (commonDistPath === cwd) {
+    throw new Error("all output files must share a common parent directory which is not the root package directory");
+  }
+  if (commonDistPath && !pathContains(cwd, commonDistPath)) {
+    throw new Error("all output files must be located within the package");
+  }
+  const configDistPath = (config == null ? void 0 : config.dist) ? path.resolve(cwd, config.dist) : void 0;
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath)) {
+    logger.log("did you mean to configure `dist: './".concat(path.relative(cwd, commonDistPath), "'`?"));
+    throw new Error("all output files must be located with the configured `dist` path");
+  }
+  const distPath = configDistPath || commonDistPath;
+  if (!distPath) {
+    throw new Error("could not detect `dist` path");
+  }
+  const ctx = {
+    config,
+    cwd,
+    distPath,
+    emitDeclarationOnly,
+    exports,
+    external,
+    files: [],
+    logger,
+    pkg,
+    runtime: (_ref = config == null ? void 0 : config.runtime) !== null && _ref !== void 0 ? _ref : "*",
+    strict,
+    target,
+    ts: {
+      config: tsconfig,
+      configPath: tsconfigPath
+    }
+  };
+  return ctx;
+}
+function resolveBuildTasks(ctx) {
+  var _a, _b, _c, _d, _e;
+  const {
+    config,
+    cwd,
+    pkg,
+    target
+  } = ctx;
+  const bundles = (config == null ? void 0 : config.bundles) || [];
+  const tasks = [];
+  const exports = Object.entries(ctx.exports || {}).map(_ref2 => {
+    let [_path, exp] = _ref2;
+    return _objectSpread({
+      _path
+    }, exp);
+  });
+  const dtsTask = {
+    type: "build:dts",
+    entries: []
+  };
+  const rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    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: target[runtime]
+      };
+    }
+  }
+  for (const exp of exports) {
+    const importId = path.join(pkg.name, exp._path);
+    if (exp.types) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPath: exp.types
+      });
+    }
+  }
+  if (dtsTask.entries.length) {
+    tasks.push(dtsTask);
+  }
+  if (!ctx.emitDeclarationOnly) {
+    for (const exp of exports) {
+      const output = exp.require;
+      if (!output) continue;
+      addRollupTaskEntry("commonjs", ctx.runtime, {
+        path: exp._path,
+        source: exp.source,
+        output
+      });
+    }
+    for (const exp of exports) {
+      const output = exp.import;
+      if (!output) continue;
+      addRollupTaskEntry("esm", 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;
+      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 = (_c = exp.browser) == null ? void 0 : _c.import;
+      if (!output) continue;
+      addRollupTaskEntry("esm", "browser", {
+        path: exp._path,
+        source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
+        output
+      });
+    }
+    for (const bundle of bundles) {
+      if (bundle.require) {
+        addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
+          path: "__bundle__",
+          source: bundle.source,
+          output: bundle.require
+        });
+      }
+      if (bundle.import) {
+        addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
+          path: "__bundle__",
+          source: bundle.source,
+          output: bundle.import
+        });
+      }
+    }
+    tasks.push(...Object.values(rollupTasks));
+    if (config == null ? void 0 : config.legacyExports) {
+      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, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
+          }
+        }
+      }
+    }
+  }
+  return tasks;
+}
+function createSpinner(msg) {
+  const startTime = Date.now();
+  console.log(msg);
+  return {
+    complete: () => {
+      console.log("".concat(chalk.green("[success]"), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
+    },
+    error: () => {
+      console.log("".concat(chalk.red("[error]"), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
+    }
+  };
+}
+function printExtractMessages(ctx, messages) {
+  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(["".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");
+  if (!warnings.length && errors.length) {
+    logger.log("");
+  }
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
+    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);
+  }
+}
+const formatHost = {
+  getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+  getNewLine: () => ts.sys.newLine,
+  getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? f => f : f => f.toLowerCase()
+};
+async function buildTypes(options) {
+  const {
+    outDir,
+    tsconfig,
+    strict = false
+  } = options;
+  const compilerOptions = _objectSpread(_objectSpread({}, tsconfig.options), {}, {
+    declaration: true,
+    declarationDir: outDir,
+    emitDeclarationOnly: true,
+    noEmit: false,
+    outDir
+  });
+  const program = ts.createProgram(tsconfig.fileNames, compilerOptions);
+  const emitResult = program.emit();
+  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  allDiagnostics.forEach(diagnostic => {
+    if (diagnostic.file && diagnostic.start) {
+      const {
+        line,
+        character
+      } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      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);
+    if (errors.length) {
+      console.error(ts.formatDiagnostics(errors, formatHost));
+      if (strict) {
+        throw new Error("failed to compile TypeScript definitions");
+      }
+    }
+  }
+}
+class DtsError extends Error {
+  constructor(message, messages) {
+    super(message);
+    this.messages = messages;
+  }
+}
+function createApiExtractorConfig(options) {
+  const {
+    distPath,
+    exportPath,
+    filePath,
+    messages,
+    projectFolder,
+    mainEntryPointFilePath,
+    tsconfigPath
+  } = options;
+  return {
+    apiReport: {
+      enabled: false,
+      reportFileName: "<unscopedPackageName>.api.md"
+    },
+    compiler: {
+      tsconfigFilePath: tsconfigPath
+    },
+    docModel: {
+      enabled: false,
+      apiJsonFilePath: path.resolve(distPath, "".concat(exportPath, ".api.json"))
+    },
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: path.resolve(distPath, filePath)
+    },
+    tsdocMetadata: {
+      enabled: false
+    },
+    messages,
+    mainEntryPointFilePath,
+    projectFolder
+  };
+}
+async function createTSDocConfig(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 tsDocBaseConfig = parse(tsDocBaseBuf.toString());
+  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["@".concat(customTag.name)] = true;
+  }
+  return TSDocConfigFile.loadFromObject(_objectSpread(_objectSpread({}, tsDocBaseConfig), {}, {
+    noStandardTags: false,
+    tagDefinitions,
+    supportForTags
+  }));
+}
+async function extractModuleBlocksFromTypes(_ref3) {
+  let {
+    tsOutDir,
+    extractResult
+  } = _ref3;
+  const program = extractResult.compilerState.program;
+  const moduleBlocks = [];
+  const allProgramFiles = [...program.getSourceFiles()];
+  const sourceFiles = allProgramFiles.filter(sourceFile => sourceFile.fileName.includes(tsOutDir));
+  for (const sourceFile of sourceFiles) {
+    if (sourceFile.text.includes("declare module")) {
+      moduleBlocks.push(...extractModuleBlocks(sourceFile.text));
+    }
+  }
+  return moduleBlocks;
+}
+function extractModuleBlocks(fileContent) {
+  const ast = parse$1(fileContent, {
+    parser: typeScriptParser
+  });
+  return ast.program.body.filter(node => node.type === "TSModuleDeclaration").map(node => print(node).code);
+}
+const LOG_LEVELS = {
+  error: "error",
+  info: "info",
+  off: "none",
+  warn: "warning"
+};
+function getExtractMessagesConfig(options) {
+  const {
+    rules
+  } = options;
+  function ruleToLogLevel(key, defaultLevel) {
+    const r = rules == null ? void 0 : rules[key];
+    return r ? LOG_LEVELS[r] : defaultLevel || "warning";
+  }
+  return {
+    compilerMessageReporting: {
+      default: {
+        logLevel: "warning"
+      }
+    },
+    extractorMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      },
+      "ae-forgotten-export": {
+        logLevel: ruleToLogLevel("ae-forgotten-export", "error"),
+        addToApiReportFile: false
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: ruleToLogLevel("ae-incompatible-release-tags", "error"),
+        addToApiReportFile: false
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: ruleToLogLevel("ae-internal-missing-underscore"),
+        addToApiReportFile: false
+      },
+      "ae-missing-release-tag": {
+        logLevel: ruleToLogLevel("ae-missing-release-tag", "error"),
+        addToApiReportFile: false
+      },
+      "ae-wrong-input-file-type": {
+        logLevel: "none",
+        addToApiReportFile: false
+      }
+    },
+    tsdocMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      },
+      "tsdoc-link-tag-unescaped-text": {
+        logLevel: ruleToLogLevel("tsdoc-link-tag-unescaped-text", "warning"),
+        addToApiReportFile: false
+      },
+      "tsdoc-undefined-tag": {
+        logLevel: ruleToLogLevel("tsdoc-undefined-tag", "error"),
+        addToApiReportFile: false
+      },
+      "tsdoc-unsupported-tag": {
+        logLevel: ruleToLogLevel("tsdoc-unsupported-tag", "none"),
+        addToApiReportFile: false
+      }
+    }
+  };
+}
+async function extractTypes(options) {
+  const {
+    customTags,
+    distPath,
+    exportPath,
+    files,
+    filePath,
+    projectPath,
+    rules,
+    sourceTypesPath,
+    tmpPath,
+    tsconfigPath
+  } = options;
+  const tsdocConfigFile = await createTSDocConfig({
+    customTags: customTags || []
+  });
+  const extractorConfig = ExtractorConfig.prepare({
+    configObject: createApiExtractorConfig({
+      distPath,
+      exportPath,
+      filePath,
+      messages: getExtractMessagesConfig({
+        rules
+      }),
+      projectFolder: projectPath,
+      mainEntryPointFilePath: sourceTypesPath,
+      tsconfigPath
+    }),
+    configObjectFullPath: void 0,
+    tsdocConfigFile,
+    packageJsonFullPath: path.resolve(projectPath, "package.json")
+  });
+  const messages = [];
+  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));
+  const moduleBlocks = await extractModuleBlocksFromTypes({
+    extractResult: extractorResult,
+    tsOutDir: tmpPath
+  });
+  const code = [typesBuf.toString(), ...moduleBlocks].join("\n\n");
+  await fs.writeFile(typesPath, prettier.format(code, _objectSpread(_objectSpread({}, prettierConfig), {}, {
+    filepath: typesPath
+  })));
+  files.push({
+    type: "types",
+    path: typesPath
+  });
+  return {
+    extractorResult,
+    messages
+  };
+}
+const rimraf = promisify(rimrafCallback);
+async function doExtract(ctx, task) {
+  var _a, _b;
+  const {
+    config,
+    cwd,
+    files,
+    strict,
+    ts
+  } = ctx;
+  if (!ts.config || !ts.configPath) {
+    return {
+      type: "dts",
+      messages: [],
+      results: []
+    };
+  }
+  const {
+    outDir,
+    rootDir = cwd
+  } = ts.config.options;
+  if (!outDir) {
+    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
+  }
+  const tmpPath = path.resolve(outDir, "__tmp__");
+  await buildTypes({
+    cwd,
+    outDir: tmpPath,
+    strict,
+    tsconfig: ts.config
+  });
+  const messages = [];
+  const results = [];
+  for (const entry of task.entries) {
+    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath;
+    const sourceTypesPath = path.resolve(tmpPath, path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts"));
+    const targetPath = path.resolve(cwd, entry.targetPath);
+    const filePath = path.relative(outDir, targetPath);
+    const result = await extractTypes({
+      customTags: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.customTags,
+      cwd,
+      distPath: outDir,
+      exportPath,
+      files,
+      filePath,
+      projectPath: cwd,
+      rules: (_b = config == null ? void 0 : config.extract) == null ? void 0 : _b.rules,
+      sourceTypesPath,
+      tmpPath,
+      tsconfigPath: path.resolve(cwd, ts.configPath || "tsconfig.json")
+    });
+    messages.push(...result.messages);
+    if (result.messages.some(msg => msg.logLevel === "error")) {
+      await rimraf(tmpPath);
+      throw new DtsError("encountered errors when extracting types", result.messages);
+    }
+    results.push({
+      sourcePath: path.resolve(cwd, entry.sourcePath),
+      filePath: targetPath
+    });
+  }
+  await rimraf(tmpPath);
+  return {
+    type: "dts",
+    messages,
+    results
+  };
+}
+const dtsTask = {
+  name: (_ctx, task) => ["Build type definitions...", "  entries:", ...task.entries.map(entry => ["    - ".concat(chalk.cyan(entry.importId), ": "), "".concat(chalk.yellow(entry.sourcePath), " ").concat(chalk.gray("\u2192"), " ").concat(chalk.yellow(entry.targetPath))].join(""))].join("\n"),
+  exec: (ctx, task) => {
+    return new Observable(observer => {
+      doExtract(ctx, task).then(result => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => {
+        observer.error(err);
+      });
+    });
+  },
+  complete: (ctx, _task, result) => {
+    printExtractMessages(ctx, result.messages);
+  },
+  error: (ctx, _task, err) => {
+    const {
+      logger
+    } = ctx;
+    if (err instanceof DtsError) {
+      printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+const dtsWatchTask = {
+  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 => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => observer.error(err));
+    });
+  },
+  complete: (ctx, _task, result) => {
+    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;
+    if (err instanceof DtsError) {
+      printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+function resolveRollupConfig(ctx, buildTask) {
+  var _ref4, _ref7, _ref8, _ref9, _ref10, _ref11;
+  var _a, _b, _c;
+  const {
+    format,
+    runtime,
+    target
+  } = buildTask;
+  const {
+    config,
+    cwd,
+    exports: _exports,
+    external,
+    distPath,
+    logger,
+    pkg,
+    ts
+  } = ctx;
+  const outputExt = MODULE_EXT[pkg.type][format];
+  const minify = (_ref4 = config == null ? void 0 : config.minify) !== null && _ref4 !== void 0 ? _ref4 : true;
+  const outDir = path.relative(cwd, distPath);
+  const pathAliases = Object.fromEntries(Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(_ref5 => {
+    let [key, val] = _ref5;
+    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));
+  const replacements = Object.fromEntries(Object.entries((config == null ? void 0 : config.define) || {}).map(_ref6 => {
+    let [key, val] = _ref6;
+    return [key, JSON.stringify(val)];
+  }));
+  const defaultPlugins = [replace({
+    preventAssignment: true,
+    values: _objectSpread({}, pkg.name === "@sanity/pkg-utils" ? _objectSpread({}, replacements) : _objectSpread({
+      "process.env.PKG_FILE_PATH": arg => {
+        const sourcePath = "./" + path.relative(cwd, arg);
+        const entry = entries.find(e => e.source === sourcePath);
+        if (!entry) {
+          console.error("could not find source entry: ".concat(sourcePath));
+          return "null";
+        }
+        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)
+    }, replacements))
+  }), 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: (_ref7 = config == null ? void 0 : config.jsx) !== null && _ref7 !== void 0 ? _ref7 : "automatic",
+    jsxFactory: (_ref8 = config == null ? void 0 : config.jsxFactory) !== null && _ref8 !== void 0 ? _ref8 : "createElement",
+    jsxFragment: (_ref9 = config == null ? void 0 : config.jsxFragment) !== null && _ref9 !== void 0 ? _ref9 : "Fragment",
+    jsxImportSource: (_ref10 = config == null ? void 0 : config.jsxImportSource) !== null && _ref10 !== void 0 ? _ref10 : "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 || DEFAULT_BROWSERSLIST_QUERY
+    }]]
+  }), 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);
+  const userPlugins = (_b = config == null ? void 0 : config.rollup) == null ? void 0 : _b.plugins;
+  const plugins = Array.isArray(userPlugins) ? defaultPlugins.concat(userPlugins) : resolveConfigProperty((_c = config == null ? void 0 : config.rollup) == null ? void 0 : _c.plugins, defaultPlugins);
+  return {
+    inputOptions: {
+      context: cwd,
+      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("@") ? "".concat(idParts[0], "/").concat(idParts[1]) : idParts[0];
+        if (name && external.includes(name)) {
+          return true;
+        }
+        return false;
+      },
+      input: entries.reduce((acc, entry) => {
+        return _objectSpread(_objectSpread({}, acc), {}, {
+          [entry.name]: entry.source
+        });
+      }, {}),
+      plugins,
+      treeshake: {
+        propertyReadSideEffects: false
+      }
+    },
+    outputOptions: {
+      chunkFileNames: () => "_chunks/[name]-[hash]".concat(outputExt),
+      compact: minify,
+      dir: outDir,
+      entryFileNames: () => "[name]".concat(outputExt),
+      esModule: true,
+      format,
+      interop: "compat",
+      minifyInternalExports: minify,
+      sourcemap: (_ref11 = config == null ? void 0 : config.sourcemap) !== null && _ref11 !== void 0 ? _ref11 : true
+    }
+  };
+}
+const rollupTask = {
+  name: (ctx, task) => ["Build javascript files...", "  format: ".concat(chalk.yellow(task.format)), "  target:", ...task.target.map(t => "    - ".concat(chalk.yellow(t))), "  entries:", ...task.entries.map(e => ["    - ", "".concat(chalk.cyan(path.join(ctx.pkg.name, e.path)), ": "), "".concat(chalk.yellow(e.source), " ").concat(chalk.gray("\u2192"), " ").concat(chalk.yellow(e.output))].join(""))].join("\n"),
+  exec: (ctx, task) => {
+    return new Observable(observer => {
+      execPromise(ctx, task).then(result => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => observer.error(err));
+    });
+  },
+  complete: () => {},
+  error: (_ctx, _task, err) => {
+    if (err instanceof Error) {
+      console.log(err);
+    }
+  }
+};
+function createSpyConsole() {
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error
+  };
+  const messages = [];
+  console.log = function () {
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    return messages.push({
+      type: "log",
+      args
+    });
+  };
+  console.warn = function () {
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    return messages.push({
+      type: "warn",
+      args
+    });
+  };
+  console.error = function () {
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    return messages.push({
+      type: "error",
+      args
+    });
+  };
+  return {
+    messages,
+    restore: () => {
+      console.log = original.log;
+      console.warn = original.warn;
+      console.error = original.error;
+    }
+  };
+}
+async function execPromise(ctx, task) {
+  const {
+    distPath,
+    files,
+    logger
+  } = ctx;
+  const outDir = path.relative(ctx.cwd, distPath);
+  const spyConsole = createSpyConsole();
+  const {
+    inputOptions,
+    outputOptions
+  } = resolveRollupConfig(ctx, task);
+  const bundle = await rollup(_objectSpread(_objectSpread({}, inputOptions), {}, {
+    onwarn(warning) {
+      spyConsole.messages.push({
+        type: "warn",
+        args: [warning.message]
+      });
+    }
+  }));
+  const {
+    output
+  } = await bundle.generate(outputOptions);
+  spyConsole.restore();
+  for (const msg of spyConsole.messages) {
+    const text = String(msg.args[0]);
+    if (text.startsWith("Dynamic import can only")) {
+      continue;
+    }
+    if (text.startsWith("Sourcemap is likely to be incorrect")) {
+      continue;
+    }
+    if (msg.type === "log") {
+      logger.info(...msg.args);
+    }
+    if (msg.type === "warn") {
+      logger.warn(...msg.args);
+    }
+    if (msg.type === "error") {
+      logger.error(...msg.args);
+    }
+  }
+  for (const chunkOrAsset of output) {
+    if (chunkOrAsset.type === "asset") {
+      files.push({
+        type: "asset",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      });
+    } else {
+      files.push({
+        type: "chunk",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      });
+    }
+  }
+  await bundle.write(outputOptions);
+  await bundle.close();
+}
+const rollupWatchTask = {
+  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 = _objectSpread(_objectSpread({}, inputOptions), {}, {
+        output: outputOptions
+      });
+      const watcher = watch$1(watchOptions);
+      watcher.on("event", event => {
+        observer.next(event);
+      });
+      return () => {
+        watcher.close();
+      };
+    });
+  },
+  complete: (ctx, task, event) => {
+    const {
+      logger
+    } = ctx;
+    if (event.code === "BUNDLE_END") {
+      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;
+    if (err instanceof Error) {
+      logger.log(err);
+    }
+  }
+};
+const buildTaskHandlers = {
+  "build:dts": dtsTask,
+  "build:js": rollupTask
+};
+const watchTaskHandlers = {
+  "watch:dts": dtsWatchTask,
+  "watch:js": rollupWatchTask
+};
+async function build(options) {
+  const {
+    cwd,
+    emitDeclarationOnly,
+    strict = false,
+    tsconfig: tsconfigOption
+  } = options;
+  const logger = createLogger();
+  const pkg = await loadPkgWithReporting({
+    cwd,
+    logger
+  });
+  const config = await loadConfig({
+    cwd
+  });
+  const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
+  const ctx = await resolveBuildContext({
+    config,
+    cwd,
+    emitDeclarationOnly,
+    logger,
+    pkg,
+    strict,
+    tsconfig
+  });
+  const buildTasks = resolveBuildTasks(ctx);
+  for (const task of buildTasks) {
+    const handler = buildTaskHandlers[task.type];
+    const taskName = handler.name(ctx, task);
+    const spinner = createSpinner(taskName);
+    try {
+      const result = await handler.exec(ctx, task).toPromise();
+      spinner.complete();
+      ctx.logger.log();
+      handler.complete(ctx, task, result);
+    } catch (err) {
+      spinner.error();
+      if (err instanceof Error) {
+        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);
+    }
+  }
+}
+function getFilesize(file) {
+  const stats = statSync(file);
+  return prettyBytes(stats.size);
+}
+function fileExists(file) {
+  try {
+    fs$1.accessSync(file);
+    return true;
+  } catch (_) {
+    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
+  };
+}
+function printPackageTree(ctx) {
+  const {
+    cwd,
+    exports,
+    logger,
+    pkg
+  } = ctx;
+  if (!exports) return;
+  logger.log("".concat(chalk.blue(pkg.name), "@").concat(chalk.green(pkg.version)));
+  const tree = {
+    type: chalk.yellow(pkg.type)
+  };
+  if (pkg.bin) {
+    tree.bin = Object.fromEntries(Object.entries(pkg.bin).map(_ref12 => {
+      let [name, file] = _ref12;
+      return [chalk.cyan(name), fileInfo(file)];
+    }));
+  }
+  function fileInfo(file) {
+    const info = getFileInfo(cwd, file);
+    if (!info.size) {
+      return "".concat(chalk.gray(file), " ").concat(chalk.red("does not exist"));
+    }
+    return "".concat(chalk.yellow(file), " ").concat(chalk.gray(info.size));
+  }
+  tree.exports = Object.fromEntries(Object.entries(exports).filter(_ref13 => {
+    let [, entry] = _ref13;
+    return entry._exported;
+  }).map(_ref14 => {
+    let [exportPath, entry] = _ref14;
+    const exp = {
+      types: void 0,
+      source: fileInfo(entry.source),
+      browser: void 0,
+      node: void 0,
+      import: void 0,
+      require: void 0,
+      default: fileInfo(entry.default)
+    };
+    if (entry.types) {
+      exp.types = fileInfo(entry.types);
+    } else {
+      delete exp.types;
+    }
+    if (entry.browser) {
+      exp.browser = {
+        source: fileInfo(entry.browser.source)
+      };
+      if (entry.browser.import) exp.browser.import = fileInfo(entry.browser.import);
+      if (entry.browser.require) exp.browser.require = fileInfo(entry.browser.require);
+    } else {
+      delete exp.browser;
+    }
+    if (entry.node) {
+      exp.node = {
+        source: fileInfo(entry.node.source)
+      };
+      if (entry.node.import) exp.node.import = fileInfo(entry.node.import);
+      if (entry.node.require) exp.node.require = fileInfo(entry.node.require);
+    } else {
+      delete exp.node;
+    }
+    if (entry.import) {
+      exp.import = fileInfo(entry.import);
+    } else {
+      delete exp.import;
+    }
+    if (entry.require) {
+      exp.require = fileInfo(entry.require);
+    } else {
+      delete exp.require;
+    }
+    return [chalk.cyan(path.join(pkg.name, exportPath)), exp];
+  }));
+  logger.log(treeify.asTree(tree, true, true));
+}
+async function check(options) {
+  const {
+    cwd,
+    strict = false,
+    tsconfig: tsconfigOption
+  } = options;
+  const logger = createLogger();
+  const pkg = await loadPkgWithReporting({
+    cwd,
+    logger
+  });
+  const config = await loadConfig({
+    cwd
+  });
+  const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
+  const ctx = await resolveBuildContext({
+    config,
+    cwd,
+    logger,
+    pkg,
+    strict,
+    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) {
+      logger.error("missing files");
+      process.exit(1);
+    }
+    const _paths = {
+      require: [],
+      import: []
+    };
+    for (const exp of Object.values(ctx.exports || {})) {
+      if (!exp._exported) continue;
+      if (exp.require) _paths.require.push(exp.require);
+      if (exp.import) _paths.import.push(exp.import);
+    }
+    const external = Object.keys(pkg.dependencies || {}).concat(Object.keys(pkg.devDependencies || {}));
+    if (_paths.import.length) {
+      const code = _paths.import.map(id => "import('".concat(id, "')")).join("\n");
+      try {
+        const esbuildResult = await esbuild$1.build({
+          external,
+          stdin: {
+            contents: code,
+            loader: "js",
+            resolveDir: cwd
+          },
+          format: "esm",
+          bundle: true,
+          logLevel: "silent",
+          outfile: "/dev/null",
+          platform: "node"
+        });
+        if (esbuildResult.warnings.length > 0) {
+          logger.warn(...esbuildResult.warnings);
+        }
+      } catch (err) {
+        const {
+          errors
+        } = err;
+        for (const _err of errors) {
+          if (_err.location) {
+            logger.error(_err.detail || _err.text);
+            logger.error("".concat(_err.location.line, " | ").concat(_err.location.lineText));
+            logger.error("in", "./".concat(_err.location.file, ":").concat(_err.location.line, ":").concat(_err.location.column));
+          } else {
+            logger.error(_err.detail || _err.text);
+          }
+          logger.log();
+        }
+        process.exit(1);
+      }
+    }
+    if (_paths.require.length) {
+      const code = _paths.require.map(id => "require('".concat(id, "')")).join("\n");
+      const esbuildResult = await esbuild$1.build({
+        external,
+        stdin: {
+          contents: code,
+          loader: "js",
+          resolveDir: cwd
+        },
+        format: "cjs",
+        bundle: true,
+        outfile: "/dev/null",
+        platform: "node"
+      });
+      if (esbuildResult.errors.length > 0) {
+        logger.error(esbuildResult.errors.join(", "));
+        process.exit(1);
+      }
+      if (esbuildResult.warnings.length > 0) {
+        logger.warn(...esbuildResult.warnings);
+      }
+    }
+  }
+}
+function resolveWatchTasks(ctx) {
+  var _a, _b, _c, _d, _e;
+  const {
+    config,
+    cwd,
+    pkg,
+    target
+  } = ctx;
+  const tasks = [];
+  const exports = Object.entries(ctx.exports || {}).map(_ref15 => {
+    let [_path, exp] = _ref15;
+    return _objectSpread({
+      _path
+    }, exp);
+  });
+  const dtsTask = {
+    type: "watch:dts",
+    entries: []
+  };
+  const rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    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: target[runtime]
+      };
+    }
+  }
+  for (const exp of exports) {
+    const importId = path.join(pkg.name, exp._path);
+    if (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;
+    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;
+    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;
+    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;
+    addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: ((_d = exp.browser) == null ? void 0 : _d.source) || exp.source,
+      output
+    });
+  }
+  if (dtsTask.entries.length) {
+    tasks.push(dtsTask);
+  }
+  tasks.push(...Object.values(rollupTasks));
+  if (config == null ? void 0 : config.legacyExports) {
+    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, "".concat(exp._path, ".js")), ["// AUTO-GENERATED \u2013 DO NOT EDIT", "export * from '".concat(relativeTargetPath, "'"), ""].join("\n"));
+        }
+      }
+    }
+  }
+  return tasks;
+}
+function globFiles(patterns) {
+  return globby(patterns);
+}
+function watchFiles(patterns) {
+  return new Observable(observer => {
+    const watcher = chokidar.watch(patterns, {
+      ignoreInitial: true
+    });
+    function handleFileEvent(type, file) {
+      observer.next({
+        type,
+        file
+      });
+    }
+    watcher.on("all", handleFileEvent);
+    return () => {
+      watcher.off("all", handleFileEvent);
+      watcher.close();
+    };
+  });
+}
+async function watchConfigFiles(options) {
+  const {
+    cwd,
+    logger
+  } = 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") {
+      logger.log("--------------------------------------------------------------------------------");
+      logger.info(path.relative(cwd, fileEvent.file), "changed");
+      logger.log("");
+      return files.slice(0);
+    }
+    return files;
+  }, initialFiles), startWith(initialFiles), distinctUntilChanged());
+}
+async function watch(options) {
+  const {
+    cwd,
+    strict = false,
+    tsconfig: tsconfigOption
+  } = options;
+  const logger = createLogger();
+  const configFiles$ = await watchConfigFiles({
+    cwd,
+    logger
+  });
+  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,
+      logger
+    });
+    const config = await loadConfig({
+      cwd
+    });
+    const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
+    return resolveBuildContext({
+      config,
+      cwd,
+      logger,
+      pkg,
+      strict,
+      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 => {
+          ctx.logger.error(err);
+          ctx.logger.log();
+          process.exit(1);
+        },
+        next: result => {
+          handler.complete(ctx, task, result);
+        },
+        complete: () => {
+          ctx.logger.success(handler.name(ctx, task));
+          ctx.logger.log();
+        }
+      });
+    }
+  });
+}
+export { DEFAULT_BROWSERSLIST_QUERY, MODULE_EXT, build, buildTaskHandlers, check, createLogger, defineConfig, dtsTask, dtsWatchTask, getExtractMessagesConfig, isRecord, loadConfig, loadPkg, loadPkgWithReporting, loadTSConfig, parseExports, resolveBuildTasks, resolveConfigProperty, rollupTask, rollupWatchTask, watch, watchTaskHandlers };
 //# sourceMappingURL=index.js.map