@sanity/pkg-utils 7.2.10-canary.1 → 7.2.10-canary.3

package/dist/_chunks-es/index.js

@@ -0,0 +1,2311 @@
+import path, { resolve, relative, dirname } from "node:path";
+import * as rimraf from "rimraf";
+import { rimraf as rimraf$1 } from "rimraf";
+import { register } from "esbuild-register/dist/node";
+import pkgUp from "pkg-up";
+import findConfig from "find-config";
+import { statSync, existsSync } from "node:fs";
+import chalk from "chalk";
+import { z, ZodError } from "zod";
+import fs, { readFile, writeFile, readdir, lstat } from "node:fs/promises";
+import browserslist from "browserslist";
+import config$1 from "@sanity/browserslist-config";
+import ts from "typescript";
+import { errorMap } from "zod-validation-error";
+import { Observable, from, switchMap } from "rxjs";
+import { ExtractorConfig, Extractor } from "@microsoft/api-extractor";
+import { mkdirp } from "mkdirp";
+import * as prettier from "prettier";
+import { format } 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.js";
+import { rollup, watch as watch$1 } from "rollup";
+import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
+import alias from "@rollup/plugin-alias";
+import { babel, getBabelOutputPlugin } from "@rollup/plugin-babel";
+import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import replace from "@rollup/plugin-replace";
+import terser from "@rollup/plugin-terser";
+import esbuild from "rollup-plugin-esbuild";
+import esbuild$1 from "esbuild";
+import treeify from "treeify";
+import prettyBytes from "pretty-bytes";
+import prompts from "prompts";
+import { execSync } from "node:child_process";
+import getLatestVersion from "get-latest-version";
+import gitUrlParse from "git-url-parse";
+import { outdent } from "outdent";
+import { scan, startWith, distinctUntilChanged } from "rxjs/operators";
+import globby from "globby";
+import * as chokidar from "chokidar";
+function fileExists(filePath) {
+  try {
+    return 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("package.json", { cwd });
+  if (!pkgJsonPath) return;
+  const pkgPath = path.dirname(pkgJsonPath);
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = path.resolve(pkgPath, fileName);
+    if (fileExists(configPath))
+      return configPath;
+  }
+}
+async function loadConfig(options) {
+  const { cwd } = options, pkgPath = await pkgUp({ cwd });
+  if (!pkgPath) return;
+  const root = path.dirname(pkgPath), configFile = await findConfigFile(root);
+  if (!configFile || !configFile.startsWith(cwd))
+    return;
+  const esbuildOptions = { extensions: [".js", ".mjs", ".ts"] }, { unregister } = globalThis.__DEV__ ? { unregister: () => {
+  } } : register(esbuildOptions), mod = require(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 = 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.custom((val) => /^\.\/.*\.css$/.test(val)),
+        z.object({
+          types: z.optional(z.string()),
+          source: z.optional(z.string()),
+          browser: z.optional(
+            z.object({
+              source: z.string(),
+              import: z.optional(z.string()),
+              require: z.optional(z.string())
+            })
+          ),
+          node: z.optional(
+            z.object({
+              source: z.optional(z.string()),
+              import: z.optional(z.string()),
+              require: z.optional(z.string())
+            })
+          ),
+          import: z.optional(z.string()),
+          require: z.optional(z.string()),
+          default: z.string()
+        }),
+        z.object({
+          types: z.optional(z.string()),
+          svelte: z.string(),
+          default: z.optional(z.string())
+        })
+      ])
+    )
+  ),
+  browserslist: z.optional(z.union([z.string(), z.array(z.string())])),
+  sideEffects: z.optional(z.union([z.boolean(), z.array(z.string())])),
+  // @TODO type this properly
+  typesVersions: z.optional(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({ cwd });
+  if (!pkgPath) throw new Error("no package.json found");
+  const buf = await fs.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 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.magenta(issue.expected)} `,
+              `(received ${chalk.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.blue("[info]"), ...args);
+    },
+    warn: (...args) => {
+      console.log(chalk.yellow("[warning]"), ...args);
+    },
+    error: (...args) => {
+      console.log(chalk.red("[error]"), ...args);
+    },
+    success: (...args) => {
+      console.log(chalk.green("[success]"), ...args);
+    }
+  };
+}
+function browserslistToEsbuild(browserslistConfig, options = {}) {
+  if (!browserslistConfig) {
+    const path2 = process.cwd();
+    browserslistConfig = browserslist.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(browserslistConfig, options).filter((b) => !UNSUPPORTED.some((u) => b.startsWith(u))).map((b) => b === "safari TP" ? browserslist("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$1;
+function pathContains(containerPath, itemPath) {
+  return !path.relative(containerPath, itemPath).startsWith("..");
+}
+function findCommonDirPath(filePaths) {
+  let ret;
+  for (const filePath of filePaths) {
+    let dirPath = path.dirname(filePath);
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+    for (; dirPath !== ret && (dirPath = path.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" && !existsSync(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.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+  if (!configPath)
+    return;
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  return ts.parseJsonConfigFileContent(configFile.config, ts.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 = z.union([z.literal("error"), z.literal("warn"), z.literal("off")]), strictOptions = 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 = z.object({
+  strictOptions: strictOptions.default({})
+});
+function parseStrictOptions(input) {
+  return validationSchema.parse({ strictOptions: input }, { 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 }),
+    {}
+  ), exports = 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(exports).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.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.resolve(cwd, config2.dist) : void 0;
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath))
+    throw logger.log(`did you mean to configure \`dist: './${path.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,
+    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 = [], exports = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "build:dts",
+    entries: []
+  }, rolldownDtsTask2 = {}, rollupTasks = {};
+  function addRollupTaskEntry(format2, runtime, entry) {
+    const buildId = `${format2}:${runtime}`;
+    ctx.dts === "rolldown" && (rolldownDtsTask2[buildId] ? rolldownDtsTask2[buildId].entries.push(entry) : rolldownDtsTask2[buildId] = {
+      type: "rolldown:dts",
+      buildId,
+      entries: [entry],
+      runtime,
+      format: format2,
+      target: target[runtime]
+    }), ctx.emitDeclarationOnly || (rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "build:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format: format2,
+      target: target[runtime]
+    });
+  }
+  if (ctx.dts === "api-extractor") {
+    for (const exp of exports) {
+      const importId = path.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.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 exports) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    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.green("[success]")} ${chalk.gray(`${Date.now() - startTime}ms`)}`);
+    },
+    error: () => {
+      console.log(`${chalk.red("[error]")} ${chalk.gray(`${Date.now() - startTime}ms`)}`);
+    }
+  };
+}
+function printExtractMessages(ctx, messages) {
+  const { cwd, logger } = ctx, warnings = messages.filter((msg) => msg.logLevel === "warning");
+  warnings.length && logger.log();
+  for (const msg of warnings) {
+    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
+    msg.messageId !== "TS6307" && logger.log(
+      [
+        `${chalk.cyan(sourceFilePath || "?")}`,
+        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk.yellow("warning")} ${chalk.gray(msg.messageId)}
+`,
+        msg.text,
+        `
+`
+      ].join("")
+    );
+  }
+  const errors = messages.filter((msg) => msg.logLevel === "error");
+  !warnings.length && errors.length && logger.log("");
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath);
+    logger.log(
+      [
+        `${chalk.cyan(sourceFilePath || "?")}`,
+        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk.red("error")} ${chalk.gray(msg.messageId)}
+`,
+        msg.text,
+        `
+`
+      ].join("")
+    );
+  }
+  errors.length && process.exit(1);
+}
+function printDiagnostic(options) {
+  const { cwd, logger, diagnostic } = options;
+  if (diagnostic.file && diagnostic.start) {
+    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`), file = path.relative(cwd, diagnostic.file.fileName), output = [
+      `${chalk.yellow(file)}:${chalk.blue(line + 1)}:${chalk.blue(character + 1)} - `,
+      `${chalk.gray(`TS${diagnostic.code}:`)} ${message}`
+    ].join("");
+    diagnostic.category === ts.DiagnosticCategory.Error && logger.error(output), diagnostic.category === ts.DiagnosticCategory.Warning && logger.warn(output), diagnostic.category === ts.DiagnosticCategory.Message && logger.log(output), diagnostic.category === ts.DiagnosticCategory.Suggestion && logger.log(output);
+  } else
+    logger.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+}
+async function buildTypes(options) {
+  const { cwd, logger, outDir, tsconfig, strict = !1 } = options, compilerOptions = {
+    ...tsconfig.options,
+    declaration: !0,
+    declarationDir: outDir,
+    emitDeclarationOnly: !0,
+    noEmit: !1,
+    noEmitOnError: strict ? !0 : tsconfig.options.noEmitOnError ?? !0,
+    outDir
+  }, program = ts.createProgram(tsconfig.fileNames, compilerOptions), emitResult = program.emit(), allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  for (const diagnostic of allDiagnostics)
+    printDiagnostic({ cwd, logger, diagnostic });
+  if (emitResult.emitSkipped && allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error).length)
+    throw new Error("failed to compile TypeScript definitions");
+}
+class DtsError extends Error {
+  messages;
+  constructor(message, messages) {
+    super(message), this.messages = messages;
+  }
+}
+function createApiExtractorConfig(options) {
+  const {
+    bundledPackages,
+    distPath,
+    exportPath,
+    filePath,
+    messages,
+    projectFolder,
+    mainEntryPointFilePath,
+    tsconfig,
+    tsconfigPath,
+    dtsRollupEnabled
+  } = options;
+  return {
+    apiReport: {
+      enabled: !1,
+      reportFileName: "<unscopedPackageName>.api.md"
+    },
+    bundledPackages,
+    // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
+    compiler: tsconfig.options.paths ? {
+      overrideTsconfig: {
+        extends: tsconfigPath,
+        compilerOptions: {
+          // An empty object replaces whatever is in the original tsconfig file
+          paths: {}
+        }
+      }
+    } : { tsconfigFilePath: tsconfigPath },
+    docModel: {
+      enabled: !1,
+      apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`)
+    },
+    dtsRollup: {
+      enabled: dtsRollupEnabled,
+      untrimmedFilePath: path.resolve(distPath, filePath)
+      // betaTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-beta.d.ts')),
+      // publicTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-public.d.ts')),
+    },
+    tsdocMetadata: {
+      enabled: !1
+    },
+    messages,
+    mainEntryPointFilePath,
+    projectFolder
+  };
+}
+async function createTSDocConfig(opts) {
+  const { customTags } = opts;
+  if (customTags.length === 0)
+    return;
+  const tsDocBaseBuf = await readFile(
+    require.resolve("@microsoft/api-extractor/extends/tsdoc-base.json")
+  ), tsDocBaseConfig = parse(tsDocBaseBuf.toString()), tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
+    customTags.map((t) => ({
+      tagName: `@${t.name}`,
+      syntaxKind: t.syntaxKind,
+      allowMultiple: t.allowMultiple
+    }))
+  ), supportForTags = { ...tsDocBaseConfig.supportForTags };
+  for (const customTag of customTags)
+    supportForTags[`@${customTag.name}`] = !0;
+  return TSDocConfigFile.loadFromObject({
+    ...tsDocBaseConfig,
+    noStandardTags: !1,
+    tagDefinitions,
+    supportForTags
+  });
+}
+async function extractModuleBlocksFromTypes({
+  tsOutDir,
+  extractResult
+}) {
+  const program = extractResult.compilerState.program, moduleBlocks = [], sourceFiles = [...program.getSourceFiles()].filter((sourceFile) => sourceFile.fileName.includes(tsOutDir));
+  for (const sourceFile of sourceFiles)
+    sourceFile.text.includes("declare module") && moduleBlocks.push(...extractModuleBlocks(sourceFile.text));
+  return moduleBlocks;
+}
+function extractModuleBlocks(fileContent) {
+  return parse$1(fileContent, {
+    parser: typeScriptParser
+  }).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, disabled = !1 } = options;
+  function ruleToLogLevel(key, defaultLevel) {
+    const r = rules?.[key];
+    return r ? LOG_LEVELS[r] : defaultLevel || "warning";
+  }
+  return {
+    compilerMessageReporting: {
+      default: {
+        logLevel: disabled ? "none" : "warning"
+      }
+    },
+    extractorMessageReporting: disabled ? {
+      default: {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    } : {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: !1
+      },
+      "ae-forgotten-export": {
+        /**
+         * This is hardcoded to `none` as it's no longer needed since TypeScript 5.5 https://github.com/microsoft/TypeScript/issues/42873
+         * It's hardcoded to `none` since supported by API Extractor when using `module: 'Preserve'` doesn't support it well since `@microsoft/api-extractor` v7.49.0, which upgraded from TS 5.4 to 5.7 internally
+         */
+        logLevel: "none",
+        addToApiReportFile: !1
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: ruleToLogLevel("ae-incompatible-release-tags", "error"),
+        addToApiReportFile: !1
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: ruleToLogLevel("ae-internal-missing-underscore"),
+        addToApiReportFile: !1
+      },
+      "ae-missing-release-tag": {
+        logLevel: ruleToLogLevel("ae-missing-release-tag", "error"),
+        addToApiReportFile: !1
+      },
+      "ae-wrong-input-file-type": {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    },
+    tsdocMessageReporting: disabled ? {
+      default: {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    } : {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: !1
+      },
+      "tsdoc-link-tag-unescaped-text": {
+        logLevel: ruleToLogLevel(
+          "tsdoc-link-tag-unescaped-text",
+          "warning"
+        ),
+        addToApiReportFile: !1
+      },
+      "tsdoc-undefined-tag": {
+        logLevel: ruleToLogLevel("tsdoc-undefined-tag", "error"),
+        addToApiReportFile: !1
+      },
+      "tsdoc-unsupported-tag": {
+        logLevel: ruleToLogLevel("tsdoc-unsupported-tag", "none"),
+        addToApiReportFile: !1
+      }
+    }
+  };
+}
+async function extractTypes(options) {
+  const {
+    bundledPackages,
+    customTags,
+    distPath,
+    exportPath,
+    files,
+    filePaths,
+    projectPath,
+    rules,
+    sourceTypesPath,
+    tmpPath,
+    tsconfig,
+    tsconfigPath,
+    extractorDisabled
+  } = options, tsdocConfigFile = await createTSDocConfig({
+    customTags: customTags || []
+  }), filePath = filePaths[0].replace(/\.d\.[mc]ts$/, ".d.ts"), shouldCleanUpDts = !filePaths.includes(filePath), extractorConfig = ExtractorConfig.prepare({
+    configObject: createApiExtractorConfig({
+      bundledPackages,
+      distPath,
+      exportPath,
+      filePath,
+      messages: getExtractMessagesConfig({ rules, disabled: extractorDisabled }),
+      projectFolder: projectPath,
+      mainEntryPointFilePath: sourceTypesPath,
+      tsconfig,
+      tsconfigPath,
+      dtsRollupEnabled: !0
+    }),
+    configObjectFullPath: void 0,
+    tsdocConfigFile,
+    packageJsonFullPath: path.resolve(projectPath, "package.json")
+  }), messages = [], extractorResult = Extractor.invoke(extractorConfig, {
+    // Equivalent to the "--local" command-line parameter
+    localBuild: !0,
+    // Equivalent to the "--verbose" command-line parameter
+    showVerboseMessages: !0,
+    // handle messages
+    messageCallback(message) {
+      messages.push(message), message.handled = !0;
+    }
+  }), typesPath = path.resolve(distPath, filePath), typesBuf = await fs.readFile(typesPath), prettierConfig = await prettier.resolveConfig(typesPath);
+  await mkdirp(path.dirname(typesPath));
+  const moduleBlocks = await extractModuleBlocksFromTypes({
+    extractResult: extractorResult,
+    tsOutDir: tmpPath
+  }), code = [typesBuf.toString(), ...moduleBlocks].join(`
+
+`), prettyCode = await prettier.format(code, {
+    ...prettierConfig,
+    filepath: typesPath
+  });
+  for (const expFilePath of filePaths) {
+    const expTypesPath = path.resolve(distPath, expFilePath);
+    await fs.writeFile(expTypesPath, prettyCode), files.push({
+      type: "types",
+      path: expTypesPath
+    });
+  }
+  return shouldCleanUpDts && await fs.unlink(typesPath), { extractorResult, messages };
+}
+async function doExtract(ctx, task) {
+  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;
+  if (!outDir)
+    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
+  const tmpPath = path.resolve(outDir, "__tmp__");
+  await buildTypes({ cwd, logger, outDir: tmpPath, strict, tsconfig: ts2.config });
+  const messages = [], results = [];
+  for (const entry of task.entries) {
+    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path.resolve(
+      tmpPath,
+      path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
+    ), targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath)), result = await extractTypes({
+      bundledPackages: bundledPackages || [],
+      customTags: config2?.extract?.customTags,
+      distPath: outDir,
+      exportPath,
+      files,
+      filePaths,
+      projectPath: cwd,
+      rules: config2?.extract?.rules,
+      sourceTypesPath,
+      tsconfig: ts2.config,
+      tmpPath,
+      tsconfigPath: path.resolve(cwd, ts2.configPath || "tsconfig.json"),
+      extractorDisabled: config2?.extract?.enabled === !1
+    });
+    messages.push(...result.messages);
+    const errors = result.messages.filter((msg) => msg.logLevel === "error");
+    if (errors.length > 0)
+      throw await rimraf$1(tmpPath), new DtsError(`encountered ${errors.length} errors when extracting types`, errors);
+    results.push({ sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
+  }
+  return await rimraf$1(tmpPath), { type: "dts", messages, results };
+}
+const dtsTask = {
+  name: (ctx, task) => [
+    `Build type definitions with ${chalk.bold(ctx.dts)}...`,
+    "  entries:",
+    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
+      `    - ${chalk.cyan(entry.importId)}: `,
+      `${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(targetPath)}`
+    ].join("")).join(`
+`))
+  ].join(`
+`),
+  exec: (ctx, task) => 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;
+    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
+  }
+}, dtsWatchTask = {
+  name: (_ctx, task) => [
+    "build type definitions",
+    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
+      `    - ${chalk.cyan(entry.importId)}: `,
+      `${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(targetPath)}`
+    ].join("")))
+  ].join(`
+`),
+  exec: (ctx, task) => {
+    const { config: config2, cwd, files, logger, strict, ts: tsContext, bundledPackages } = ctx;
+    return new Observable((observer) => {
+      if (!tsContext.config || !tsContext.configPath) {
+        observer.next({ type: "dts", messages: [], results: [] }), observer.complete();
+        return;
+      }
+      const { outDir, rootDir = cwd } = tsContext.config.options;
+      if (!outDir) {
+        observer.error(new Error("tsconfig.json is missing `compilerOptions.outDir`"));
+        return;
+      }
+      const tmpPath = path.resolve(outDir, "__tmp__");
+      buildTypes({
+        cwd,
+        logger,
+        outDir: tmpPath,
+        tsconfig: tsContext.config,
+        strict
+      }).catch((err) => {
+        observer.error(err);
+      });
+      const host = ts.createWatchCompilerHost(
+        tsContext.configPath,
+        {
+          ...tsContext.config.options,
+          declaration: !0,
+          declarationDir: tmpPath,
+          emitDeclarationOnly: !0,
+          noEmit: !1,
+          noEmitOnError: strict ? !0 : tsContext.config.options.noEmitOnError ?? !0,
+          outDir: tmpPath
+        },
+        ts.sys,
+        ts.createEmitAndSemanticDiagnosticsBuilderProgram,
+        (diagnostic) => {
+          logger.error(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+        },
+        (diagnostic) => {
+          logger.info(ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+        }
+      ), origPostProgramCreate = host.afterProgramCreate;
+      host.afterProgramCreate = async (program) => {
+        origPostProgramCreate?.(program);
+        const messages = [], results = [];
+        for (const entry of task.entries) {
+          const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path.resolve(
+            tmpPath,
+            path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
+          ), targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath));
+          try {
+            const result = await extractTypes({
+              bundledPackages: bundledPackages || [],
+              customTags: config2?.extract?.customTags,
+              cwd,
+              distPath: outDir,
+              exportPath,
+              files,
+              filePaths,
+              projectPath: cwd,
+              rules: config2?.extract?.rules,
+              sourceTypesPath,
+              tsconfig: tsContext.config,
+              tmpPath,
+              tsconfigPath: path.resolve(cwd, tsContext.configPath || "tsconfig.json"),
+              extractorDisabled: config2?.extract?.enabled === !1
+            });
+            messages.push(...result.messages), results.push({ sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
+          } catch (err) {
+            if (err instanceof DtsError)
+              messages.push(...err.messages);
+            else {
+              observer.error(err);
+              return;
+            }
+          }
+        }
+        observer.next({ type: "dts", messages, results });
+      };
+      const watchProgram = ts.createWatchProgram(host);
+      return () => {
+        watchProgram.close(), rimraf.sync(tmpPath);
+      };
+    });
+  },
+  complete: (ctx, task, result) => {
+    const { logger } = ctx;
+    printExtractMessages(ctx, result.messages), logger.success(
+      `build type definitions
+       ${task.entries.map(
+        (entry) => `    - ${chalk.cyan(entry.importId)}: ${chalk.yellow(entry.sourcePath)} ${chalk.gray("\u2192")} ${chalk.yellow(entry.targetPaths.join(", "))}`
+      ).join(`
+       `)}`
+    ), logger.log("");
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
+  }
+};
+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.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
+      "  bundles:",
+      ...bundleEntries.map(
+        (e) => [
+          "    - ",
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [], entriesLines = entries.length ? [
+      "  entries:",
+      ...entries.map(
+        (e) => [
+          "    - ",
+          `${chalk.cyan(path.join(ctx.pkg.name, e.path))}: `,
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [];
+    return [
+      `Build type definitions with ${chalk.bold("rolldown")}...`,
+      `  format: ${chalk.yellow(task.format)}`,
+      ...targetLines,
+      ...bundlesLines,
+      ...entriesLines
+    ].join(`
+`);
+  },
+  exec: (ctx, task) => from(execPromise$1(ctx, task)),
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    console.error(err);
+  }
+};
+async function execPromise$1(ctx, task) {
+  const [{ rolldown }, { resolveRolldownConfig }] = await Promise.all([
+    import("rolldown"),
+    import("./resolveRolldownConfig.js")
+  ]), { distPath, files, logger } = ctx, outDir = path.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0]);
+        msg.code !== "CIRCULAR_DEPENDENCY" && (text.startsWith("Dynamic import can only") || text.startsWith("Sourcemap is likely to be incorrect") || (msg.type === "log" && logger.info(...msg.args), msg.type === "warn" && logger.warn(...msg.args), msg.type === "error" && logger.error(...msg.args)));
+      }
+    }
+  });
+  try {
+    const { inputOptions, outputOptions } = resolveRolldownConfig(ctx, task), bundle = await rolldown({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: "warn",
+          code: warning.code,
+          args: [warning.message]
+        });
+      }
+    }), { output } = await bundle.generate(outputOptions);
+    for (const chunkOrAsset of output)
+      chunkOrAsset.type === "asset" ? files.push({
+        type: "asset",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      }) : files.push({
+        type: "chunk",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      });
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
+  } catch (err) {
+    throw consoleSpy.restore(), err;
+  }
+}
+function resolveRollupConfig(ctx, buildTask) {
+  const { format: format2, runtime, target } = buildTask, { config: config2, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format2], minify = config2?.minify ?? !1, outDir = path.relative(cwd, distPath), pathAliases = Object.fromEntries(
+    Object.entries(ts2.config?.options.paths || {}).map(([key, val]) => [key, path.resolve(cwd, ts2.config?.options.baseUrl || ".", val[0])])
+  ), entries = buildTask.entries.map((entry) => ({
+    ...entry,
+    name: path.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+  }), {}), exportIds = _exports && Object.keys(_exports).map((exportPath) => path.join(pkg.name, exportPath)), sourcePaths = _exports && Object.values(_exports).map((e) => path.resolve(cwd, e.source)), replacements = Object.fromEntries(
+    Object.entries(config2?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
+  ), { optimizeLodash: enableOptimizeLodash = hasDependency(pkg, "lodash") } = config2?.rollup || {}, defaultPlugins = [
+    replace({
+      preventAssignment: !0,
+      values: pkg.name === "@sanity/pkg-utils" ? { ...replacements } : {
+        "process.env.PKG_FILE_PATH": (arg) => {
+          const sourcePath = `./${path.relative(cwd, arg)}`, entry = entries.find((e) => e.source === sourcePath);
+          return entry ? JSON.stringify(
+            path.relative(cwd, path.resolve(outDir, entry.name + outputExt))
+          ) : (console.error(`could not find source entry: ${sourcePath}`), "null");
+        },
+        "process.env.PKG_FORMAT": JSON.stringify(format2),
+        "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+        "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version),
+        ...replacements
+      }
+    }),
+    alias({
+      entries: { ...pathAliases }
+    }),
+    nodeResolve({
+      browser: runtime === "browser",
+      extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+      preferBuiltins: !0
+    }),
+    commonjs(),
+    json(),
+    (config2?.babel?.reactCompiler || config2?.babel?.styledComponents) && 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
+        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``"
+            fileName: !1,
+            // Native template literals take less space than this transpilation
+            transpileTemplateLiterals: !1,
+            // Massively helps dead code elimination and tree-shaking
+            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 config2.babel.styledComponents == "object" ? config2.babel.styledComponents : {}
+          }
+        ],
+        config2?.babel?.reactCompiler && [
+          "babel-plugin-react-compiler",
+          config2?.reactCompilerOptions || {}
+        ]
+      ].filter(Boolean)
+    }),
+    esbuild({
+      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: config2?.minify !== !1,
+      supported: {
+        "template-literal": !0
+      }
+    }),
+    Array.isArray(config2?.babel?.plugins) && getBabelOutputPlugin({
+      babelrc: !1,
+      plugins: config2.babel.plugins
+    }),
+    enableOptimizeLodash && optimizeLodashImports({
+      useLodashEs: format2 === "esm" && hasDependency(pkg, "lodash-es") ? !0 : void 0,
+      ...typeof config2?.rollup?.optimizeLodash == "boolean" ? {} : config2?.rollup?.optimizeLodash
+    }),
+    minify && terser({
+      compress: { directives: !1, passes: 10 },
+      ecma: 2020,
+      output: {
+        comments: (_node, comment) => {
+          const text = comment.value;
+          return comment.type === "comment2" ? /@preserve|@license|@cc_on/i.test(text) : !1;
+        },
+        preserve_annotations: !0
+      }
+    })
+  ].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,
+      external: (id, importer) => {
+        if (exportIds?.includes(id))
+          return !0;
+        if (importer && (id.startsWith(".") || id.startsWith("/"))) {
+          const idPath = path.resolve(path.dirname(importer), id);
+          if (sourcePaths?.includes(idPath))
+            return logger.warn(
+              `detected self-referencing import \u2013 treating as external: ${path.relative(
+                cwd,
+                idPath
+              )}`
+            ), !0;
+        }
+        const idParts = id.split("/"), name = idParts[0].startsWith("@") ? `${idParts[0]}/${idParts[1]}` : idParts[0];
+        return !!(name && external.includes(name));
+      },
+      input: entries.reduce(
+        (acc, entry) => Object.assign(acc, { [entry.name]: entry.source }),
+        {}
+      ),
+      watch: {
+        chokidar: {
+          usePolling: !0
+        }
+      },
+      plugins,
+      treeshake: {
+        preset: "recommended",
+        propertyReadSideEffects: !1,
+        moduleSideEffects: "no-external",
+        ...config2?.rollup?.treeshake
+      },
+      experimentalLogSideEffects: config2?.rollup?.experimentalLogSideEffects
+    },
+    outputOptions: {
+      chunkFileNames,
+      compact: minify,
+      dir: outDir,
+      entryFileNames,
+      esModule: !0,
+      format: format2,
+      interop: "compat",
+      sourcemap: config2?.sourcemap ?? !0,
+      hoistTransitiveImports: !1,
+      minifyInternalExports: minify,
+      ...config2?.rollup?.output
+    }
+  };
+}
+function hasDependency(pkg, packageName) {
+  return pkg.dependencies ? packageName in pkg.dependencies : pkg.peerDependencies ? packageName in pkg.peerDependencies : !1;
+}
+const rollupTask = {
+  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.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
+      "  bundles:",
+      ...bundleEntries.map(
+        (e) => [
+          "    - ",
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [], entriesLines = entries.length ? [
+      "  entries:",
+      ...entries.map(
+        (e) => [
+          "    - ",
+          `${chalk.cyan(path.join(ctx.pkg.name, e.path))}: `,
+          `${chalk.yellow(e.source)} ${chalk.gray("\u2192")} ${chalk.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [];
+    return [
+      "Build javascript files...",
+      `  format: ${chalk.yellow(task.format)}`,
+      ...targetLines,
+      ...bundlesLines,
+      ...entriesLines
+    ].join(`
+`);
+  },
+  exec: (ctx, task) => new Observable((observer) => {
+    execPromise(ctx, task).then((result) => {
+      observer.next(result), observer.complete();
+    }).catch((err) => observer.error(err));
+  }),
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    console.error(err);
+  }
+};
+async function execPromise(ctx, task) {
+  const { distPath, files, logger } = ctx, outDir = path.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0]);
+        msg.code !== "CIRCULAR_DEPENDENCY" && (text.startsWith("Dynamic import can only") || text.startsWith("Sourcemap is likely to be incorrect") || (msg.type === "log" && logger.info(...msg.args), msg.type === "warn" && logger.warn(...msg.args), msg.type === "error" && logger.error(...msg.args)));
+      }
+    }
+  });
+  try {
+    const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task), bundle = await rollup({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: "warn",
+          code: warning.code,
+          args: [warning.message]
+        });
+      }
+    }), { output } = await bundle.generate(outputOptions);
+    for (const chunkOrAsset of output)
+      chunkOrAsset.type === "asset" ? files.push({
+        type: "asset",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      }) : files.push({
+        type: "chunk",
+        path: path.resolve(outDir, chunkOrAsset.fileName)
+      });
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
+  } catch (err) {
+    throw consoleSpy.restore(), err;
+  }
+}
+const rollupWatchTask = {
+  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
+       `)}`,
+  exec: (ctx, task) => {
+    const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task);
+    return new Observable((observer) => {
+      const watchOptions = {
+        ...inputOptions,
+        output: outputOptions
+      }, watcher = watch$1(watchOptions);
+      return watcher.on("event", (event) => {
+        observer.next(event);
+      }), () => {
+        watcher.close();
+      };
+    });
+  },
+  complete: (ctx, task, event) => {
+    const { logger } = ctx;
+    if (event.code === "BUNDLE_END") {
+      logger.success(
+        `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
+       `)}`
+      ), logger.log("");
+      return;
+    }
+    if (event.code !== "BUNDLE_START" && event.code !== "END" && event.code === "ERROR") {
+      logger.error(event.code, event);
+      return;
+    }
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    err instanceof Error && logger.log(err);
+  }
+}, buildTaskHandlers = {
+  "build:dts": dtsTask,
+  "build:js": rollupTask,
+  "rolldown:dts": rolldownDtsTask
+}, watchTaskHandlers = {
+  "watch:dts": dtsWatchTask,
+  "watch:js": rollupWatchTask
+};
+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.relative(cwd, ctx.distPath)}' before building...`
+  ), await rimraf$1(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 = statSync(file);
+  return prettyBytes(stats.size);
+}
+function getFileInfo(cwd, filePath) {
+  const p = path.resolve(cwd, filePath), exists = fileExists(p), size = exists ? getFilesize(p) : void 0;
+  return { exists, size };
+}
+function printPackageTree(ctx) {
+  const { cwd, exports, logger, pkg } = ctx;
+  if (!exports) return;
+  logger.log(`${chalk.blue(pkg.name)}@${chalk.green(pkg.version)}`);
+  const tree = {};
+  pkg.type && (tree.type = chalk.yellow(pkg.type)), pkg.bin && (tree.bin = Object.fromEntries(
+    Object.entries(pkg.bin).map(([name, file]) => [chalk.cyan(name), fileInfo(file)])
+  ));
+  function fileInfo(file) {
+    const info = getFileInfo(cwd, file);
+    return info.size ? `${chalk.yellow(file)} ${chalk.gray(info.size)}` : `${chalk.gray(file)} ${chalk.red("does not exist")}`;
+  }
+  tree.exports = Object.fromEntries(
+    Object.entries(exports).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.cyan(path.join(pkg.name, exportPath)), exp];
+    })
+  ), logger.log(treeify.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.resolve(cwd, exp.source)) && missingFiles.push(exp.source), exp.require && !fileExists(path.resolve(cwd, exp.require)) && missingFiles.push(exp.require), exp.import && !fileExists(path.resolve(cwd, exp.import)) && missingFiles.push(exp.import);
+    ctx.pkg.types && !fileExists(path.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: format2, logger } = options, code = exportPaths.map((id) => format2 ? `import('${id}');` : `require('${id}');`).join(`
+`);
+  try {
+    const esbuildResult = await esbuild$1.build({
+      bundle: !0,
+      external,
+      format: format2,
+      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", relative(cwd, packagePath));
+  const templateOptions = {};
+  for (const templateOption of template.options) {
+    const templateValidate = templateOption.validate, res = await prompts(
+      {
+        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(
+      {
+        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 = resolve(packagePath, file.name);
+    await mkdirp(dirname(filePath)), await writeFile(filePath, file.contents.trim() + `
+`), logger.success(`wrote ${relative(cwd, filePath)}`);
+  }
+}
+async function isEmptyDirectory(dirPath) {
+  return (await 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(v), !0;
+          } catch {
+            return "invalid git url";
+          }
+        },
+        parse: (v) => {
+          if (!v) return null;
+          const result = gitUrlParse(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`
+        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`
+        *.local
+        *.log
+        *.tgz
+
+        .DS_Store
+        dist
+        etc
+        node_modules
+        `
+      }), features.prettier && files.push({
+        name: ".prettierignore",
+        contents: 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`
+          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(
+            resolve(packagePath, ".eslintrc.cjs"),
+            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(
+          resolve(packagePath, "tsconfig.settings.json"),
+          outdent`
+            {
+              "extends": "@sanity/pkg-utils/tsconfig/strictest.json",
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist"
+              }
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.dist.json",
+        contents: await prettierFormat(
+          resolve(packagePath, "tsconfig.dist.json"),
+          outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./src"],
+              "exclude": ["./src/**/*.test.ts"]
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.json",
+        contents: await prettierFormat(
+          resolve(packagePath, "tsconfig.json"),
+          outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./**/*.cjs", "./**/*.ts", "./**/*.tsx"],
+              "exclude": ["./node_modules"]
+            }
+            `,
+          config
+        )
+      })), features.typescript ? (files.push({
+        name: "package.config.ts",
+        contents: await prettierFormat(
+          resolve(packagePath, "package.config.ts"),
+          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(
+          resolve(packagePath, "src/index.ts"),
+          outdent`
+            /** @public */
+            export function main(): void {
+              //
+            }
+            `,
+          config
+        )
+      })) : (files.push({
+        name: "package.config.js",
+        contents: await prettierFormat(
+          resolve(packagePath, "package.config.js"),
+          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(
+          resolve(packagePath, "src/index.js"),
+          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(
+          resolve(packagePath, "package.json"),
+          JSON.stringify(pkgJson, null, 2),
+          config
+        )
+      }), files;
+    }
+  };
+};
+function prettierFormat(filepath, input, prettierOptions) {
+  return 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(name, version);
+      latestDeps[name] = latestVersion ? `^${latestVersion}` : version;
+    }
+  }
+  return latestDeps;
+}
+function getGitUserConfig(cwd) {
+  let user, email;
+  try {
+    user = execSync("git config user.name", { encoding: "utf8", cwd }).trim() || void 0, email = 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 = 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(packagePath);
+    return;
+  }
+  if (!(await 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 = [], exports = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "watch:dts",
+    entries: []
+  }, rollupTasks = {};
+  function addRollupTaskEntry(format2, runtime, entry) {
+    const buildId = `${format2}:${runtime}`;
+    rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "watch:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format: format2,
+      target: target[runtime]
+    };
+  }
+  for (const exp of exports) {
+    const importId = path.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 exports) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports) {
+    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(patterns.map((pattern) => pattern.split(path.sep).join(path.posix.sep)));
+}
+function watchFiles(patterns) {
+  return new Observable((observer) => {
+    const watcher = chokidar.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.resolve(cwd, "package.json"),
+    path.resolve(cwd, "package.config.cjs"),
+    path.resolve(cwd, "package.config.js"),
+    path.resolve(cwd, "package.config.ts")
+  ]);
+  return watchFiles([
+    path.resolve(cwd, "package.json"),
+    path.resolve(cwd, "package.config.cjs"),
+    path.resolve(cwd, "package.config.js"),
+    path.resolve(cwd, "package.config.ts")
+  ]).pipe(
+    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.relative(cwd, fileEvent.file), "changed"), logger.log(""), files.slice(0)) : files, initialFiles),
+    startWith(initialFiles),
+    distinctUntilChanged()
+  );
+}
+async function watch(options) {
+  const { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger();
+  (await watchConfigFiles({ cwd, logger })).pipe(
+    switchMap(async (configFiles) => {
+      if (!configFiles.map((f) => path.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();
+        }
+      });
+    }
+  });
+}
+export {
+  DEFAULT_BROWSERSLIST_QUERY,
+  build,
+  check,
+  createLogger,
+  defineConfig,
+  defineTemplateOption,
+  getExtractMessagesConfig,
+  init,
+  loadConfig,
+  loadPkg,
+  loadPkgWithReporting,
+  parseExports,
+  parseStrictOptions,
+  pkgExtMap,
+  strictOptions,
+  toggle,
+  watch
+};
+//# sourceMappingURL=index.js.map