@sanity/pkg-utils 1.20.3 → 2.0.0-beta.1

package/dist/index.esm.js

@@ -1,1749 +0,0 @@
-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 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 browserslist from 'browserslist';
-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: ".esm.js"
-  },
-  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;
-}
-const pkgSchema = z.object({
-  type: z.optional(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) {
-  try {
-    return await loadPkg(options);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      for (const issue of err.issues) {
-        if (issue.code === "invalid_type") {
-          console.log(["".concat(chalk.red("fail"), "   `").concat(formatPath(issue.path), "` "), "in ./package.json must be of type ".concat(chalk.magenta(issue.expected), " "), "(received ".concat(chalk.magenta(issue.received), ")")].join(""));
-        }
-      }
-    } else {
-      console.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 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(_ref => {
-    let [_path, exp] = _ref;
-    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 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(_ref2) {
-  let {
-    tsOutDir,
-    extractResult
-  } = _ref2;
-  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", ...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) => {
-    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 _ref3, _ref6, _ref7, _ref8, _ref9, _ref10;
-  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 = (_ref3 = config == null ? void 0 : config.minify) !== null && _ref3 !== void 0 ? _ref3 : true;
-  const outDir = path.relative(cwd, distPath);
-  const pathAliases = Object.fromEntries(Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(_ref4 => {
-    let [key, val] = _ref4;
-    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(_ref5 => {
-    let [key, val] = _ref5;
-    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: (_ref6 = config == null ? void 0 : config.jsx) !== null && _ref6 !== void 0 ? _ref6 : "automatic",
-    jsxFactory: (_ref7 = config == null ? void 0 : config.jsxFactory) !== null && _ref7 !== void 0 ? _ref7 : "createElement",
-    jsxFragment: (_ref8 = config == null ? void 0 : config.jsxFragment) !== null && _ref8 !== void 0 ? _ref8 : "Fragment",
-    jsxImportSource: (_ref9 = config == null ? void 0 : config.jsxImportSource) !== null && _ref9 !== void 0 ? _ref9 : "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: () => outputExt === ".esm.js" ? "[name].js" : "[name]".concat(outputExt),
-      esModule: true,
-      format,
-      interop: "compat",
-      minifyInternalExports: minify,
-      sourcemap: (_ref10 = config == null ? void 0 : config.sourcemap) !== null && _ref10 !== void 0 ? _ref10 : true
-    }
-  };
-}
-const rollupTask = {
-  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 => {
-        observer.next(result);
-        observer.complete();
-      }).catch(err => observer.error(err));
-    });
-  },
-  complete: () => {},
-  error: (_ctx, _task, err) => {
-    if (err instanceof Error) {
-      console.log(err);
-    }
-  }
-};
-async function execPromise(ctx, task) {
-  const {
-    files,
-    distPath
-  } = ctx;
-  const outDir = path.relative(ctx.cwd, distPath);
-  const _console = {
-    log: console.log,
-    warn: console.warn,
-    error: console.error
-  };
-  const {
-    inputOptions,
-    outputOptions
-  } = resolveRollupConfig(ctx, task);
-  console.log = () => void 0;
-  console.warn = () => void 0;
-  console.error = () => void 0;
-  const bundle = await rollup(_objectSpread(_objectSpread({}, inputOptions), {}, {
-    onwarn(warning) {
-      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
-        _console.warn.bind(console)(chalk.yellow("warn  "), warning.message);
-      }
-    }
-  }));
-  const {
-    output
-  } = await bundle.generate(outputOptions);
-  console.log = _console.log;
-  console.warn = _console.warn;
-  console.error = _console.error;
-  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
-};
-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;
-}
-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("  warn"), ...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: 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);
-    }
-  };
-}
-async function resolveBuildContext(options) {
-  var _ref11;
-  const {
-    config,
-    cwd,
-    emitDeclarationOnly = false,
-    pkg,
-    strict,
-    tsconfig: tsconfigPath
-  } = options;
-  const logger = createLogger();
-  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: (_ref11 = config == null ? void 0 : config.runtime) !== null && _ref11 !== void 0 ? _ref11 : "*",
-    strict,
-    target,
-    ts: {
-      config: tsconfig,
-      configPath: tsconfigPath
-    }
-  };
-  return ctx;
-}
-function createSpinner(msg) {
-  const startTime = Date.now();
-  console.log("       ".concat(msg));
-  return {
-    complete: () => {
-      console.log("".concat(chalk.green("ok    "), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
-    },
-    error: () => {
-      console.log("".concat(chalk.red("failed"), " ").concat(chalk.gray("".concat(Date.now() - startTime, "ms"))));
-    }
-  };
-}
-async function build(options) {
-  const {
-    cwd,
-    emitDeclarationOnly,
-    strict = false,
-    tsconfig: tsconfigOption
-  } = options;
-  const pkg = await loadPkgWithReporting({
-    cwd
-  });
-  const config = await loadConfig({
-    cwd
-  });
-  const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
-  const ctx = await resolveBuildContext({
-    config,
-    cwd,
-    emitDeclarationOnly,
-    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 = {};
-  if (pkg.bin) {
-    tree.bin = pkg.bin;
-  }
-  function fileInfo(file) {
-    const info = getFileInfo(cwd, file);
-    if (!info.size) {
-      return "".concat(chalk.gray(file), " ").concat(chalk.red("does not exist"));
-    }
-    return "".concat(file, " ").concat(chalk.gray(info.size));
-  }
-  tree.exports = Object.fromEntries(Object.entries(exports).filter(_ref12 => {
-    let [, entry] = _ref12;
-    return entry._exported;
-  }).map(_ref13 => {
-    let [exportPath, entry] = _ref13;
-    const exp = {
-      source: entry.source,
-      types: void 0,
-      browser: void 0,
-      node: void 0,
-      import: void 0,
-      require: void 0,
-      default: entry.default
-    };
-    if (entry.types) {
-      exp.types = fileInfo(entry.types);
-    } else {
-      delete exp.types;
-    }
-    if (entry.browser) {
-      exp.browser = {
-        source: 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: 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;
-    }
-    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 = false,
-    tsconfig: tsconfigOption
-  } = options;
-  const pkg = await loadPkgWithReporting({
-    cwd
-  });
-  const config = await loadConfig({
-    cwd
-  });
-  const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
-  const ctx = await resolveBuildContext({
-    config,
-    cwd,
-    pkg,
-    strict,
-    tsconfig
-  });
-  const {
-    logger
-  } = ctx;
-  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(_ref14 => {
-    let [_path, exp] = _ref14;
-    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
-  } = 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,
-    strict = false,
-    tsconfig: tsconfigOption
-  } = 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
-    });
-    const tsconfig = tsconfigOption || (config == null ? void 0 : config.tsconfig) || "tsconfig.json";
-    return resolveBuildContext({
-      config,
-      cwd,
-      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, defineConfig, dtsTask, dtsWatchTask, getExtractMessagesConfig, isRecord, loadConfig, loadPkg, loadPkgWithReporting, loadTSConfig, parseExports, resolveBuildTasks, resolveConfigProperty, rollupTask, rollupWatchTask, watch, watchTaskHandlers };
-//# sourceMappingURL=index.esm.js.map