@sanity/pkg-utils 7.3.0 → 7.4.0-canary.1

package/dist/_chunks-cjs/index.cjs

@@ -18,7 +18,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
 ));
-var chalk = require("chalk"), rxjs = require("rxjs"), path = require("node:path"), rimraf = require("rimraf"), ts = require("typescript"), fs = require("node:fs/promises"), apiExtractor = require("@microsoft/api-extractor"), mkdirp = require("mkdirp"), prettier = require("prettier"), tsdocConfig = require("@microsoft/tsdoc-config"), jsoncParser = require("jsonc-parser"), recast = require("recast"), typeScriptParser = require("recast/parsers/typescript.js"), consoleSpy = require("./consoleSpy.cjs"), rollup = require("rollup"), rollupPlugin = require("@optimize-lodash/rollup-plugin"), alias = require("@rollup/plugin-alias"), pluginBabel = require("@rollup/plugin-babel"), commonjs = require("@rollup/plugin-commonjs"), json = require("@rollup/plugin-json"), pluginNodeResolve = require("@rollup/plugin-node-resolve"), replace = require("@rollup/plugin-replace"), terser = require("@rollup/plugin-terser"), esbuild = require("rollup-plugin-esbuild");
+var path = require("node:path"), rimraf = require("rimraf"), node_module = require("node:module"), node = require("esbuild-register/dist/node"), pkgUp = require("pkg-up"), findConfig = require("find-config"), node_fs = require("node:fs"), chalk = require("chalk"), zod = require("zod"), fs = require("node:fs/promises"), browserslist = require("browserslist"), config$1 = require("@sanity/browserslist-config"), ts = require("typescript"), zodValidationError = require("zod-validation-error"), rxjs = require("rxjs"), apiExtractor = require("@microsoft/api-extractor"), mkdirp = require("mkdirp"), prettier = require("prettier"), tsdocConfig = require("@microsoft/tsdoc-config"), jsoncParser = require("jsonc-parser"), recast = require("recast"), typeScriptParser = require("recast/parsers/typescript.js"), rollup = require("rollup"), rollupPlugin = require("@optimize-lodash/rollup-plugin"), alias = require("@rollup/plugin-alias"), pluginBabel = require("@rollup/plugin-babel"), commonjs = require("@rollup/plugin-commonjs"), json = require("@rollup/plugin-json"), pluginNodeResolve = require("@rollup/plugin-node-resolve"), replace = require("@rollup/plugin-replace"), terser = require("@rollup/plugin-terser"), esbuild = require("rollup-plugin-esbuild"), esbuild$1 = require("esbuild"), treeify = require("treeify"), prettyBytes = require("pretty-bytes"), prompts = require("prompts"), node_child_process = require("node:child_process"), getLatestVersion = require("get-latest-version"), gitUrlParse = require("git-url-parse"), outdent = require("outdent"), operators = require("rxjs/operators"), globby = require("globby"), chokidar = require("chokidar"), _documentCurrentScript = typeof document < "u" ? document.currentScript : null;
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -37,7 +37,648 @@ function _interopNamespaceCompat(e) {
     }
   }), n.default = e, Object.freeze(n);
 }
-var chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), path__default = /* @__PURE__ */ _interopDefaultCompat(path), rimraf__namespace = /* @__PURE__ */ _interopNamespaceCompat(rimraf), ts__default = /* @__PURE__ */ _interopDefaultCompat(ts), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs), prettier__namespace = /* @__PURE__ */ _interopNamespaceCompat(prettier), typeScriptParser__default = /* @__PURE__ */ _interopDefaultCompat(typeScriptParser), alias__default = /* @__PURE__ */ _interopDefaultCompat(alias), commonjs__default = /* @__PURE__ */ _interopDefaultCompat(commonjs), json__default = /* @__PURE__ */ _interopDefaultCompat(json), replace__default = /* @__PURE__ */ _interopDefaultCompat(replace), terser__default = /* @__PURE__ */ _interopDefaultCompat(terser), esbuild__default = /* @__PURE__ */ _interopDefaultCompat(esbuild);
+var path__default = /* @__PURE__ */ _interopDefaultCompat(path), rimraf__namespace = /* @__PURE__ */ _interopNamespaceCompat(rimraf), pkgUp__default = /* @__PURE__ */ _interopDefaultCompat(pkgUp), findConfig__default = /* @__PURE__ */ _interopDefaultCompat(findConfig), chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs), browserslist__default = /* @__PURE__ */ _interopDefaultCompat(browserslist), config__default = /* @__PURE__ */ _interopDefaultCompat(config$1), ts__default = /* @__PURE__ */ _interopDefaultCompat(ts), prettier__namespace = /* @__PURE__ */ _interopNamespaceCompat(prettier), typeScriptParser__default = /* @__PURE__ */ _interopDefaultCompat(typeScriptParser), alias__default = /* @__PURE__ */ _interopDefaultCompat(alias), commonjs__default = /* @__PURE__ */ _interopDefaultCompat(commonjs), json__default = /* @__PURE__ */ _interopDefaultCompat(json), replace__default = /* @__PURE__ */ _interopDefaultCompat(replace), terser__default = /* @__PURE__ */ _interopDefaultCompat(terser), esbuild__default = /* @__PURE__ */ _interopDefaultCompat(esbuild), esbuild__default$1 = /* @__PURE__ */ _interopDefaultCompat(esbuild$1), treeify__default = /* @__PURE__ */ _interopDefaultCompat(treeify), prettyBytes__default = /* @__PURE__ */ _interopDefaultCompat(prettyBytes), prompts__default = /* @__PURE__ */ _interopDefaultCompat(prompts), getLatestVersion__default = /* @__PURE__ */ _interopDefaultCompat(getLatestVersion), gitUrlParse__default = /* @__PURE__ */ _interopDefaultCompat(gitUrlParse), globby__default = /* @__PURE__ */ _interopDefaultCompat(globby), chokidar__namespace = /* @__PURE__ */ _interopNamespaceCompat(chokidar);
+function fileExists(filePath) {
+  try {
+    return node_fs.statSync(filePath), !0;
+  } catch {
+    return !1;
+  }
+}
+const CONFIG_FILE_NAMES = [
+  "package.config.ts",
+  "package.config.js",
+  "package.config.cjs",
+  "package.config.mjs"
+];
+function findConfigFile(cwd) {
+  const pkgJsonPath = findConfig__default.default("package.json", { cwd });
+  if (!pkgJsonPath) return;
+  const pkgPath = path__default.default.dirname(pkgJsonPath);
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = path__default.default.resolve(pkgPath, fileName);
+    if (fileExists(configPath))
+      return configPath;
+  }
+}
+const require$1 = node_module.createRequire(typeof document > "u" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("_chunks-cjs/index.cjs", document.baseURI).href);
+async function loadConfig(options) {
+  const { cwd } = options, pkgPath = await pkgUp__default.default({ cwd });
+  if (!pkgPath) return;
+  const root = path__default.default.dirname(pkgPath), configFile = await findConfigFile(root);
+  if (!configFile || !configFile.startsWith(cwd))
+    return;
+  const esbuildOptions = { extensions: [".js", ".mjs", ".ts"] }, { unregister } = globalThis.__DEV__ ? { unregister: () => {
+  } } : node.register(esbuildOptions), mod = require$1(configFile);
+  return unregister(), mod?.default || mod || void 0;
+}
+function assertLast(a, arr) {
+  const aIdx = arr.indexOf(a);
+  return aIdx === -1 ? !0 : aIdx === arr.length - 1;
+}
+function assertOrder(a, b, arr) {
+  const aIdx = arr.indexOf(a), bIdx = arr.indexOf(b);
+  return aIdx === -1 || bIdx === -1 ? !0 : aIdx < bIdx;
+}
+const pkgSchema = zod.z.object({
+  type: zod.z.optional(zod.z.enum(["commonjs", "module"])),
+  name: zod.z.string(),
+  version: zod.z.string(),
+  license: zod.z.string(),
+  bin: zod.z.optional(zod.z.record(zod.z.string())),
+  dependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  devDependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  peerDependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  source: zod.z.optional(zod.z.string()),
+  main: zod.z.optional(zod.z.string()),
+  browser: zod.z.optional(zod.z.record(zod.z.string())),
+  module: zod.z.optional(zod.z.string()),
+  types: zod.z.optional(zod.z.string()),
+  exports: zod.z.optional(
+    zod.z.record(
+      zod.z.union([
+        zod.z.custom((val) => /^\.\/.*\.json$/.test(val)),
+        zod.z.custom((val) => /^\.\/.*\.css$/.test(val)),
+        zod.z.object({
+          types: zod.z.optional(zod.z.string()),
+          source: zod.z.optional(zod.z.string()),
+          browser: zod.z.optional(
+            zod.z.object({
+              source: zod.z.string(),
+              import: zod.z.optional(zod.z.string()),
+              require: zod.z.optional(zod.z.string())
+            })
+          ),
+          node: zod.z.optional(
+            zod.z.object({
+              source: zod.z.optional(zod.z.string()),
+              import: zod.z.optional(zod.z.string()),
+              require: zod.z.optional(zod.z.string())
+            })
+          ),
+          import: zod.z.optional(zod.z.string()),
+          require: zod.z.optional(zod.z.string()),
+          default: zod.z.string()
+        }),
+        zod.z.object({
+          types: zod.z.optional(zod.z.string()),
+          svelte: zod.z.string(),
+          default: zod.z.optional(zod.z.string())
+        })
+      ])
+    )
+  ),
+  browserslist: zod.z.optional(zod.z.union([zod.z.string(), zod.z.array(zod.z.string())])),
+  sideEffects: zod.z.optional(zod.z.union([zod.z.boolean(), zod.z.array(zod.z.string())])),
+  // @TODO type this properly
+  typesVersions: zod.z.optional(zod.z.any())
+}), typoMap = /* @__PURE__ */ new Map();
+for (const key of pkgSchema.keyof()._def.values)
+  typoMap.set(key.toUpperCase(), key);
+function validatePkg(input) {
+  const pkg = pkgSchema.parse(input), invalidKey = Object.keys(input).find((key) => {
+    const needle = key.toUpperCase();
+    return typoMap.has(needle) ? typoMap.get(needle) !== key : !1;
+  });
+  if (invalidKey)
+    throw new TypeError(
+      `
+- package.json: "${invalidKey}" is not a valid key. Did you mean "${typoMap.get(invalidKey.toUpperCase())}"?`
+    );
+  return pkg;
+}
+async function loadPkg(options) {
+  const { cwd } = options, pkgPath = await pkgUp__default.default({ cwd });
+  if (!pkgPath) throw new Error("no package.json found");
+  const buf = await fs__default.default.readFile(pkgPath), raw = JSON.parse(buf.toString());
+  return validatePkg(raw), raw;
+}
+async function loadPkgWithReporting(options) {
+  const { cwd, logger, strict } = options;
+  try {
+    const pkg = await loadPkg({ cwd });
+    let shouldError = !1;
+    if (strict && (pkg.type || (shouldError = !0, logger.error(
+      'the `type` field in `./package.json` must be either "module" or "commonjs")'
+    ))), pkg.exports) {
+      const _exports = Object.entries(pkg.exports);
+      for (const [expPath, exp] of _exports) {
+        if (typeof exp == "string" || "svelte" in exp)
+          continue;
+        const keys = Object.keys(exp);
+        exp.types && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`types\` condition shouldn't be used as dts files are generated in such a way that both CJS and ESM is supported`
+        )), exp.module && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`module\` condition shouldn't be used as it's not well supported in all bundlers.`
+        )), exp.node ? (exp.import && exp.node.import && !assertOrder("node", "import", keys) && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`node\` property should come before the \`import\` property`
+        )), exp.node.module && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`node.module\` condition shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`
+        )), !exp.node.source && exp.node.import && (exp.node.require || exp.require) && (exp.node.import.endsWith(".cjs.js") || exp.node.import.endsWith(".cjs.mjs")) && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`node.import\` re-export pattern shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`
+        )), exp.require && exp.node.require && exp.require === exp.node.require ? (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`node.require\` property isn't necessary as it's identical to \`require\``
+        )) : exp.require && exp.node.require && !assertOrder("node", "require", keys) && (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`node\` property should come before the \`require\` property`
+        ))) : assertOrder("import", "require", keys) || logger.warn(
+          `exports["${expPath}"]: the \`import\` property should come before the \`require\` property`
+        ), assertLast("default", keys) || (shouldError = !0, logger.error(
+          `exports["${expPath}"]: the \`default\` property should be the last property`
+        ));
+      }
+    }
+    return shouldError && process.exit(1), pkg;
+  } catch (err) {
+    if (err instanceof zod.ZodError)
+      for (const issue of err.issues) {
+        if (issue.code === "invalid_type") {
+          logger.error(
+            [
+              `\`${formatPath(issue.path)}\` `,
+              `in \`./package.json\` must be of type ${chalk__default.default.magenta(issue.expected)} `,
+              `(received ${chalk__default.default.magenta(issue.received)})`
+            ].join("")
+          );
+          continue;
+        }
+        logger.error(issue);
+      }
+    else
+      logger.error(err);
+    process.exit(1);
+  }
+}
+function formatPath(segments) {
+  return segments.map((s, idx) => idx === 0 ? s : typeof s == "number" ? `[${s}]` : s.startsWith(".") ? `["${s}"]` : `.${s}`).join("");
+}
+function createLogger() {
+  return {
+    log: (...args) => {
+      console.log(...args);
+    },
+    info: (...args) => {
+      console.log(chalk__default.default.blue("[info]"), ...args);
+    },
+    warn: (...args) => {
+      console.log(chalk__default.default.yellow("[warning]"), ...args);
+    },
+    error: (...args) => {
+      console.log(chalk__default.default.red("[error]"), ...args);
+    },
+    success: (...args) => {
+      console.log(chalk__default.default.green("[success]"), ...args);
+    }
+  };
+}
+function browserslistToEsbuild(browserslistConfig, options = {}) {
+  if (!browserslistConfig) {
+    const path2 = process.cwd();
+    browserslistConfig = browserslist__default.default.loadConfig({ path: path2, ...options });
+  }
+  const SUPPORTED_ESBUILD_TARGETS = [
+    "es",
+    "chrome",
+    "edge",
+    "firefox",
+    "ios",
+    "node",
+    "safari",
+    "opera",
+    "ie"
+  ], UNSUPPORTED = ["android 4"], replaces = {
+    ios_saf: "ios",
+    android: "chrome"
+  }, separator = " ";
+  return browserslist__default.default(browserslistConfig, options).filter((b) => !UNSUPPORTED.some((u) => b.startsWith(u))).map((b) => b === "safari TP" ? browserslist__default.default("last 1 safari version")[0] : b).map((b) => b.split(separator)).map((b) => (replaces[b[0]] && (b[0] = replaces[b[0]]), b)).map((b) => (b[1].includes("-") && (b[1] = b[1].slice(0, b[1].indexOf("-"))), b)).map((b) => (b[1].endsWith(".0") && (b[1] = b[1].slice(0, -2)), b)).filter((b) => /^\d+(\.\d+)*$/.test(b[1])).filter((b) => SUPPORTED_ESBUILD_TARGETS.includes(b[0])).reduce((acc, b) => {
+    const existingIndex = acc.findIndex((br) => br[0] === b[0]);
+    return existingIndex !== -1 ? acc[existingIndex][1] = b[1] : acc.push(b), acc;
+  }, []).map((b) => b.join(""));
+}
+function resolveConfigProperty(prop, initialValue) {
+  return prop ? typeof prop == "function" ? prop(initialValue) : prop : initialValue;
+}
+const DEFAULT_BROWSERSLIST_QUERY = config__default.default;
+function pathContains(containerPath, itemPath) {
+  return !path__default.default.relative(containerPath, itemPath).startsWith("..");
+}
+function findCommonDirPath(filePaths) {
+  let ret;
+  for (const filePath of filePaths) {
+    let dirPath = path__default.default.dirname(filePath);
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+    for (; dirPath !== ret && (dirPath = path__default.default.dirname(dirPath), dirPath !== ret); ) {
+      if (pathContains(dirPath, ret)) {
+        ret = dirPath;
+        break;
+      }
+      if (dirPath === ".") return;
+    }
+  }
+  return ret;
+}
+const fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", defaultEnding = ".js", mjsEnding = ".mjs", cjsEnding = ".cjs", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
+function getTargetPaths(_type, expOrBundle) {
+  const type = _type === "module" ? "module" : "commonjs", set = /* @__PURE__ */ new Set();
+  return expOrBundle?.import && set.add(expOrBundle.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)), expOrBundle?.require && set.add(expOrBundle.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)), isPkgExport$1(expOrBundle) && (expOrBundle.browser?.source || (expOrBundle.browser?.import && set.add(
+    expOrBundle.browser.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)
+  ), expOrBundle.browser?.require && set.add(
+    expOrBundle.browser.require.replace(
+      fileEnding,
+      type === "commonjs" ? dtsEnding : ctsEnding
+    )
+  )), expOrBundle.node?.source || (expOrBundle.node?.import && set.add(
+    expOrBundle.node.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)
+  ), expOrBundle.node?.require && set.add(
+    expOrBundle.node.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)
+  ))), Array.from(set);
+}
+function isPkgExport$1(exp) {
+  return exp?.browser || exp?.node || exp?.default;
+}
+function isRecord(value) {
+  return !!value && !Array.isArray(value) && typeof value == "object";
+}
+const pkgExtMap = {
+  // pkg.type: "commonjs"
+  commonjs: {
+    commonjs: defaultEnding,
+    esm: mjsEnding
+  },
+  // pkg.type: "module"
+  module: {
+    commonjs: cjsEnding,
+    esm: defaultEnding
+  }
+};
+function validateExports(_exports, options) {
+  const { pkg } = options, type = pkg.type || "commonjs", ext = pkgExtMap[type], errors = [];
+  for (const exp of _exports)
+    exp.require && !exp.require.endsWith(ext.commonjs) && errors.push(
+      `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].require\` must end with "${ext.commonjs}"`
+    ), exp.import && !exp.import.endsWith(ext.esm) && errors.push(
+      `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].import\` must end with "${ext.esm}"`
+    );
+  return errors;
+}
+function parseExports(options) {
+  const { cwd, pkg, strict, strictOptions: strictOptions2, logger } = options, type = pkg.type || "commonjs", errors = [], report = (kind, message) => {
+    kind === "warn" ? logger.warn(message) : errors.push(message);
+  };
+  if (!pkg.main && strict && strictOptions2.alwaysPackageJsonMain !== "off" && report(strictOptions2.alwaysPackageJsonMain, "package.json: `main` must be declared"), !Array.isArray(pkg.files) && strict && strictOptions2.alwaysPackageJsonFiles !== "off" && report(
+    strictOptions2.alwaysPackageJsonFiles,
+    "package.json: `files` should be used over `.npmignore`"
+  ), pkg.source) {
+    if (strict && pkg.exports?.["."] && typeof pkg.exports["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source === pkg.source)
+      errors.push(
+        'package.json: the "source" property can be removed, as it is equal to exports["."].source.'
+      );
+    else if (!pkg.exports && pkg.main) {
+      const extMap = pkgExtMap[type], importExport = pkg.main.replace(fileEnding, extMap.esm), requireExport = pkg.main.replace(fileEnding, extMap.commonjs), defaultExport = pkg.main.replace(fileEnding, defaultEnding), maybeBrowserCondition = [];
+      if (pkg.browser) {
+        const browserConditions = [];
+        pkg.module && pkg.browser?.[pkg.module] ? browserConditions.push(
+          `      "import": ${JSON.stringify(pkg.browser[pkg.module].replace(fileEnding, extMap.esm))}`
+        ) : pkg.browser?.[pkg.main] && browserConditions.push(
+          `      "import": ${JSON.stringify(pkg.browser?.[pkg.main].replace(fileEnding, extMap.esm))}`
+        ), pkg.browser?.[pkg.main] && browserConditions.push(
+          `      "require": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.commonjs))}`
+        ), browserConditions.length && maybeBrowserCondition.push(
+          '    "browser": {',
+          `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`,
+          ...browserConditions,
+          "    }"
+        );
+      }
+      errors.push(
+        ...[
+          "package.json: `exports` are missing, it should be:",
+          '"exports": {',
+          '  ".": {',
+          `    "source": ${JSON.stringify(pkg.source)},`,
+          // If browser conditions are detected then add them to the suggestion
+          ...maybeBrowserCondition.length > 0 ? maybeBrowserCondition : [],
+          type === "commonjs" && `    "import": ${JSON.stringify(importExport)},`,
+          type === "module" && `    "require": ${JSON.stringify(requireExport)},`,
+          `    "default": ${JSON.stringify(defaultExport)}`,
+          "  },",
+          '  "./package.json": "./package.json"',
+          "}"
+        ].filter(Boolean)
+      );
+    }
+  }
+  if (errors.length)
+    throw new Error(`
+- ` + errors.join(`
+- `));
+  if (!pkg.exports)
+    throw new Error(
+      `
+- ` + [
+        "package.json: `exports` are missing, please set a minimal configuration, for example:",
+        '"exports": {',
+        '  ".": {',
+        '    "source": "./src/index.js",',
+        '    "default": "./dist/index.js"',
+        "  },",
+        '  "./package.json": "./package.json"',
+        "}"
+      ].join(`
+- `)
+    );
+  const _exports = [];
+  strict && strictOptions2.noPackageJsonTypings !== "off" && "typings" in pkg && report(strictOptions2.noPackageJsonTypings, "package.json: `typings` should be `types`"), strict && strictOptions2.alwaysPackageJsonTypes !== "off" && !pkg.types && typeof pkg.exports?.["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source?.endsWith(".ts") && report(
+    strictOptions2.alwaysPackageJsonTypes,
+    "package.json: `types` must be declared for the npm listing to show as a TypeScript module."
+  ), 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") || typeof exportEntry == "string" && exportEntry.endsWith(".json"))
+      exportPath === "./package.json" && exportEntry !== "./package.json" && errors.push('package.json: `exports["./package.json"]` must be "./package.json".');
+    else if (exportPath.endsWith(".css"))
+      typeof exportEntry == "string" && !node_fs.existsSync(path.resolve(cwd, exportEntry)) ? errors.push(
+        `package.json: \`exports[${JSON.stringify(exportPath)}]\`: file does not exist.`
+      ) : typeof exportEntry != "string" && errors.push(
+        `package.json: \`exports[${JSON.stringify(exportPath)}]\`: export conditions not supported for CSS files.`
+      );
+    else if (!(isRecord(exportEntry) && "svelte" in exportEntry))
+      if (isPkgExport(exportEntry)) {
+        const exp = {
+          _exported: !0,
+          _path: exportPath,
+          ...exportEntry
+        };
+        if (!exp.default) {
+          const fallback = type === "module" ? exp.import : exp.require;
+          fallback && (exp.default = fallback);
+        }
+        !exp.require && type === "commonjs" && exp.default && (exp.require = exp.default), !exp.import && type === "module" && exp.default && (exp.import = exp.default), exportPath === "." && (exportEntry.require && pkg.main && exportEntry.require !== pkg.main && errors.push(
+          'package.json: mismatch between "main" and "exports.require". These must be equal.'
+        ), exportEntry.import && pkg.module && exportEntry.import !== pkg.module && errors.push(
+          'package.json: mismatch between "module" and "exports.import" These must be equal.'
+        )), _exports.push(exp);
+      } else isRecord(exportEntry) || errors.push("package.json: exports must be an object");
+  if (errors.push(...validateExports(_exports, { pkg })), errors.length)
+    throw new Error(`
+- ` + errors.join(`
+- `));
+  return _exports;
+}
+function isPkgExport(value) {
+  return isRecord(value) && "source" in value && typeof value.source == "string";
+}
+async function loadTSConfig(options) {
+  const { cwd, tsconfigPath } = options, configPath = ts__default.default.findConfigFile(cwd, ts__default.default.sys.fileExists, tsconfigPath);
+  if (!configPath)
+    return;
+  const configFile = ts__default.default.readConfigFile(configPath, ts__default.default.sys.readFile);
+  return ts__default.default.parseJsonConfigFileContent(configFile.config, ts__default.default.sys, cwd);
+}
+function resolveBrowserTarget(versions) {
+  const target = versions.filter(
+    (version) => version.startsWith("chrome") || version.startsWith("edge") || version.startsWith("firefox") || version.startsWith("ios") || version.startsWith("safari") || version.startsWith("opera")
+  );
+  if (target.length !== 0)
+    return target;
+}
+function resolveNodeTarget(versions) {
+  const target = versions.filter((version) => version.startsWith("node"));
+  if (target.length !== 0)
+    return target;
+}
+const toggle = zod.z.union([zod.z.literal("error"), zod.z.literal("warn"), zod.z.literal("off")]), strictOptions = zod.z.object({
+  noPackageJsonTypings: toggle.default("error"),
+  noImplicitSideEffects: toggle.default("warn"),
+  noImplicitBrowsersList: toggle.default("warn"),
+  alwaysPackageJsonTypes: toggle.default("error"),
+  alwaysPackageJsonMain: toggle.default("error"),
+  alwaysPackageJsonFiles: toggle.default("error")
+}).strict(), validationSchema = zod.z.object({
+  strictOptions: strictOptions.default({})
+});
+function parseStrictOptions(input) {
+  return validationSchema.parse({ strictOptions: input }, { errorMap: zodValidationError.errorMap }).strictOptions;
+}
+async function resolveBuildContext(options) {
+  const {
+    config: config2,
+    cwd,
+    emitDeclarationOnly = !1,
+    logger,
+    pkg,
+    strict,
+    tsconfig: tsconfigPath
+  } = options, tsconfig = await loadTSConfig({ cwd, tsconfigPath }), strictOptions2 = parseStrictOptions(config2?.strictOptions ?? {});
+  let browserslist2 = pkg.browserslist;
+  if (!browserslist2) {
+    if (strict && strictOptions2.noImplicitBrowsersList !== "off") {
+      if (strictOptions2.noImplicitBrowsersList === "error")
+        throw new Error(
+          '\n- package.json: "browserslist" is missing, set it to `"browserslist": "extends @sanity/browserslist-config"`'
+        );
+      logger.warn(
+        'Could not detect a `browserslist` property in `package.json`, using default configuration. Add `"browserslist": "extends @sanity/browserslist-config"` to silence this warning.'
+      );
+    }
+    browserslist2 = DEFAULT_BROWSERSLIST_QUERY;
+  }
+  const targetVersions = browserslistToEsbuild(browserslist2);
+  if (strict && strictOptions2.noImplicitSideEffects !== "off" && typeof pkg.sideEffects > "u") {
+    const msg = "package.json: `sideEffects` is missing, see https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sideeffects for how to define `sideEffects`";
+    if (strictOptions2.noImplicitSideEffects === "error")
+      throw new Error(msg);
+    logger.warn(msg);
+  }
+  const nodeTarget = resolveNodeTarget(targetVersions), 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
+  }, parsedExports = parseExports({
+    cwd,
+    pkg,
+    strict,
+    strictOptions: strictOptions2,
+    logger
+  }).reduce(
+    (acc, { _path: exportPath, ...exportEntry }) => Object.assign(acc, { [exportPath]: exportEntry }),
+    {}
+  ), exports2 = resolveConfigProperty(config2?.exports, parsedExports), parsedExternal = [
+    ...pkg.dependencies ? Object.keys(pkg.dependencies) : [],
+    ...pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []
+  ], external = config2 && Array.isArray(config2.external) ? [...parsedExternal, ...config2.external] : resolveConfigProperty(config2?.external, parsedExternal), externalWithTypes = /* @__PURE__ */ new Set([pkg.name, ...external, ...external.map(transformPackageName)]), bundledDependencies = (pkg.devDependencies ? Object.keys(pkg.devDependencies) : []).filter(
+    // Do not bundle anything that is marked as external
+    (_) => !externalWithTypes.has(_)
+  ), bundledPackages = config2 && Array.isArray(config2.extract?.bundledPackages) ? [...bundledDependencies, ...config2.extract.bundledPackages] : resolveConfigProperty(config2?.extract?.bundledPackages, bundledDependencies), outputPaths = Object.values(exports2).flatMap((exportEntry) => [
+    exportEntry.import,
+    exportEntry.require,
+    exportEntry.browser?.import,
+    exportEntry.browser?.require,
+    exportEntry.node?.source && exportEntry.node.import,
+    exportEntry.node?.source && exportEntry.node.require
+  ].filter(Boolean)).map((p) => path__default.default.resolve(cwd, p)), 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 = config2?.dist ? path__default.default.resolve(cwd, config2.dist) : void 0;
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath))
+    throw logger.log(`did you mean to configure \`dist: './${path__default.default.relative(cwd, commonDistPath)}'\`?`), 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");
+  return {
+    config: config2,
+    cwd,
+    distPath,
+    emitDeclarationOnly,
+    exports: exports2,
+    external,
+    bundledPackages,
+    files: [],
+    logger,
+    pkg,
+    runtime: config2?.runtime ?? "*",
+    strict,
+    target,
+    ts: {
+      config: tsconfig,
+      configPath: tsconfigPath
+    },
+    dts: config2?.dts === "rolldown" ? "rolldown" : "api-extractor"
+  };
+}
+function transformPackageName(packageName) {
+  if (packageName.startsWith("@types/"))
+    return packageName;
+  if (packageName.startsWith("@")) {
+    const [scope, name] = packageName.split("/");
+    return `@types/${scope.slice(1)}__${name}`;
+  } else
+    return `@types/${packageName}`;
+}
+function resolveBuildTasks(ctx) {
+  const { config: config2, pkg, target } = ctx, bundles = config2?.bundles || [], tasks = [], exports2 = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "build:dts",
+    entries: []
+  }, rolldownDtsTask2 = {}, rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    const buildId = `${format}:${runtime}`;
+    ctx.dts === "rolldown" && (rolldownDtsTask2[buildId] ? rolldownDtsTask2[buildId].entries.push(entry) : rolldownDtsTask2[buildId] = {
+      type: "rolldown:dts",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    }), ctx.emitDeclarationOnly || (rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "build:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    });
+  }
+  if (ctx.dts === "api-extractor") {
+    for (const exp of exports2) {
+      const importId = path__default.default.join(pkg.name, exp._path);
+      exp.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPaths: getTargetPaths(pkg.type, exp)
+      }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.browser.source,
+        targetPaths: getTargetPaths(pkg.type, exp.browser)
+      }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.node.source,
+        targetPaths: getTargetPaths(pkg.type, exp.node)
+      });
+    }
+    for (const bundle of bundles)
+      if (bundle.source?.endsWith(".ts")) {
+        const exportPath = (bundle.import || bundle.require).replace(/\.[mc]?js$/, ""), importId = path__default.default.join(pkg.name, exportPath);
+        dtsTask2.entries.push({
+          importId,
+          exportPath,
+          sourcePath: bundle.source,
+          targetPaths: getTargetPaths(pkg.type, bundle)
+        });
+      }
+    dtsTask2.entries.length && tasks.push(dtsTask2);
+  }
+  for (const exp of exports2) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.import;
+    output && addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const bundle of bundles) {
+    const idx = bundles.indexOf(bundle);
+    bundle.require && addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_cjs_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.require
+    }), bundle.import && addRollupTaskEntry("esm", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_esm_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.import
+    });
+  }
+  return tasks.push(...Object.values(rolldownDtsTask2)), tasks.push(...Object.values(rollupTasks)), tasks;
+}
+function createSpinner(msg) {
+  const startTime = Date.now();
+  return console.log(msg), {
+    complete: () => {
+      console.log(`${chalk__default.default.green("[success]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
+    },
+    error: () => {
+      console.log(`${chalk__default.default.red("[error]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
+    }
+  };
+}
 function printExtractMessages(ctx, messages) {
   const { cwd, logger } = ctx, warnings = messages.filter((msg) => msg.logLevel === "warning");
   warnings.length && logger.log();
@@ -188,7 +829,7 @@ async function extractModuleBlocksFromTypes({
 function extractModuleBlocks(fileContent) {
   return recast.parse(fileContent, {
     parser: typeScriptParser__default.default
-  }).program.body.filter((node) => node.type === "TSModuleDeclaration").map((node) => recast.print(node).code);
+  }).program.body.filter((node2) => node2.type === "TSModuleDeclaration").map((node2) => recast.print(node2).code);
 }
 const LOG_LEVELS = {
   error: "error",
@@ -334,7 +975,7 @@ async function extractTypes(options) {
   return shouldCleanUpDts && await fs__default.default.unlink(typesPath), { extractorResult, messages };
 }
 async function doExtract(ctx, task) {
-  const { config, cwd, files, logger, strict, ts: ts2, bundledPackages } = ctx;
+  const { config: config2, cwd, files, logger, strict, ts: ts2, bundledPackages } = ctx;
   if (!ts2.config || !ts2.configPath)
     return { type: "dts", messages: [], results: [] };
   const { outDir, rootDir = cwd } = ts2.config.options;
@@ -349,18 +990,18 @@ async function doExtract(ctx, task) {
       path__default.default.relative(rootDir, path__default.default.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
     ), targetPaths = entry.targetPaths.map((targetPath) => path__default.default.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path__default.default.relative(outDir, targetPath)), result = await extractTypes({
       bundledPackages: bundledPackages || [],
-      customTags: config?.extract?.customTags,
+      customTags: config2?.extract?.customTags,
       distPath: outDir,
       exportPath,
       files,
       filePaths,
       projectPath: cwd,
-      rules: config?.extract?.rules,
+      rules: config2?.extract?.rules,
       sourceTypesPath,
       tsconfig: ts2.config,
       tmpPath,
       tsconfigPath: path__default.default.resolve(cwd, ts2.configPath || "tsconfig.json"),
-      extractorDisabled: config?.extract?.enabled === !1
+      extractorDisabled: config2?.extract?.enabled === !1
     });
     messages.push(...result.messages);
     const errors = result.messages.filter((msg) => msg.logLevel === "error");
@@ -405,7 +1046,7 @@ const dtsTask = {
   ].join(`
 `),
   exec: (ctx, task) => {
-    const { config, cwd, files, logger, strict, ts: tsContext, bundledPackages } = ctx;
+    const { config: config2, cwd, files, logger, strict, ts: tsContext, bundledPackages } = ctx;
     return new rxjs.Observable((observer) => {
       if (!tsContext.config || !tsContext.configPath) {
         observer.next({ type: "dts", messages: [], results: [] }), observer.complete();
@@ -459,19 +1100,19 @@ const dtsTask = {
           try {
             const result = await extractTypes({
               bundledPackages: bundledPackages || [],
-              customTags: config?.extract?.customTags,
+              customTags: config2?.extract?.customTags,
               cwd,
               distPath: outDir,
               exportPath,
               files,
               filePaths,
               projectPath: cwd,
-              rules: config?.extract?.rules,
+              rules: config2?.extract?.rules,
               sourceTypesPath,
               tsconfig: tsContext.config,
               tmpPath,
               tsconfigPath: path__default.default.resolve(cwd, tsContext.configPath || "tsconfig.json"),
-              extractorDisabled: config?.extract?.enabled === !1
+              extractorDisabled: config2?.extract?.enabled === !1
             });
             messages.push(...result.messages), results.push({ sourcePath: path__default.default.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
           } catch (err) {
@@ -505,7 +1146,21 @@ const dtsTask = {
     const { logger } = ctx;
     err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
   }
-}, rolldownDtsTask = {
+};
+function createConsoleSpy(options) {
+  const { onRestored } = options || {}, original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error
+  }, messages = [];
+  return console.log = (...args) => messages.push({ type: "log", args }), console.warn = (...args) => messages.push({ type: "warn", args }), console.error = (...args) => messages.push({ type: "error", args }), {
+    messages,
+    restore: () => {
+      console.log = original.log, console.warn = original.warn, console.error = original.error, onRestored?.(messages);
+    }
+  };
+}
+const rolldownDtsTask = {
   name: (ctx, task) => {
     const bundleEntries = task.entries.filter((e) => e.path.includes("__$$bundle_")), entries = task.entries.filter((e) => !e.path.includes("__$$bundle_")), targetLines = task.target.length ? ["  target:", ...task.target.map((t) => `    - ${chalk__default.default.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
       "  bundles:",
@@ -547,7 +1202,7 @@ async function execPromise$1(ctx, task) {
     Promise.resolve().then(function() {
       return require("./resolveRolldownConfig.cjs");
     })
-  ]), { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy$1 = consoleSpy.createConsoleSpy({
+  ]), { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
     onRestored: (messages) => {
       for (const msg of messages) {
         const text = String(msg.args[0]);
@@ -559,7 +1214,7 @@ async function execPromise$1(ctx, task) {
     const { inputOptions, outputOptions } = resolveRolldownConfig(ctx, task), bundle = await rolldown({
       ...inputOptions,
       onwarn(warning) {
-        consoleSpy$1.messages.push({
+        consoleSpy.messages.push({
           type: "warn",
           code: warning.code,
           args: [warning.message]
@@ -574,9 +1229,9 @@ async function execPromise$1(ctx, task) {
         type: "chunk",
         path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
       });
-    await bundle.write(outputOptions), await bundle.close(), consoleSpy$1.restore();
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
   } catch (err) {
-    throw consoleSpy$1.restore(), err;
+    throw consoleSpy.restore(), err;
   }
 }
 function replaceFileEnding(path2) {
@@ -590,14 +1245,14 @@ function replaceFileEnding(path2) {
   }
 }
 function resolveRollupConfig(ctx, buildTask) {
-  const { format, runtime, target } = buildTask, { config, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = consoleSpy.pkgExtMap[pkg.type || "commonjs"][format], minify = config?.minify ?? !1, outDir = path__default.default.relative(cwd, distPath), pathAliases = Object.fromEntries(
+  const { format, runtime, target } = buildTask, { config: config2, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format], minify = config2?.minify ?? !1, outDir = path__default.default.relative(cwd, distPath), pathAliases = Object.fromEntries(
     Object.entries(ts2.config?.options.paths || {}).map(([key, val]) => [key, path__default.default.resolve(cwd, ts2.config?.options.baseUrl || ".", val[0])])
   ), entries = buildTask.entries.map((entry) => ({
     ...entry,
     name: path__default.default.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
   }), {}), exportIds = _exports && Object.keys(_exports).map((exportPath) => path__default.default.join(pkg.name, exportPath)), sourcePaths = _exports && Object.values(_exports).map((e) => path__default.default.resolve(cwd, e.source)), replacements = Object.fromEntries(
-    Object.entries(config?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
-  ), { optimizeLodash: enableOptimizeLodash = hasDependency(pkg, "lodash") } = config?.rollup || {}, defaultPlugins = [
+    Object.entries(config2?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
+  ), { optimizeLodash: enableOptimizeLodash = hasDependency(pkg, "lodash") } = config2?.rollup || {}, defaultPlugins = [
     replace__default.default({
       preventAssignment: !0,
       values: pkg.name === "@sanity/pkg-utils" ? { ...replacements } : {
@@ -623,14 +1278,14 @@ function resolveRollupConfig(ctx, buildTask) {
     }),
     commonjs__default.default(),
     json__default.default(),
-    (config?.babel?.reactCompiler || config?.babel?.styledComponents) && pluginBabel.babel({
+    (config2?.babel?.reactCompiler || config2?.babel?.styledComponents) && pluginBabel.babel({
       babelrc: !1,
       presets: ["@babel/preset-typescript"],
       babelHelpers: "bundled",
       extensions: [".ts", ".tsx", ".js", ".jsx"],
       plugins: [
         // The styled-components plugin needs to run before the react-compiler plugin, in case the css prop is used
-        config?.babel?.styledComponents && [
+        config2?.babel?.styledComponents && [
           "babel-plugin-styled-components",
           {
             // Unnecessary, as the way we use styled-components in Sanity is usually by wrapping `@sanity/ui` primitives, not declaring new ones like "const Button = styled.button``"
@@ -641,35 +1296,35 @@ function resolveRollupConfig(ctx, buildTask) {
             pure: !0,
             // disabled, as pkg-utils tends to be used for npm publishing, while other tooling, like `sanity dev`, `next dev`, etc are used for testing
             cssProp: !1,
-            ...typeof config.babel.styledComponents == "object" ? config.babel.styledComponents : {}
+            ...typeof config2.babel.styledComponents == "object" ? config2.babel.styledComponents : {}
           }
         ],
-        config?.babel?.reactCompiler && [
+        config2?.babel?.reactCompiler && [
           "babel-plugin-react-compiler",
-          config?.reactCompilerOptions || {}
+          config2?.reactCompilerOptions || {}
         ]
       ].filter(Boolean)
     }),
     esbuild__default.default({
-      jsx: config?.jsx ?? "automatic",
-      jsxFactory: config?.jsxFactory ?? "createElement",
-      jsxFragment: config?.jsxFragment ?? "Fragment",
-      jsxImportSource: config?.jsxImportSource ?? "react",
+      jsx: config2?.jsx ?? "automatic",
+      jsxFactory: config2?.jsxFactory ?? "createElement",
+      jsxFragment: config2?.jsxFragment ?? "Fragment",
+      jsxImportSource: config2?.jsxImportSource ?? "react",
       target,
       tsconfig: ctx.ts.configPath || "tsconfig.json",
       treeShaking: !0,
-      minifySyntax: config?.minify !== !1,
+      minifySyntax: config2?.minify !== !1,
       supported: {
         "template-literal": !0
       }
     }),
-    Array.isArray(config?.babel?.plugins) && pluginBabel.getBabelOutputPlugin({
+    Array.isArray(config2?.babel?.plugins) && pluginBabel.getBabelOutputPlugin({
       babelrc: !1,
-      plugins: config.babel.plugins
+      plugins: config2.babel.plugins
     }),
     enableOptimizeLodash && rollupPlugin.optimizeLodashImports({
       useLodashEs: format === "esm" && hasDependency(pkg, "lodash-es") ? !0 : void 0,
-      ...typeof config?.rollup?.optimizeLodash == "boolean" ? {} : config?.rollup?.optimizeLodash
+      ...typeof config2?.rollup?.optimizeLodash == "boolean" ? {} : config2?.rollup?.optimizeLodash
     }),
     minify && terser__default.default({
       compress: { directives: !1, passes: 10 },
@@ -682,7 +1337,7 @@ function resolveRollupConfig(ctx, buildTask) {
         preserve_annotations: !0
       }
     })
-  ].filter(Boolean), userPlugins = config?.rollup?.plugins, plugins = Array.isArray(userPlugins) ? defaultPlugins.concat(userPlugins) : consoleSpy.resolveConfigProperty(config?.rollup?.plugins, defaultPlugins), hashChunkFileNames = config?.rollup?.hashChunkFileNames ?? !1, chunkFileNames = `${hashChunkFileNames ? "_chunks" : "_chunks-[format]"}/${hashChunkFileNames ? "[name]-[hash]" : "[name]"}${outputExt}`, entryFileNames = `[name]${outputExt}`;
+  ].filter(Boolean), userPlugins = config2?.rollup?.plugins, plugins = Array.isArray(userPlugins) ? defaultPlugins.concat(userPlugins) : resolveConfigProperty(config2?.rollup?.plugins, defaultPlugins), hashChunkFileNames = config2?.rollup?.hashChunkFileNames ?? !1, chunkFileNames = `${hashChunkFileNames ? "_chunks" : "_chunks-[format]"}/${hashChunkFileNames ? "[name]-[hash]" : "[name]"}${outputExt}`, entryFileNames = `[name]${outputExt}`;
   return {
     inputOptions: {
       context: cwd,
@@ -716,9 +1371,9 @@ function resolveRollupConfig(ctx, buildTask) {
         preset: "recommended",
         propertyReadSideEffects: !1,
         moduleSideEffects: "no-external",
-        ...config?.rollup?.treeshake
+        ...config2?.rollup?.treeshake
       },
-      experimentalLogSideEffects: config?.rollup?.experimentalLogSideEffects
+      experimentalLogSideEffects: config2?.rollup?.experimentalLogSideEffects
     },
     outputOptions: {
       chunkFileNames,
@@ -728,10 +1383,10 @@ function resolveRollupConfig(ctx, buildTask) {
       esModule: !0,
       format,
       interop: "compat",
-      sourcemap: config?.sourcemap ?? !0,
+      sourcemap: config2?.sourcemap ?? !0,
       hoistTransitiveImports: !1,
       minifyInternalExports: minify,
-      ...config?.rollup?.output
+      ...config2?.rollup?.output
     }
   };
 }
@@ -779,7 +1434,7 @@ const rollupTask = {
   }
 };
 async function execPromise(ctx, task) {
-  const { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy$1 = consoleSpy.createConsoleSpy({
+  const { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
     onRestored: (messages) => {
       for (const msg of messages) {
         const text = String(msg.args[0]);
@@ -791,7 +1446,7 @@ async function execPromise(ctx, task) {
     const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task), bundle = await rollup.rollup({
       ...inputOptions,
       onwarn(warning) {
-        consoleSpy$1.messages.push({
+        consoleSpy.messages.push({
           type: "warn",
           code: warning.code,
           args: [warning.message]
@@ -806,9 +1461,9 @@ async function execPromise(ctx, task) {
         type: "chunk",
         path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
       });
-    await bundle.write(outputOptions), await bundle.close(), consoleSpy$1.restore();
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
   } catch (err) {
-    throw consoleSpy$1.restore(), err;
+    throw consoleSpy.restore(), err;
   }
 }
 const rollupWatchTask = {
@@ -856,7 +1511,808 @@ const rollupWatchTask = {
   "watch:dts": dtsWatchTask,
   "watch:js": rollupWatchTask
 };
-exports.buildTaskHandlers = buildTaskHandlers;
+async function build(options) {
+  const {
+    cwd,
+    emitDeclarationOnly,
+    strict = !1,
+    tsconfig: tsconfigOption,
+    clean = !1
+  } = options, logger = createLogger(), config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({
+    config: config2,
+    cwd,
+    emitDeclarationOnly,
+    logger,
+    pkg,
+    strict,
+    tsconfig
+  });
+  clean && (logger.log(
+    `Deleting the \`dist\` folder: './${path__default.default.relative(cwd, ctx.distPath)}' before building...`
+  ), await rimraf.rimraf(ctx.distPath));
+  const buildTasks = resolveBuildTasks(ctx);
+  for (const task of buildTasks) {
+    const handler = buildTaskHandlers[task.type], taskName = handler.name(ctx, task), spinner = createSpinner(taskName);
+    try {
+      const result = await handler.exec(ctx, task).toPromise();
+      spinner.complete(), ctx.logger.log(), handler.complete(ctx, task, result);
+    } catch (err) {
+      if (spinner.error(), err instanceof Error) {
+        const RE_CWD = new RegExp(`${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 = node_fs.statSync(file);
+  return prettyBytes__default.default(stats.size);
+}
+function getFileInfo(cwd, filePath) {
+  const p = path__default.default.resolve(cwd, filePath), exists = fileExists(p), size = exists ? getFilesize(p) : void 0;
+  return { exists, size };
+}
+function printPackageTree(ctx) {
+  const { cwd, exports: exports2, logger, pkg } = ctx;
+  if (!exports2) return;
+  logger.log(`${chalk__default.default.blue(pkg.name)}@${chalk__default.default.green(pkg.version)}`);
+  const tree = {};
+  pkg.type && (tree.type = chalk__default.default.yellow(pkg.type)), pkg.bin && (tree.bin = Object.fromEntries(
+    Object.entries(pkg.bin).map(([name, file]) => [chalk__default.default.cyan(name), fileInfo(file)])
+  ));
+  function fileInfo(file) {
+    const info = getFileInfo(cwd, file);
+    return info.size ? `${chalk__default.default.yellow(file)} ${chalk__default.default.gray(info.size)}` : `${chalk__default.default.gray(file)} ${chalk__default.default.red("does not exist")}`;
+  }
+  tree.exports = Object.fromEntries(
+    Object.entries(exports2).filter(([, entry]) => entry._exported).map(([exportPath, entry]) => {
+      const exp = {
+        source: fileInfo(entry.source),
+        browser: void 0,
+        require: void 0,
+        node: void 0,
+        import: void 0,
+        default: fileInfo(entry.default)
+      };
+      return entry.browser ? (exp.browser = { source: fileInfo(entry.browser.source) }, entry.browser.import && (exp.browser.import = fileInfo(entry.browser.import)), entry.browser.require && (exp.browser.require = fileInfo(entry.browser.require))) : delete exp.browser, entry.require ? exp.require = fileInfo(entry.require) : delete exp.require, entry.node ? (exp.node = {}, entry.node.source && (exp.node.source = fileInfo(entry.node.source)), entry.node.import && (exp.node.import = fileInfo(entry.node.import)), entry.node.require && (exp.node.require = fileInfo(entry.node.require))) : delete exp.node, entry.import ? exp.import = fileInfo(entry.import) : delete exp.import, [chalk__default.default.cyan(path__default.default.join(pkg.name, exportPath)), exp];
+    })
+  ), logger.log(treeify__default.default.asTree(tree, !0, !0));
+}
+async function check(options) {
+  const { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger(), config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({ config: config2, cwd, logger, pkg, strict, tsconfig });
+  if (printPackageTree(ctx), strict) {
+    const missingFiles = [];
+    for (const [, exp] of Object.entries(ctx.exports || {}))
+      exp.source && !fileExists(path__default.default.resolve(cwd, exp.source)) && missingFiles.push(exp.source), exp.require && !fileExists(path__default.default.resolve(cwd, exp.require)) && missingFiles.push(exp.require), exp.import && !fileExists(path__default.default.resolve(cwd, exp.import)) && missingFiles.push(exp.import);
+    ctx.pkg.types && !fileExists(path__default.default.resolve(cwd, ctx.pkg.types)) && missingFiles.push(ctx.pkg.types), missingFiles.length && (logger.error(`missing files: ${missingFiles.join(", ")}`), process.exit(1));
+    const exportPaths = {
+      require: [],
+      import: []
+    };
+    for (const exp of Object.values(ctx.exports || {}))
+      exp._exported && (exp.require && exportPaths.require.push(exp.require), exp.import && exportPaths.import.push(exp.import));
+    const external = [
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {})
+    ], consoleSpy = createConsoleSpy();
+    exportPaths.import.length && checkExports(exportPaths.import, { cwd, external, format: "esm", logger }), exportPaths.require.length && checkExports(exportPaths.require, { cwd, external, format: "cjs", logger }), consoleSpy.restore();
+  }
+}
+async function checkExports(exportPaths, options) {
+  const { cwd, external, format, logger } = options, code = exportPaths.map((id) => format ? `import('${id}');` : `require('${id}');`).join(`
+`);
+  try {
+    const esbuildResult = await esbuild__default$1.default.build({
+      bundle: !0,
+      external,
+      format,
+      logLevel: "silent",
+      // otherwise output maps to stdout as we're using stdin
+      outfile: "/dev/null",
+      platform: "node",
+      stdin: {
+        contents: code,
+        loader: "js",
+        resolveDir: cwd
+      }
+    });
+    if (esbuildResult.errors.length > 0) {
+      for (const msg of esbuildResult.errors)
+        printEsbuildMessage(logger.warn, msg), logger.log();
+      process.exit(1);
+    }
+    const esbuildWarnings = esbuildResult.warnings.filter((msg) => {
+      (msg.detail || msg.text).includes("does not affect esbuild's own target setting");
+    });
+    for (const msg of esbuildWarnings)
+      printEsbuildMessage(logger.warn, msg), logger.log();
+  } catch (err) {
+    if (isEsbuildFailure(err)) {
+      const { errors } = err;
+      for (const msg of errors)
+        printEsbuildMessage(logger.error, msg), logger.log();
+    } else err instanceof Error ? (logger.error(err.stack || err.message), logger.log()) : (logger.error(`${err}`), logger.log());
+    process.exit(1);
+  }
+}
+function printEsbuildMessage(log, msg) {
+  msg.location ? log(
+    [
+      `${msg.detail || msg.text}
+`,
+      `${msg.location.line} | ${msg.location.lineText}
+`,
+      `in ./${msg.location.file}:${msg.location.line}:${msg.location.column}`
+    ].join("")
+  ) : log(msg.detail || msg.text);
+}
+function isEsbuildFailure(err) {
+  return err instanceof Error && "errors" in err && Array.isArray(err.errors) && err.errors.every(isEsbuildMessage) && "warnings" in err && Array.isArray(err.warnings) && err.warnings.every(isEsbuildMessage);
+}
+function isEsbuildMessage(msg) {
+  return typeof msg == "object" && msg !== null && "text" in msg && typeof msg.text == "string" && "location" in msg && (msg.location === null || typeof msg.location == "object");
+}
+function defineConfig(configOptions) {
+  return configOptions;
+}
+function defineTemplateOption(option) {
+  return option;
+}
+const promptsTypes = {
+  string: "text"
+};
+async function createFromTemplate(options) {
+  const { cwd, logger, packagePath, template: templateOrResolver } = options, template = typeof templateOrResolver == "function" ? await templateOrResolver({ cwd, logger, packagePath }) : templateOrResolver;
+  logger.log("create new package at", path.relative(cwd, packagePath));
+  const templateOptions = {};
+  for (const templateOption of template.options) {
+    const templateValidate = templateOption.validate, res = await prompts__default.default(
+      {
+        type: promptsTypes[templateOption.type],
+        name: templateOption.name,
+        message: templateOption.description,
+        validate: templateValidate ? (prev) => templateValidate(prev) : void 0,
+        initial: typeof templateOption.initial == "function" ? templateOption.initial(templateOptions) : templateOption.initial
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    templateOptions[templateOption.name] = templateOption.parse ? templateOption.parse(res[templateOption.name]) : res[templateOption.name];
+  }
+  const features = {};
+  for (const templateFeature of template.features) {
+    const res = templateFeature.optional ? await prompts__default.default(
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `use ${templateFeature.name}?`,
+        initial: templateFeature.initial
+      },
+      { onCancel: () => process.exit(0) }
+    ) : void 0;
+    features[templateFeature.name] = res?.confirm || !templateFeature.optional;
+  }
+  const files = await template.getFiles(templateOptions, features);
+  files.sort((a, b) => a.name.localeCompare(b.name));
+  for (const file of files) {
+    const filePath = path.resolve(packagePath, file.name);
+    await mkdirp.mkdirp(path.dirname(filePath)), await fs.writeFile(filePath, file.contents.trim() + `
+`), logger.success(`wrote ${path.relative(cwd, filePath)}`);
+  }
+}
+async function isEmptyDirectory(dirPath) {
+  return (await fs.readdir(dirPath)).length === 0;
+}
+const overridableDefaults = {
+  endOfLine: "lf",
+  tabWidth: 2,
+  useTabs: !1
+}, config = {
+  ...overridableDefaults,
+  printWidth: 100,
+  semi: !1,
+  singleQuote: !0,
+  quoteProps: "consistent",
+  bracketSpacing: !1,
+  plugins: ["prettier-plugin-packagejson"],
+  overrides: [
+    {
+      files: ["*.json5"],
+      options: {
+        quoteProps: "preserve",
+        singleQuote: !1
+      }
+    },
+    {
+      files: ["*.yml"],
+      options: {
+        singleQuote: !1
+      }
+    }
+  ]
+}, RE_NAME = /^(?:@(?:[a-z0-9-*~][a-z0-9-*._~]*)\/)?[a-z0-9-~][a-z0-9-._~]*$/i, defaultTemplate = async ({ cwd, logger, packagePath }) => {
+  const gitConfig = getGitUserConfig(cwd);
+  return {
+    options: [
+      {
+        name: "repo",
+        type: "string",
+        description: "git url",
+        validate: (v) => {
+          if (!v) return !0;
+          try {
+            return gitUrlParse__default.default(v), !0;
+          } catch {
+            return "invalid git url";
+          }
+        },
+        parse: (v) => {
+          if (!v) return null;
+          const result = gitUrlParse__default.default(v);
+          return { source: result.source, owner: result.owner, name: result.name };
+        }
+      },
+      {
+        name: "pkgName",
+        type: "string",
+        description: "package name",
+        initial: (options) => options.repo?.name || void 0,
+        validate: (v) => v ? RE_NAME.exec(v) ? !0 : "invalid package name" : "package name is required",
+        parse: (v) => {
+          if (!v)
+            throw new Error("package name is required");
+          if (!RE_NAME.exec(v))
+            throw new Error("invalid package name");
+          const [scope, name] = v.split("/");
+          return { scope, name, fullName: v };
+        }
+      },
+      {
+        name: "description",
+        type: "string",
+        description: "package description"
+      },
+      {
+        name: "authorName",
+        type: "string",
+        description: "package author name",
+        initial: gitConfig.user
+      },
+      {
+        name: "authorEmail",
+        type: "string",
+        description: "package author email",
+        initial: gitConfig.email
+      },
+      {
+        name: "license",
+        type: "string",
+        description: "package license",
+        initial: "MIT",
+        validate: (v) => v ? !0 : "license is required"
+      }
+    ],
+    features: [
+      {
+        name: "eslint",
+        optional: !0,
+        initial: !0
+      },
+      {
+        name: "prettier",
+        optional: !0,
+        initial: !0
+      },
+      {
+        name: "typescript",
+        optional: !0,
+        initial: !0
+      }
+    ],
+    async getFiles(options, features) {
+      const { pkgName, repo } = options, { fullName: name } = pkgName, author = [options.authorName, options.authorEmail && `<${options.authorEmail}>`].filter(Boolean).join(" ") ?? void 0, pkgJson = {
+        name,
+        version: "0.0.0",
+        description: options.description ?? void 0,
+        keywords: [],
+        homepage: void 0,
+        bugs: void 0,
+        repository: void 0,
+        license: options.license,
+        author,
+        sideEffects: !1,
+        type: "module",
+        exports: {
+          ".": {
+            source: features.typescript ? "./src/index.ts" : "./src/index.js",
+            require: "./dist/index.cjs",
+            default: "./dist/index.js"
+          },
+          "./package.json": "./package.json"
+        },
+        main: "./dist/index.cjs",
+        module: "./dist/index.js",
+        types: void 0,
+        files: ["dist", "src"],
+        scripts: {
+          build: "pkg build --strict --clean --check",
+          format: features.prettier ? "prettier --write --cache --ignore-unknown ." : void 0
+        },
+        "lint-staged": features.prettier ? {
+          "*": ["prettier --write --cache --ignore-unknown"]
+        } : void 0,
+        browserslist: "extends @sanity/browserslist-config",
+        prettier: features.prettier ? "@sanity/prettier-config" : void 0,
+        dependencies: {},
+        devDependencies: {
+          "@sanity/pkg-utils": "^6",
+          "@sanity/prettier-config": features.prettier ? "^1" : void 0,
+          "@typescript-eslint/eslint-plugin": void 0,
+          "@typescript-eslint/parser": void 0,
+          eslint: void 0,
+          "eslint-config-prettier": void 0,
+          "eslint-plugin-import": void 0,
+          "eslint-plugin-prettier": void 0,
+          "eslint-plugin-simple-import-sort": void 0,
+          "lint-staged": "^15",
+          prettier: features.prettier ? "^3" : void 0,
+          typescript: void 0
+        },
+        engines: {
+          node: ">=18.0.0"
+        }
+      }, files = [];
+      if (files.push({
+        name: ".editorconfig",
+        contents: outdent.outdent`
+        root = true
+
+        [*]
+        charset = utf-8
+        indent_style = space
+        indent_size = 2
+        end_of_line = lf
+        insert_final_newline = true
+        trim_trailing_whitespace = true
+        `
+      }), files.push({
+        name: ".gitignore",
+        contents: outdent.outdent`
+        *.local
+        *.log
+        *.tgz
+
+        .DS_Store
+        dist
+        etc
+        node_modules
+        `
+      }), features.prettier && files.push({
+        name: ".prettierignore",
+        contents: outdent.outdent`
+          dist
+          pnpm-lock.yaml
+          `
+      }), repo && (pkgJson.repository = {
+        type: "git",
+        url: `git+ssh://git@${repo.source}/${repo.owner}/${repo.name}.git`
+      }, pkgJson.bugs = {
+        url: `https://${repo.source}/${repo.owner}/${repo.name}/issues`
+      }, pkgJson.homepage = `https://${repo.source}/${repo.owner}/${repo.name}#readme`), features.typescript) {
+        pkgJson.types = "./dist/index.d.ts", pkgJson.scripts = {
+          ...pkgJson.scripts,
+          "ts:check": "tsc --noEmit"
+        };
+        const devDependencies = pkgJson.devDependencies;
+        isRecord(devDependencies) && (devDependencies.typescript = "^5.4");
+      }
+      if (features.eslint) {
+        const eslintConfig = {
+          root: !0,
+          env: {
+            browser: !0,
+            es6: !0,
+            node: !0
+          },
+          extends: [
+            "eslint:recommended",
+            features.prettier ? "plugin:prettier/recommended" : void 0
+          ].filter(Boolean),
+          parserOptions: {
+            ecmaVersion: 2020,
+            sourceType: "module"
+          },
+          plugins: [
+            "import",
+            "simple-import-sort",
+            features.prettier ? "prettier" : void 0
+          ].filter(Boolean),
+          rules: {
+            "no-console": "error",
+            "no-shadow": "error",
+            "no-warning-comments": ["warn", { location: "start", terms: ["todo", "fixme"] }],
+            "quote-props": ["warn", "consistent-as-needed"],
+            "simple-import-sort/exports": "warn",
+            "simple-import-sort/imports": "warn",
+            strict: ["warn", "global"]
+          }
+        };
+        if (files.push({
+          name: ".eslintignore",
+          contents: outdent.outdent`
+          dist
+          `
+        }), pkgJson.scripts = {
+          ...pkgJson.scripts,
+          lint: features.typescript ? "eslint . --ext .cjs,.js,.ts,.tsx" : "eslint . --ext .cjs,.js"
+        }, pkgJson.devDependencies = {
+          ...pkgJson.devDependencies,
+          eslint: "^8",
+          "eslint-config-prettier": features.prettier ? "^9" : void 0,
+          "eslint-plugin-import": "^2",
+          "eslint-plugin-prettier": features.prettier ? "^5" : void 0,
+          "eslint-plugin-simple-import-sort": "^12"
+        }, features.typescript) {
+          pkgJson.devDependencies = {
+            ...pkgJson.devDependencies,
+            "@typescript-eslint/eslint-plugin": "^7",
+            "@typescript-eslint/parser": "^7"
+          };
+          const eslintConfigOverride = {
+            files: ["**/*.ts", "**/*.tsx"],
+            parser: "@typescript-eslint/parser",
+            parserOptions: {
+              project: ["./tsconfig.json"]
+            },
+            extends: [
+              "eslint:recommended",
+              features.prettier ? "plugin:prettier/recommended" : void 0,
+              "plugin:@typescript-eslint/eslint-recommended",
+              "plugin:@typescript-eslint/recommended"
+            ].filter(Boolean),
+            plugins: [
+              "import",
+              "@typescript-eslint",
+              "simple-import-sort",
+              features.prettier ? "prettier" : void 0
+            ].filter(Boolean),
+            rules: {
+              "@typescript-eslint/explicit-module-boundary-types": "error",
+              "@typescript-eslint/interface-name-prefix": "off",
+              "@typescript-eslint/member-delimiter-style": "off",
+              "@typescript-eslint/no-empty-interface": "off"
+            }
+          };
+          eslintConfig.overrides = [eslintConfigOverride];
+        }
+        files.push({
+          name: ".eslintrc.cjs",
+          contents: await prettierFormat(
+            path.resolve(packagePath, ".eslintrc.cjs"),
+            outdent.outdent`
+            'use strict'
+
+            /** @type import('eslint').Linter.Config */
+            module.exports = ${JSON.stringify(eslintConfig, null, 2)}
+            `,
+            config
+          )
+        });
+      }
+      features.typescript && (files.push({
+        name: "tsconfig.settings.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.settings.json"),
+          outdent.outdent`
+            {
+              "extends": "@sanity/pkg-utils/tsconfig/strictest.json",
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist"
+              }
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.dist.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.dist.json"),
+          outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./src"],
+              "exclude": ["./src/**/*.test.ts"]
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.json"),
+          outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./**/*.cjs", "./**/*.ts", "./**/*.tsx"],
+              "exclude": ["./node_modules"]
+            }
+            `,
+          config
+        )
+      })), features.typescript ? (files.push({
+        name: "package.config.ts",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.config.ts"),
+          outdent.outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            // https://github.com/sanity-io/pkg-utils#configuration
+            export default defineConfig({
+              // the path to the tsconfig file for distributed builds
+              tsconfig: 'tsconfig.dist.json',
+            })
+            `,
+          config
+        )
+      }), files.push({
+        name: "src/index.ts",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "src/index.ts"),
+          outdent.outdent`
+            /** @public */
+            export function main(): void {
+              //
+            }
+            `,
+          config
+        )
+      })) : (files.push({
+        name: "package.config.js",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.config.js"),
+          outdent.outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            export default defineConfig({
+              extract: {
+                rules: {
+                  // do not require internal members to be prefixed with \`_\`
+                  'ae-internal-missing-underscore': 'off',
+                },
+              },
+            })
+            `,
+          config
+        )
+      }), files.push({
+        name: "src/index.js",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "src/index.js"),
+          outdent.outdent`
+            /** @public */
+            export function main() {
+              //
+            }
+            `,
+          config
+        )
+      }));
+      try {
+        pkgJson.dependencies = await resolveLatestDeps(pkgJson.dependencies ?? {});
+      } catch (error) {
+        logger.warn(error instanceof Error ? error.message : error);
+      }
+      try {
+        pkgJson.devDependencies = await resolveLatestDeps(pkgJson.devDependencies ?? {});
+      } catch (error) {
+        logger.warn(error instanceof Error ? error.message : error);
+      }
+      return files.push({
+        name: "package.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.json"),
+          JSON.stringify(pkgJson, null, 2),
+          config
+        )
+      }), files;
+    }
+  };
+};
+function prettierFormat(filepath, input, prettierOptions) {
+  return prettier.format(input, { ...prettierOptions, plugins: [], filepath });
+}
+async function resolveLatestDeps(deps) {
+  const depsEntries = Object.entries(deps), latestDeps = {};
+  for (const entry of depsEntries) {
+    const [name, version] = entry;
+    if (version) {
+      const latestVersion = await getLatestVersion__default.default(name, version);
+      latestDeps[name] = latestVersion ? `^${latestVersion}` : version;
+    }
+  }
+  return latestDeps;
+}
+function getGitUserConfig(cwd) {
+  let user, email;
+  try {
+    user = node_child_process.execSync("git config user.name", { encoding: "utf8", cwd }).trim() || void 0, email = node_child_process.execSync("git config user.email", { encoding: "utf8", cwd }).trim() || void 0;
+  } catch {
+  }
+  return { user, email };
+}
+async function init(options) {
+  if (!options.cwd)
+    throw new Error("Missing required option: cwd");
+  if (!options.path)
+    throw new Error("Missing required option: path");
+  const logger = createLogger(), packagePath = path.resolve(options.cwd, options.path);
+  await ensurePackagePath(packagePath), await createFromTemplate({
+    cwd: options.cwd,
+    logger,
+    template: defaultTemplate,
+    packagePath
+  });
+}
+async function ensurePackagePath(packagePath) {
+  if (!fileExists(packagePath)) {
+    await mkdirp.mkdirp(packagePath);
+    return;
+  }
+  if (!(await fs.lstat(packagePath)).isDirectory())
+    throw new Error("the package path is a file, not a directory");
+  if (!await isEmptyDirectory(packagePath))
+    throw new Error("the package directory is not empty");
+}
+function resolveWatchTasks(ctx) {
+  const { pkg, target } = ctx, tasks = [], exports2 = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "watch:dts",
+    entries: []
+  }, rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    const buildId = `${format}:${runtime}`;
+    rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "watch:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    };
+  }
+  for (const exp of exports2) {
+    const importId = path__default.default.join(pkg.name, exp._path);
+    exp.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.source,
+      targetPaths: getTargetPaths(pkg.type, exp)
+    }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.browser.source,
+      targetPaths: getTargetPaths(pkg.type, exp.browser)
+    }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.node.source,
+      targetPaths: getTargetPaths(pkg.type, exp.node)
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.import;
+    output && addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  return dtsTask2.entries.length && tasks.push(dtsTask2), tasks.push(...Object.values(rollupTasks)), tasks;
+}
+function globFiles(patterns) {
+  return globby__default.default(patterns.map((pattern) => pattern.split(path__default.default.sep).join(path__default.default.posix.sep)));
+}
+function watchFiles(patterns) {
+  return new rxjs.Observable((observer) => {
+    const watcher = chokidar__namespace.watch(patterns, {
+      ignoreInitial: !0
+    });
+    function handleFileEvent(type, file) {
+      type === "error" || file instanceof Error ? observer.error(file) : observer.next({ type, file });
+    }
+    return watcher.on("all", handleFileEvent), () => {
+      watcher.off("all", handleFileEvent), watcher.close();
+    };
+  });
+}
+async function watchConfigFiles(options) {
+  const { cwd, logger } = options, initialFiles = await globFiles([
+    path__default.default.resolve(cwd, "package.json"),
+    path__default.default.resolve(cwd, "package.config.cjs"),
+    path__default.default.resolve(cwd, "package.config.js"),
+    path__default.default.resolve(cwd, "package.config.ts")
+  ]);
+  return watchFiles([
+    path__default.default.resolve(cwd, "package.json"),
+    path__default.default.resolve(cwd, "package.config.cjs"),
+    path__default.default.resolve(cwd, "package.config.js"),
+    path__default.default.resolve(cwd, "package.config.ts")
+  ]).pipe(
+    operators.scan((files, fileEvent) => fileEvent.type === "add" ? files.concat(fileEvent.file) : fileEvent.type === "unlink" ? files.filter((f) => f !== fileEvent.file) : fileEvent.type === "change" ? (logger.log(
+      "--------------------------------------------------------------------------------"
+    ), logger.info(path__default.default.relative(cwd, fileEvent.file), "changed"), logger.log(""), files.slice(0)) : files, initialFiles),
+    operators.startWith(initialFiles),
+    operators.distinctUntilChanged()
+  );
+}
+async function watch(options) {
+  const { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger();
+  (await watchConfigFiles({ cwd, logger })).pipe(
+    rxjs.switchMap(async (configFiles) => {
+      if (!configFiles.map((f) => path__default.default.relative(cwd, f)).find((f) => f === "package.json"))
+        throw new Error("missing package.json");
+      const config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json";
+      return resolveBuildContext({ config: config2, cwd, logger, pkg, strict, tsconfig });
+    })
+  ).subscribe(async (ctx) => {
+    const watchTasks = resolveWatchTasks(ctx);
+    for (const task of watchTasks) {
+      const handler = watchTaskHandlers[task.type];
+      handler.exec(ctx, task).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();
+        }
+      });
+    }
+  });
+}
+exports.DEFAULT_BROWSERSLIST_QUERY = DEFAULT_BROWSERSLIST_QUERY;
+exports.build = build;
+exports.check = check;
+exports.createLogger = createLogger;
+exports.defineConfig = defineConfig;
+exports.defineTemplateOption = defineTemplateOption;
 exports.getExtractMessagesConfig = getExtractMessagesConfig;
-exports.watchTaskHandlers = watchTaskHandlers;
+exports.init = init;
+exports.loadConfig = loadConfig;
+exports.loadPkg = loadPkg;
+exports.loadPkgWithReporting = loadPkgWithReporting;
+exports.parseExports = parseExports;
+exports.parseStrictOptions = parseStrictOptions;
+exports.pkgExtMap = pkgExtMap;
+exports.strictOptions = strictOptions;
+exports.toggle = toggle;
+exports.watch = watch;
 //# sourceMappingURL=index.cjs.map