@sanity/tsdown-config 0.13.1 → 0.14.1

package/README.md

@@ -72,7 +72,9 @@ export default defineConfig({
 
 The same `vanillaExtract` feature as `@sanity/pkg-utils` is available. It extracts the CSS from
 `.css.ts` files into a separate, `lightningcss`-optimized file (`dist/bundle.css` by default).
-Start by installing `@vanilla-extract/css` for authoring the `.css.ts` files:
+Under the hood it uses [`@sanity/vanilla-extract-tsdown-plugin`](https://github.com/sanity-io/pkg-utils/tree/main/packages/%40sanity/vanilla-extract-tsdown-plugin#readme),
+a tsdown-native port of `@vanilla-extract/rollup-plugin`, so enabling it doesn't pull `rollup`
+into your project. Start by installing `@vanilla-extract/css` for authoring the `.css.ts` files:
 
 ```sh
 pnpm add --save-dev @vanilla-extract/css
@@ -87,10 +89,11 @@ export default defineConfig({
 })
 ```
 
-By default a compatibility mode is active that automatically wires up the conditional CSS export
-pattern:
+By default (`inject: {nodeCompat: true}`) the conditional CSS export pattern is wired up
+automatically:
 
-- injects the self-referential `import "<pkg>/bundle.css"` into the `index` entry chunk,
+- injects the self-referential `import "<pkg>/bundle.css"` into the entry chunks that use
+  vanilla-extract styles,
 - emits a no-op `bundle.css.js` shim (plus `bundle.css.d.ts`) for runtimes that cannot import
   `.css` files, and
 - writes the conditional `"./bundle.css"` export to `package.json` (`browser`/`style` → the real
@@ -106,9 +109,10 @@ consumers by adding it to `sideEffects` in `package.json`:
 }
 ```
 
-Pass an options object instead of `true` to customize (e.g. `minify`, `browserslist`,
-`extract.name`), or set `extract.compatMode: false` to wire up the import, shim, and export
-yourself.
+Pass an options object instead of `true` to customize - the options are modeled after the
+[`css` options of `@tsdown/css`](https://tsdown.dev/options/css) (e.g. `fileName`, `minify`,
+`target`). Set `inject: true` for a plain relative `import "./bundle.css"` instead of the
+conditional export pattern, or `inject: false` to wire up the import, shim, and export yourself.
 
 ## dts
 
@@ -128,6 +132,38 @@ export default defineConfig({
 })
 ```
 
+## Isolated declarations
+
+If you're using the [`@sanity/tsconfig/isolated-declarations`](https://github.com/sanity-io/pkg-utils/tree/main/packages/%40sanity/tsconfig#isolated-declarations-tsconfigjson)
+preset — which makes tsdown generate the `.d.ts` files with oxc's fast isolated declarations
+transform — annotate the default export of `tsdown.config.ts` with `satisfies Promise<UserConfig>`:
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+import type {UserConfig} from 'tsdown'
+
+export default defineConfig() satisfies Promise<UserConfig>
+```
+
+Without the annotation, type-checking `tsdown.config.ts` with the `@sanity/tsconfig` presets (they
+enable `declaration`) fails with TS2883 in pnpm projects: the inferred type of the default export
+can only be named through `@sanity/tsdown-config`'s own copy of `tsdown`, which isn't portable.
+`satisfies Promise<UserConfig>` names the type through your own `tsdown` dependency instead.
+
+Keep the `isolated-declarations` preset scoped to the tsconfig that tsdown builds with (e.g. a
+`tsconfig.dist.json` that only includes `./src`). If `isolatedDeclarations` covers
+`tsdown.config.ts` itself, the default export can't be inferred at all (TS9037), and the config has
+to move into an explicitly annotated variable instead:
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+import type {UserConfig} from 'tsdown'
+
+const config: Promise<UserConfig> = defineConfig()
+
+export default config
+```
+
 ## define
 
 tsdown's `define` option is also passed through as-is. It replaces global identifiers with constant
@@ -141,3 +177,60 @@ export default defineConfig({
   define: {'process.env.NODE_ENV': JSON.stringify('production')},
 })
 ```
+
+## target
+
+tsdown's [`target` option](https://tsdown.dev/options/target) is also passed through as-is. It
+downlevels JS syntax for the given runtimes (esbuild-style target strings), and doubles as the
+default CSS syntax lowering target when `vanillaExtract` is enabled (browserless targets like
+`node20` don't affect the CSS - it falls back to `@sanity/browserslist-config`):
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  target: ['chrome90', 'safari16'],
+})
+```
+
+## exports
+
+tsdown's [`exports` option](https://tsdown.dev/options/package-exports) is forwarded with
+different defaults, suited for publishing Sanity libraries:
+
+- `enabled: 'local-only'` - the `exports` map in `package.json` is generated during local builds
+  and skipped in CI, where the committed `package.json` is already up to date, and
+- `devExports: true` when pnpm is detected - the local `exports` map points at the source files
+  (so monorepo siblings and editors resolve them directly), while `publishConfig.exports` receives
+  the built files. This default is omitted for other or unknown package managers because they do
+  not all reliably apply `publishConfig.exports` when publishing.
+
+Userland values apply with tsdown's `mergeConfig` semantics: an object deep-merges over the
+defaults (so individual fields can be overridden), while any other value - `false` to disable
+exports generation, or a bare CI condition (`'ci-only'`/`'local-only'`) - replaces them entirely:
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  exports: {all: true},
+})
+```
+
+## Everything else: `mergeConfig`
+
+`defineConfig` deliberately only exposes options you're likely to change. For anything else, merge
+tsdown options over the returned config with tsdown's own `mergeConfig` - `defineConfig` returns a
+promise, so `await` it first:
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+import {mergeConfig} from 'tsdown'
+
+export default mergeConfig(await defineConfig({tsconfig: 'tsconfig.dist.json'}), {
+  // Any tsdown option, e.g. opting out of hashed chunk filenames:
+  hash: false,
+})
+```

package/dist/index.d.mts

@@ -1,57 +1,16 @@
 import { UserConfig } from "tsdown";
+import { Options } from "@sanity/vanilla-extract-tsdown-plugin";
 import { PluginOptions } from "babel-plugin-react-compiler";
-import { Options } from "@vanilla-extract/rollup-plugin";
 /**
- * Options for the `@vanilla-extract/rollup-plugin` integration, including the same extensions as
- * `@sanity/pkg-utils` (`minify`, `browserslist`, and `extract.compatMode`).
+ * Options for the `vanillaExtract` option — the same options as
+ * `@sanity/vanilla-extract-tsdown-plugin` (`identifiers`, `fileName`, `minify`, `target`, and
+ * `inject`, all modeled after the `css` options of `@tsdown/css`), with one different default:
+ * `inject` defaults to `{nodeCompat: true}` (instead of the plugin's `false`), wiring up the
+ * conditional CSS export pattern that Sanity libraries ship with. Set `inject: true` for a plain
+ * relative CSS import, or `inject: false` to only extract the CSS.
  * @public
  */
-interface PackageVanillaExtractOptions extends Omit<Options, "extract"> {
-  /**
-   * Minify the extracted CSS with `lightningcss`.
-   * @defaultValue true
-   */
-  minify?: boolean;
-  /**
-   * Browserslist query passed to `lightningcss` when optimizing the extracted CSS.
-   * @defaultValue `@sanity/browserslist-config`
-   */
-  browserslist?: string | string[];
-  /**
-   * Different formatting of identifiers (e.g. class names, keyframes, CSS Vars, etc).
-   * @defaultValue "short"
-   */
-  identifiers?: Options["identifiers"];
-  /**
-   * Extract the CSS into a separate file. The CSS is always extracted, so this configures _how_.
-   */
-  extract?: {
-    /**
-     * Name of the emitted `.css` file (and, with `compatMode`, the `exports` subpath + shim base).
-     * @defaultValue "bundle.css"
-     */
-    name?: string;
-    /**
-     * Generate a `.css.map` sourcemap file.
-     * @defaultValue true
-     */
-    sourcemap?: boolean;
-    /**
-     * Compatibility mode automatically wires up the conditional CSS export pattern so userland does
-     * not have to. When enabled, the config:
-     *
-     * - injects `import "<pkg-name>/<name>"` into the `index` entry chunk,
-     * - emits a no-op `<name>.js` shim for runtimes that cannot import `.css` files, and
-     * - writes the conditional `"./<name>"` export to `package.json`
-     *   (`browser`/`style` → the real CSS, `node`/`default` → the shim).
-     *
-     * The result is that `import "<pkg>/<name>"` resolves to the real CSS in bundlers/browsers and
-     * to the no-op shim in Node and similar runtimes. Disable it to wire these up yourself.
-     * @defaultValue true
-     */
-    compatMode?: boolean;
-  };
-}
+type PackageVanillaExtractOptions = Options;
 /**
  * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.
  * @public
@@ -89,11 +48,26 @@ type ReactCompilerOptions = Partial<PluginOptions>;
 /**
  * @public
  */
-interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format" | "dts" | "define"> {
+interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format" | "dts" | "define" | "target"> {
   /**
    * @defaultValue 'neutral'
    */
   platform?: UserConfig["platform"];
+  /**
+   * tsdown's `exports` option, with defaults suited for publishing Sanity libraries:
+   * `enabled: 'local-only'` generates the `exports` map during local builds and skips it in CI
+   * (where the committed `package.json` is already up to date). When pnpm is detected,
+   * `devExports: true` also keeps the local `exports` map pointing at source files while
+   * `publishConfig.exports` receives the built files.
+   *
+   * Userland values apply with tsdown's `mergeConfig` semantics: an object deep-merges over
+   * these defaults (so individual fields can be overridden), while any other value - `false`
+   * to disable exports generation, or a bare CI condition (`'ci-only'`/`'local-only'`) -
+   * replaces them entirely.
+   * @defaultValue `{enabled: 'local-only', devExports: true}` for pnpm projects;
+   * `{enabled: 'local-only'}` otherwise.
+   */
+  exports?: UserConfig["exports"];
   /**
    * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published
    * components are memoized automatically. Pass `true` to use the defaults, or an options object
@@ -113,10 +87,10 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
    */
   styledComponents?: boolean | StyledComponentsOptions;
   /**
-   * Enables `@vanilla-extract/rollup-plugin` to extract CSS into a separate file, with support for
-   * minifying the extracted CSS. Pass `true` to use the defaults, or an object to customize.
+   * Enables `@sanity/vanilla-extract-tsdown-plugin` to extract CSS into a separate,
+   * `lightningcss`-optimized file. Pass `true` to use the defaults, or an object to customize.
    *
-   * By default (`extract.compatMode: true`) the config also injects the self-referential
+   * By default (`inject: {nodeCompat: true}`) the plugin also injects the self-referential
    * `import "<pkg>/bundle.css"`, emits a `bundle.css.js` shim, and writes the conditional
    * `"./bundle.css"` export to `package.json` - see {@link PackageVanillaExtractOptions}.
    * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.
@@ -128,5 +102,5 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
  * @public
  */
 declare function defineConfig(options?: PackageOptions): Promise<UserConfig>;
-export { PackageOptions, type PackageVanillaExtractOptions, ReactCompilerOptions, StyledComponentsOptions, defineConfig };
+export { PackageOptions, PackageVanillaExtractOptions, ReactCompilerOptions, StyledComponentsOptions, defineConfig };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/vanillaExtract.ts","../src/index.ts"],"mappings":";;;;;;;;UAaiB,qCAAqC,KAAK;;;;;EAKzD;;;;;EAKA;;;;;EAKA,cAAc;;;;EAId;;;;;IAKE;;;;;IAKA;;;;;;;;;;;;;;IAcA;;;;;;;UCzCa;;EAEf;;;;;EAKA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;EAEA;;;;;;;;;KAUU,uBAAuB,QAAQ;;;;UAK1B,uBAAuB,KACtC;;;;EAMA,WAAW;;;;;;;;;;EAUX,0BAA0B;;;;;;;;EAQ1B,6BAA6B;;;;;;;;;;;EAW7B,2BAA2B;;;;;iBAoCP,aAAa,UAAS,iBAAsB,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;KAmBY,+BAA+B;;;;;UAM1B;;EAEf;;;;;EAKA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;EAEA;;;;;;;;;KAUU,uBAAuB,QAAQ;;;;UAK1B,uBAAuB,KACtC;;;;EAMA,WAAW;;;;;;;;;;;;;;;EAeX,UAAU;;;;;;;;;;EAUV,0BAA0B;;;;;;;;EAQ1B,6BAA6B;;;;;;;;;;;EAW7B,2BAA2B;;;;;iBAMP,aAAa,UAAS,iBAAsB,QAAQ"}

package/dist/index.mjs

@@ -1,26 +1,10 @@
-import { defineConfig as defineConfig$1 } from "tsdown";
-/**
-* Emits shared (non-entry) chunks into subfolders per output flavor, following the same naming
-* convention as `@sanity/pkg-utils` (`_chunks-es`, `_chunks-cjs` and `_chunks-dts`), instead of
-* rolldown's default of placing chunks at the root of the output directory next to the entries.
-* A chunk can otherwise be named like an entry (e.g. code shared between `index` and `theme`
-* entries forms a chunk that rolldown also names `theme`): the JS output deduplicates such
-* filename collisions in favor of the entry, but the d.ts output can resolve them the other way
-* around, handing `theme.d.ts` to the chunk - which re-exports everything under minified aliases -
-* so every named import from the `theme` entry fails to type-check with TS2460
-* (https://github.com/sanity-io/ui/issues/2262).
-*/
-function resolveChunkFileNames(defaultOutputOptions, format) {
-	return (chunk) => {
-		let template = (typeof defaultOutputOptions.chunkFileNames == "function" ? defaultOutputOptions.chunkFileNames(chunk) : defaultOutputOptions.chunkFileNames) ?? "[name].js";
-		return `${chunk.name.endsWith(".d") ? "_chunks-dts" : `_chunks-${format}`}/${template}`;
-	};
-}
+import { detect } from "package-manager-detector/detect";
+import { defineConfig as defineConfig$1, mergeConfig } from "tsdown";
 /**
 * @public
 */
 async function defineConfig(options = {}) {
-	let { entry, dts, define } = options, tsconfig = options.tsconfig ?? "tsconfig.json", platform = options.platform ?? "neutral", reactCompiler = options.reactCompiler ?? !1, styledComponents = options.styledComponents ?? !1, report = { gzip: !1 }, format = options.format ?? "esm", inputOptions = {
+	let { entry, tsconfig, dts, define, target } = options, platform = options.platform ?? "neutral", reactCompiler = options.reactCompiler ?? !1, styledComponents = options.styledComponents ?? !1, report = { gzip: !1 }, format = options.format ?? "esm", inputOptions = {
 		preserveEntrySignatures: "strict",
 		experimental: { attachDebugInfo: "none" },
 		...styledComponents !== !1 && { transform: { plugins: { styledComponents: {
@@ -30,69 +14,34 @@ async function defineConfig(options = {}) {
 			cssProp: !1,
 			...typeof styledComponents == "object" ? styledComponents : {}
 		} } } }
-	}, resolveBaseOutputOptions = (defaultOptions, outputFormat) => ({
-		hoistTransitiveImports: !1,
-		chunkFileNames: resolveChunkFileNames(defaultOptions, outputFormat)
-	}), outputOptions = resolveBaseOutputOptions, treeshake, customExports, plugins = [];
+	}, plugins = [];
 	if (reactCompiler !== !1) {
 		let [{ default: pluginBabel }, { reactCompilerPreset }] = await Promise.all([import("@rolldown/plugin-babel"), import("@vitejs/plugin-react")]);
 		plugins.push(await pluginBabel({ presets: [reactCompilerPreset(typeof reactCompiler == "object" ? reactCompiler : {})] }));
 	}
 	if (options.vanillaExtract) {
-		let [{ vanillaExtractPlugin }, { default: browserslistConfig }, { optimizeCss }, { bundleCssShim }, { composeIntro, createConditionalCssExport, insertCssExport, readPackageName, resolveVanillaExtract, resolveVanillaExtractCssName }] = await Promise.all([
-			import("@vanilla-extract/rollup-plugin"),
-			import("@sanity/browserslist-config"),
-			import("./_chunks-es/optimizeCss.mjs"),
-			import("./_chunks-es/bundleCssShim.mjs"),
-			import("./_chunks-es/vanillaExtract.mjs")
-		]), vanillaExtract = resolveVanillaExtract(options.vanillaExtract), cssName = resolveVanillaExtractCssName(vanillaExtract.options);
+		let { vanillaExtractPlugin } = await import("@sanity/vanilla-extract-tsdown-plugin");
 		plugins.push(vanillaExtractPlugin({
-			identifiers: vanillaExtract.options.identifiers ?? "short",
-			cwd: vanillaExtract.options.cwd,
-			esbuildOptions: vanillaExtract.options.esbuildOptions,
-			unstable_injectFilescopes: vanillaExtract.options.unstable_injectFilescopes,
-			extract: {
-				name: cssName,
-				sourcemap: vanillaExtract.options.extract?.sourcemap ?? !0
-			}
-		}), optimizeCss({
-			extractFileName: cssName,
-			browserslist: vanillaExtract.options.browserslist || browserslistConfig,
-			minify: vanillaExtract.options.minify ?? !0
-		})), treeshake = { moduleSideEffects: [{
-			test: /\.vanilla\.css$/,
-			external: !0,
-			sideEffects: !1
-		}] };
-		let cssImportId = vanillaExtract.compatMode ? `${readPackageName(process.cwd())}/${cssName}` : void 0;
-		if (outputOptions = (defaultOptions, outputFormat, context) => ({
-			...resolveBaseOutputOptions(defaultOptions, outputFormat),
-			assetFileNames: "[name][extname]",
-			...cssImportId && !context.cjsDts && (outputFormat === "es" || outputFormat === "cjs") ? { intro: composeIntro(outputFormat === "cjs" ? `require(${JSON.stringify(cssImportId)})` : `import ${JSON.stringify(cssImportId)}`) } : {}
-		}), vanillaExtract.compatMode) {
-			plugins.push(bundleCssShim({ fileName: `${cssName}.js` }));
-			let conditionalCssExport = createConditionalCssExport(cssName, "dist");
-			customExports = (exportsMap) => insertCssExport(exportsMap, `./${cssName}`, conditionalCssExport);
-		}
+			inject: { nodeCompat: !0 },
+			...options.vanillaExtract === !0 ? {} : options.vanillaExtract
+		}));
 	}
+	let { exports } = mergeConfig({ exports: {
+		enabled: "local-only",
+		...(await detect({ cwd: process.cwd() }))?.name === "pnpm" && { devExports: !0 }
+	} }, { exports: options.exports });
 	return defineConfig$1({
 		define,
 		dts,
 		entry,
-		exports: {
-			enabled: "local-only",
-			devExports: !0,
-			...customExports && { customExports }
-		},
+		exports,
 		format,
-		hash: !1,
 		inputOptions,
-		outputOptions,
 		platform,
 		plugins,
 		publint: !0,
 		report,
-		treeshake,
+		target,
 		tsconfig,
 		minify: {
 			compress: !0,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import type {PluginOptions as ReactCompilerPluginOptions} from 'babel-plugin-react-compiler'\nimport {\n  defineConfig as defineTsdownConfig,\n  type NormalizedFormat,\n  type Rolldown,\n  type UserConfig,\n} from 'tsdown'\nimport type {PackageVanillaExtractOptions} from './vanillaExtract.ts'\n\nexport type {PackageVanillaExtractOptions}\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * Options for the React Compiler, the same options as `babel-plugin-react-compiler`.\n * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer\n * dependency, required to use `reactCompiler`) is installed, and always match the installed\n * version of the compiler.\n * @public\n */\nexport type ReactCompilerOptions = Partial<ReactCompilerPluginOptions>\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<\n  UserConfig,\n  'tsconfig' | 'entry' | 'format' | 'dts' | 'define'\n> {\n  /**\n   * @defaultValue 'neutral'\n   */\n  platform?: UserConfig['platform']\n  /**\n   * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published\n   * components are memoized automatically. Pass `true` to use the defaults, or an options object\n   * to configure the compiler (e.g. `{target: '18'}`).\n   * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`\n   * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the\n   * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.\n   * @defaultValue false\n   */\n  reactCompiler?: boolean | ReactCompilerOptions\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n  /**\n   * Enables `@vanilla-extract/rollup-plugin` to extract CSS into a separate file, with support for\n   * minifying the extracted CSS. Pass `true` to use the defaults, or an object to customize.\n   *\n   * By default (`extract.compatMode: true`) the config also injects the self-referential\n   * `import \"<pkg>/bundle.css\"`, emits a `bundle.css.js` shim, and writes the conditional\n   * `\"./bundle.css\"` export to `package.json` - see {@link PackageVanillaExtractOptions}.\n   * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.\n   * @alpha\n   */\n  vanillaExtract?: boolean | PackageVanillaExtractOptions\n}\n\n/**\n * Emits shared (non-entry) chunks into subfolders per output flavor, following the same naming\n * convention as `@sanity/pkg-utils` (`_chunks-es`, `_chunks-cjs` and `_chunks-dts`), instead of\n * rolldown's default of placing chunks at the root of the output directory next to the entries.\n * A chunk can otherwise be named like an entry (e.g. code shared between `index` and `theme`\n * entries forms a chunk that rolldown also names `theme`): the JS output deduplicates such\n * filename collisions in favor of the entry, but the d.ts output can resolve them the other way\n * around, handing `theme.d.ts` to the chunk - which re-exports everything under minified aliases -\n * so every named import from the `theme` entry fails to type-check with TS2460\n * (https://github.com/sanity-io/ui/issues/2262).\n */\nfunction resolveChunkFileNames(\n  defaultOutputOptions: Rolldown.OutputOptions,\n  format: NormalizedFormat,\n): Rolldown.OutputOptions['chunkFileNames'] {\n  return (chunk) => {\n    // tsdown's default is a `[name]` template string carrying the resolved output extension for\n    // the current format and package type (e.g. `[name].mjs`), so reuse it for the file names\n    const template =\n      (typeof defaultOutputOptions.chunkFileNames === 'function'\n        ? defaultOutputOptions.chunkFileNames(chunk)\n        : defaultOutputOptions.chunkFileNames) ?? '[name].js'\n    // `rolldown-plugin-dts` names d.ts chunks with a `.d` suffix and later rewrites the rendered\n    // JS filename to the matching d.ts extension (e.g. `_chunks-dts/[name].mjs` renders\n    // `_chunks-dts/theme.mjs`, which becomes `_chunks-dts/theme.d.mts`)\n    const folder = chunk.name.endsWith('.d') ? '_chunks-dts' : `_chunks-${format}`\n    return `${folder}/${template}`\n  }\n}\n\n/**\n * @public\n */\nexport async function defineConfig(options: PackageOptions = {}): Promise<UserConfig> {\n  // `dts` and `define` are passed through to tsdown as-is. When left undefined, tsdown keeps its\n  // default behavior (`dts` is auto-detected from `package.json`, `define` replaces nothing).\n  const {entry, dts, define} = options\n  const tsconfig = options.tsconfig ?? 'tsconfig.json'\n  const platform = options.platform ?? 'neutral'\n  const reactCompiler = options.reactCompiler ?? false\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const publint = true\n  const hash = false\n  const format = options.format ?? 'esm'\n  const inputOptions = {\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } as const satisfies UserConfig['inputOptions']\n\n  const resolveBaseOutputOptions = (\n    defaultOptions: Rolldown.OutputOptions,\n    outputFormat: NormalizedFormat,\n  ) =>\n    ({\n      hoistTransitiveImports: false,\n      chunkFileNames: resolveChunkFileNames(defaultOptions, outputFormat),\n    }) satisfies Rolldown.OutputOptions\n\n  let outputOptions: UserConfig['outputOptions'] = resolveBaseOutputOptions\n  let treeshake: UserConfig['treeshake']\n  let customExports: ((exportsMap: Record<string, unknown>) => Record<string, unknown>) | undefined\n\n  const plugins: Rolldown.Plugin[] = []\n  if (reactCompiler !== false) {\n    // Follows the official tsdown recipe for the React Compiler:\n    // https://tsdown.dev/recipes/react-support#enabling-react-compiler\n    // The plugins are lazy loaded so they're only paid for when the React Compiler is enabled.\n    // `babel-plugin-react-compiler` itself is resolved by Babel from the consumer package during\n    // the build, which is why it can be an optional peer dependency. Once rolldown ships its rust\n    // port of the React Compiler this can be swapped out for an oxc transform, like `styledComponents`.\n    const [{default: pluginBabel}, {reactCompilerPreset}] = await Promise.all([\n      import('@rolldown/plugin-babel'),\n      import('@vitejs/plugin-react'),\n    ])\n    plugins.push(\n      await pluginBabel({\n        presets: [reactCompilerPreset(typeof reactCompiler === 'object' ? reactCompiler : {})],\n      }),\n    )\n  }\n  if (options.vanillaExtract) {\n    // Everything vanilla-extract related is lazy loaded, like `reactCompiler`, so it's only paid\n    // for when the option is enabled: `@vanilla-extract/rollup-plugin` compiles the `.css.ts`\n    // files, and `optimizeCss` pulls in the CSS toolchain (`lightningcss`, `browserslist`) that\n    // minifies the extracted CSS.\n    const [\n      {vanillaExtractPlugin},\n      {default: browserslistConfig},\n      {optimizeCss},\n      {bundleCssShim},\n      {\n        composeIntro,\n        createConditionalCssExport,\n        insertCssExport,\n        readPackageName,\n        resolveVanillaExtract,\n        resolveVanillaExtractCssName,\n      },\n    ] = await Promise.all([\n      import('@vanilla-extract/rollup-plugin'),\n      import('@sanity/browserslist-config'),\n      import('./optimizeCss.ts'),\n      import('./bundleCssShim.ts'),\n      import('./vanillaExtract.ts'),\n    ])\n\n    // Resolve vanilla-extract options + the conditional CSS export \"compat mode\"\n    const vanillaExtract = resolveVanillaExtract(options.vanillaExtract)\n    const cssName = resolveVanillaExtractCssName(vanillaExtract.options)\n\n    plugins.push(\n      // Rolldown supports most Rollup plugins, but the plugin types are not identical, so the\n      // official guidance is to cast: https://tsdown.dev/advanced/plugins#rollup-plugins\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      vanillaExtractPlugin({\n        identifiers: vanillaExtract.options.identifiers ?? 'short',\n        cwd: vanillaExtract.options.cwd,\n        esbuildOptions: vanillaExtract.options.esbuildOptions,\n        unstable_injectFilescopes: vanillaExtract.options.unstable_injectFilescopes,\n        extract: {\n          name: cssName,\n          sourcemap: vanillaExtract.options.extract?.sourcemap ?? true,\n        },\n      }) as unknown as Rolldown.Plugin,\n      optimizeCss({\n        extractFileName: cssName,\n        browserslist: vanillaExtract.options.browserslist || browserslistConfig,\n        minify: vanillaExtract.options.minify ?? true,\n      }),\n    )\n\n    // The vanilla-extract plugin resolves each compiled `.css.ts` module's CSS to an external,\n    // side-effect-only `<file>.vanilla.css` import and extracts the CSS into a single file. The\n    // imports are redundant once the CSS is extracted, so let tree-shaking drop them up front:\n    // the plugin's own `generateBundle` cleanup only strips imports at the start of a line, which\n    // the minifier's statement merging can defeat (e.g. `a(), require(\"….vanilla.css\")` in CJS).\n    // Modules not matching the rule keep the default tree-shaking behavior.\n    treeshake = {moduleSideEffects: [{test: /\\.vanilla\\.css$/, external: true, sideEffects: false}]}\n\n    // In compat mode, the self-referential `import \"<pkg>/<css>\"` needs the package name.\n    const cssImportId = vanillaExtract.compatMode\n      ? `${readPackageName(process.cwd())}/${cssName}`\n      : undefined\n\n    outputOptions = (defaultOptions, outputFormat, context) => ({\n      ...resolveBaseOutputOptions(defaultOptions, outputFormat),\n      // Emit the extracted CSS (and its sourcemap) with a stable name at the root of the tsdown\n      // default `outDir` ('dist', not configurable yet) instead of rolldown's default\n      // `assets/[name]-[hash][extname]`, so it can back the conditional `./<css>` export.\n      assetFileNames: '[name][extname]',\n      // In compat mode, inject the self-referential CSS import into the `index` entry chunk so\n      // userland does not need to set `outputOptions.intro` themselves. Use `require()` for\n      // CommonJS output (a top-level `import` would be invalid in a `.cjs` bundle).\n      ...(cssImportId && !context.cjsDts && (outputFormat === 'es' || outputFormat === 'cjs')\n        ? {\n            intro: composeIntro(\n              outputFormat === 'cjs'\n                ? `require(${JSON.stringify(cssImportId)})`\n                : `import ${JSON.stringify(cssImportId)}`,\n            ),\n          }\n        : {}),\n    })\n\n    if (vanillaExtract.compatMode) {\n      // In compat mode, emit the no-op JS shim that the `node`/`default` conditions of the\n      // `./<css>` export resolve to.\n      plugins.push(bundleCssShim({fileName: `${cssName}.js`}))\n\n      // Write the conditional `./<css>` export to `package.json` (and, through tsdown, mirror it\n      // into `publishConfig.exports`) so userland does not have to maintain it.\n      const conditionalCssExport = createConditionalCssExport(cssName, 'dist')\n      customExports = (exportsMap) =>\n        insertCssExport(exportsMap, `./${cssName}`, conditionalCssExport)\n    }\n  }\n\n  const exports = {\n    enabled: 'local-only',\n    // @TODO use @sanity/parse-package-json to determine if devExports should be `true` or `source`\n    devExports: true,\n    ...(customExports && {customExports}),\n  } as const satisfies UserConfig['exports']\n\n  return defineTsdownConfig({\n    define,\n    dts,\n    entry,\n    exports,\n    format,\n    hash,\n    inputOptions,\n    outputOptions,\n    platform,\n    plugins,\n    publint,\n    report,\n    treeshake,\n    tsconfig,\n    minify: {compress: true, codegen: false, mangle: false},\n    // `treeshake` stays `undefined` (tsdown's/rolldown's default, `moduleSideEffects: true`)\n    // unless vanilla-extract needs its targeted rule above. Previously this set the equivalent of\n    // `moduleSideEffects: 'no-external'` (with a `.css` exemption), which stripped intentional\n    // side-effect-only imports of external packages (e.g. `import 'react-time-ago/locale/en'`)\n    // from the output. The default preserves those imports while still honoring `package.json`\n    // `sideEffects` fields for bundled modules.\n  })\n}\n"],"mappings":";;;;;;;;;;;;AAoGA,SAAS,sBACP,sBACA,QAC0C;CAC1C,QAAQ,UAAU;EAGhB,IAAM,YACH,OAAO,qBAAqB,kBAAmB,aAC5C,qBAAqB,eAAe,KAAK,IACzC,qBAAqB,mBAAmB;EAK9C,OAAO,GADQ,MAAM,KAAK,SAAS,IAAI,IAAI,gBAAgB,WAAW,SACrD,GAAG;CACtB;AACF;;;;AAKA,eAAsB,aAAa,UAA0B,CAAC,GAAwB;CAGpF,IAAM,EAAC,OAAO,KAAK,WAAU,SACvB,WAAW,QAAQ,YAAY,iBAC/B,WAAW,QAAQ,YAAY,WAC/B,gBAAgB,QAAQ,iBAAiB,IACzC,mBAAmB,QAAQ,oBAAoB,IAC/C,SAAS,EAAC,MAAM,GAAK,GAGrB,SAAS,QAAQ,UAAU,OAC3B,eAAe;EACnB,yBAAyB;EACzB,cAAc,EAAC,iBAAiB,OAAM;EACtC,GAAI,qBAAqB,MAAS,EAChC,WAAW,EACT,SAAS,EACP,kBAAkB;GAIhB,UAAU;GAIV,2BAA2B;GAG3B,MAAM;GAGN,SAAS;GACT,GAAI,OAAO,oBAAqB,WAAW,mBAAmB,CAAC;EACjE,EACF,EACF,EACF;CACF,GAEM,4BACJ,gBACA,kBAEC;EACC,wBAAwB;EACxB,gBAAgB,sBAAsB,gBAAgB,YAAY;CACpE,IAEE,gBAA6C,0BAC7C,WACA,eAEE,UAA6B,CAAC;CACpC,IAAI,kBAAkB,IAAO;EAO3B,IAAM,CAAC,EAAC,SAAS,eAAc,EAAC,yBAAwB,MAAM,QAAQ,IAAI,CACxE,OAAO,2BACP,OAAO,uBACT,CAAC;EACD,QAAQ,KACN,MAAM,YAAY,EAChB,SAAS,CAAC,oBAAoB,OAAO,iBAAkB,WAAW,gBAAgB,CAAC,CAAC,CAAC,EACvF,CAAC,CACH;CACF;CACA,IAAI,QAAQ,gBAAgB;EAK1B,IAAM,CACJ,EAAC,wBACD,EAAC,SAAS,sBACV,EAAC,eACD,EAAC,iBACD,EACE,cACA,4BACA,iBACA,iBACA,uBACA,kCAEA,MAAM,QAAQ,IAAI;GACpB,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;EACT,CAAC,GAGK,iBAAiB,sBAAsB,QAAQ,cAAc,GAC7D,UAAU,6BAA6B,eAAe,OAAO;EA6BnE,AA3BA,QAAQ,KAIN,qBAAqB;GACnB,aAAa,eAAe,QAAQ,eAAe;GACnD,KAAK,eAAe,QAAQ;GAC5B,gBAAgB,eAAe,QAAQ;GACvC,2BAA2B,eAAe,QAAQ;GAClD,SAAS;IACP,MAAM;IACN,WAAW,eAAe,QAAQ,SAAS,aAAa;GAC1D;EACF,CAAC,GACD,YAAY;GACV,iBAAiB;GACjB,cAAc,eAAe,QAAQ,gBAAgB;GACrD,QAAQ,eAAe,QAAQ,UAAU;EAC3C,CAAC,CACH,GAQA,YAAY,EAAC,mBAAmB,CAAC;GAAC,MAAM;GAAmB,UAAU;GAAM,aAAa;EAAK,CAAC,EAAC;EAG/F,IAAM,cAAc,eAAe,aAC/B,GAAG,gBAAgB,QAAQ,IAAI,CAAC,EAAE,GAAG,YACrC,KAAA;EAsBJ,IApBA,iBAAiB,gBAAgB,cAAc,aAAa;GAC1D,GAAG,yBAAyB,gBAAgB,YAAY;GAIxD,gBAAgB;GAIhB,GAAI,eAAe,CAAC,QAAQ,WAAW,iBAAiB,QAAQ,iBAAiB,SAC7E,EACE,OAAO,aACL,iBAAiB,QACb,WAAW,KAAK,UAAU,WAAW,EAAE,KACvC,UAAU,KAAK,UAAU,WAAW,GAC1C,EACF,IACA,CAAC;EACP,IAEI,eAAe,YAAY;GAG7B,QAAQ,KAAK,cAAc,EAAC,UAAU,GAAG,QAAQ,KAAI,CAAC,CAAC;GAIvD,IAAM,uBAAuB,2BAA2B,SAAS,MAAM;GACvE,iBAAiB,eACf,gBAAgB,YAAY,KAAK,WAAW,oBAAoB;EACpE;CACF;CASA,OAAOA,eAAmB;EACxB;EACA;EACA;EACA,SAAA;GAVA,SAAS;GAET,YAAY;GACZ,GAAI,iBAAiB,EAAC,cAAa;EAO7B;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;GAAC,UAAU;GAAM,SAAS;GAAO,QAAQ;EAAK;CAOxD,CAAC;AACH"}
+{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import type {Options as VanillaExtractPluginOptions} from '@sanity/vanilla-extract-tsdown-plugin'\nimport type {PluginOptions as ReactCompilerPluginOptions} from 'babel-plugin-react-compiler'\nimport {detect} from 'package-manager-detector/detect'\nimport {\n  defineConfig as defineTsdownConfig,\n  mergeConfig,\n  type Rolldown,\n  type UserConfig,\n} from 'tsdown'\n\n/**\n * Options for the `vanillaExtract` option — the same options as\n * `@sanity/vanilla-extract-tsdown-plugin` (`identifiers`, `fileName`, `minify`, `target`, and\n * `inject`, all modeled after the `css` options of `@tsdown/css`), with one different default:\n * `inject` defaults to `{nodeCompat: true}` (instead of the plugin's `false`), wiring up the\n * conditional CSS export pattern that Sanity libraries ship with. Set `inject: true` for a plain\n * relative CSS import, or `inject: false` to only extract the CSS.\n * @public\n */\nexport type PackageVanillaExtractOptions = VanillaExtractPluginOptions\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * Options for the React Compiler, the same options as `babel-plugin-react-compiler`.\n * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer\n * dependency, required to use `reactCompiler`) is installed, and always match the installed\n * version of the compiler.\n * @public\n */\nexport type ReactCompilerOptions = Partial<ReactCompilerPluginOptions>\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<\n  UserConfig,\n  'tsconfig' | 'entry' | 'format' | 'dts' | 'define' | 'target'\n> {\n  /**\n   * @defaultValue 'neutral'\n   */\n  platform?: UserConfig['platform']\n  /**\n   * tsdown's `exports` option, with defaults suited for publishing Sanity libraries:\n   * `enabled: 'local-only'` generates the `exports` map during local builds and skips it in CI\n   * (where the committed `package.json` is already up to date). When pnpm is detected,\n   * `devExports: true` also keeps the local `exports` map pointing at source files while\n   * `publishConfig.exports` receives the built files.\n   *\n   * Userland values apply with tsdown's `mergeConfig` semantics: an object deep-merges over\n   * these defaults (so individual fields can be overridden), while any other value - `false`\n   * to disable exports generation, or a bare CI condition (`'ci-only'`/`'local-only'`) -\n   * replaces them entirely.\n   * @defaultValue `{enabled: 'local-only', devExports: true}` for pnpm projects;\n   * `{enabled: 'local-only'}` otherwise.\n   */\n  exports?: UserConfig['exports']\n  /**\n   * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published\n   * components are memoized automatically. Pass `true` to use the defaults, or an options object\n   * to configure the compiler (e.g. `{target: '18'}`).\n   * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`\n   * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the\n   * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.\n   * @defaultValue false\n   */\n  reactCompiler?: boolean | ReactCompilerOptions\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n  /**\n   * Enables `@sanity/vanilla-extract-tsdown-plugin` to extract CSS into a separate,\n   * `lightningcss`-optimized file. Pass `true` to use the defaults, or an object to customize.\n   *\n   * By default (`inject: {nodeCompat: true}`) the plugin also injects the self-referential\n   * `import \"<pkg>/bundle.css\"`, emits a `bundle.css.js` shim, and writes the conditional\n   * `\"./bundle.css\"` export to `package.json` - see {@link PackageVanillaExtractOptions}.\n   * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.\n   * @alpha\n   */\n  vanillaExtract?: boolean | PackageVanillaExtractOptions\n}\n\n/**\n * @public\n */\nexport async function defineConfig(options: PackageOptions = {}): Promise<UserConfig> {\n  // `tsconfig`, `entry`, `dts`, `define` and `target` are passed through to tsdown as-is. When\n  // left undefined, tsdown keeps its default behavior (`tsconfig` is auto-detected from the\n  // project, `dts` from `package.json`, `define` replaces nothing, and `target` applies no\n  // syntax downleveling).\n  const {entry, tsconfig, dts, define, target} = options\n  const platform = options.platform ?? 'neutral'\n  const reactCompiler = options.reactCompiler ?? false\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const publint = true\n  const format = options.format ?? 'esm'\n  const inputOptions = {\n    // https://github.com/rolldown/rolldown/blob/main/packages/rolldown/src/options/docs/preserve-entry-signatures.md#strict\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } as const satisfies UserConfig['inputOptions']\n\n  // `outputOptions` is left to tsdown's defaults - notably chunk filenames keep tsdown's hashed\n  // default (unless userland sets `hash`), which prevents chunk/entry filename collisions\n  // (https://github.com/sanity-io/ui/issues/2262).\n  const plugins: Rolldown.Plugin[] = []\n  if (reactCompiler !== false) {\n    // Follows the official tsdown recipe for the React Compiler:\n    // https://tsdown.dev/recipes/react-support#enabling-react-compiler\n    // The plugins are lazy loaded so they're only paid for when the React Compiler is enabled.\n    // `babel-plugin-react-compiler` itself is resolved by Babel from the consumer package during\n    // the build, which is why it can be an optional peer dependency. Once rolldown ships its rust\n    // port of the React Compiler this can be swapped out for an oxc transform, like `styledComponents`.\n    const [{default: pluginBabel}, {reactCompilerPreset}] = await Promise.all([\n      import('@rolldown/plugin-babel'),\n      import('@vitejs/plugin-react'),\n    ])\n    plugins.push(\n      await pluginBabel({\n        presets: [reactCompilerPreset(typeof reactCompiler === 'object' ? reactCompiler : {})],\n      }),\n    )\n  }\n  if (options.vanillaExtract) {\n    // Lazy loaded, like `reactCompiler`, so the CSS toolchain is only paid for when the option is\n    // enabled. The plugin compiles the `.css.ts` files and extracts the CSS into a single\n    // `lightningcss`-optimized file. Its `inject` option is general purpose (and, like\n    // `css.inject` in `@tsdown/css`, disabled by default), so this config supplies the default\n    // most Sanity libraries want: `{nodeCompat: true}` wires up the whole conditional CSS export\n    // pattern - the self-referential CSS import, the no-op JS shim, and the conditional\n    // `./<fileName>` export written through this config's `exports` option (which the plugin's\n    // `tsdownConfig` hook composes into).\n    const {vanillaExtractPlugin} = await import('@sanity/vanilla-extract-tsdown-plugin')\n    plugins.push(\n      vanillaExtractPlugin({\n        inject: {nodeCompat: true},\n        ...(options.vanillaExtract === true ? {} : options.vanillaExtract),\n      }),\n    )\n  }\n\n  const packageManager = await detect({cwd: process.cwd()})\n  // tsdown's `exports` feature is enabled with Sanity-flavored defaults, and userland values\n  // apply with tsdown's own `mergeConfig` semantics: an object deep-merges over the defaults,\n  // anything else (`false`, a CI condition) replaces them.\n  const {exports} = mergeConfig(\n    {\n      exports: {\n        enabled: 'local-only',\n        // Only opt in by default when pnpm is detected: support for replacing package fields\n        // from `publishConfig` is not reliable across package managers.\n        ...(packageManager?.name === 'pnpm' && {devExports: true}),\n      },\n    },\n    {exports: options.exports},\n  )\n\n  return defineTsdownConfig({\n    define,\n    dts,\n    entry,\n    exports,\n    format,\n    inputOptions,\n    platform,\n    plugins,\n    publint,\n    report,\n    target,\n    tsconfig,\n    minify: {compress: true, codegen: false, mangle: false},\n  })\n}\n"],"mappings":";;;;;AAqHA,eAAsB,aAAa,UAA0B,CAAC,GAAwB;CAKpF,IAAM,EAAC,OAAO,UAAU,KAAK,QAAQ,WAAU,SACzC,WAAW,QAAQ,YAAY,WAC/B,gBAAgB,QAAQ,iBAAiB,IACzC,mBAAmB,QAAQ,oBAAoB,IAC/C,SAAS,EAAC,MAAM,GAAK,GAErB,SAAS,QAAQ,UAAU,OAC3B,eAAe;EAEnB,yBAAyB;EACzB,cAAc,EAAC,iBAAiB,OAAM;EACtC,GAAI,qBAAqB,MAAS,EAChC,WAAW,EACT,SAAS,EACP,kBAAkB;GAIhB,UAAU;GAIV,2BAA2B;GAG3B,MAAM;GAGN,SAAS;GACT,GAAI,OAAO,oBAAqB,WAAW,mBAAmB,CAAC;EACjE,EACF,EACF,EACF;CACF,GAKM,UAA6B,CAAC;CACpC,IAAI,kBAAkB,IAAO;EAO3B,IAAM,CAAC,EAAC,SAAS,eAAc,EAAC,yBAAwB,MAAM,QAAQ,IAAI,CACxE,OAAO,2BACP,OAAO,uBACT,CAAC;EACD,QAAQ,KACN,MAAM,YAAY,EAChB,SAAS,CAAC,oBAAoB,OAAO,iBAAkB,WAAW,gBAAgB,CAAC,CAAC,CAAC,EACvF,CAAC,CACH;CACF;CACA,IAAI,QAAQ,gBAAgB;EAS1B,IAAM,EAAC,yBAAwB,MAAM,OAAO;EAC5C,QAAQ,KACN,qBAAqB;GACnB,QAAQ,EAAC,YAAY,GAAI;GACzB,GAAI,QAAQ,mBAAmB,KAAO,CAAC,IAAI,QAAQ;EACrD,CAAC,CACH;CACF;CAMA,IAAM,EAAC,YAAW,YAChB,EACE,SAAS;EACP,SAAS;EAGT,IAAI,MAVmB,OAAO,EAAC,KAAK,QAAQ,IAAI,EAAC,CAAC,EAAA,EAU9B,SAAS,UAAU,EAAC,YAAY,GAAI;CAC1D,EACF,GACA,EAAC,SAAS,QAAQ,QAAO,CAC3B;CAEA,OAAOA,eAAmB;EACxB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;GAAC,UAAU;GAAM,SAAS;GAAO,QAAQ;EAAK;CACxD,CAAC;AACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/tsdown-config",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "Shared configuration for tsdown",
   "keywords": [
     "sanity-io",
@@ -37,12 +37,10 @@
   "dependencies": {
     "@babel/core": "^7.29.7",
     "@rolldown/plugin-babel": "^0.2.3",
-    "@sanity/browserslist-config": "^1.0.5",
-    "@vanilla-extract/rollup-plugin": "^1.5.4",
     "@vitejs/plugin-react": "^6.0.3",
-    "browserslist": "^4.28.5",
-    "lightningcss": "^1.32.0",
-    "publint": "^0.3.21"
+    "package-manager-detector": "^1.7.0",
+    "publint": "^0.3.21",
+    "@sanity/vanilla-extract-tsdown-plugin": "^0.1.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
@@ -51,12 +49,12 @@
     "tsdown": "^0.22.5",
     "typescript": "7.0.2",
     "vitest": "^4.1.10",
-    "@sanity/pkg-utils": "^11.0.1",
+    "@sanity/pkg-utils": "^11.0.2",
     "@sanity/tsconfig": "^2.2.0"
   },
   "peerDependencies": {
     "babel-plugin-react-compiler": "*",
-    "tsdown": "0.22.5",
+    "tsdown": "^0.22.5",
     "typescript": "6.x || 7.x"
   },
   "peerDependenciesMeta": {

package/dist/_chunks-es/bundleCssShim.mjs

@@ -1,34 +0,0 @@
-/**
-* Emits a no-op JavaScript shim (`export default ""`) alongside the extracted CSS. The conditional
-* `./<css>` export points its `node`/`default` conditions at this file so that the self-referential
-* `import "<pkg>/<css>"` resolves to a harmless module in runtimes that cannot import `.css` files,
-* instead of throwing `Error: Unknown file extension ".css"`.
-*
-* A matching `.d.ts` declaration is emitted next to the shim as well. Both the `browser`/`style`
-* (`<css>`) and the `node`/`default` (`<css>.js`) conditions of the `./<css>` export resolve their
-* types to the same `<css>.d.ts` file, so type-aware tooling (e.g. dts export checkers that load a
-* `.d.ts` for every export target) does not crash on a missing declaration file.
-*
-* @param options.fileName - The shim file name, e.g. `bundle.css.js`.
-* @internal
-*/
-function bundleCssShim(options) {
-	let cssName = options.fileName.replace(/\.js$/, "");
-	return {
-		name: "sanity-tsdown-config:bundle-css-shim",
-		generateBundle() {
-			this.emitFile({
-				type: "asset",
-				fileName: options.fileName,
-				source: `// No-op shim for \`${cssName}\` in runtimes that cannot import \`.css\` files directly.\nexport default ""\n`
-			}), this.emitFile({
-				type: "asset",
-				fileName: `${cssName}.d.ts`,
-				source: `// Type declarations for \`${cssName}\` and its no-op JS shim.\ndeclare const _default: string\nexport default _default\n`
-			});
-		}
-	};
-}
-export { bundleCssShim };
-
-//# sourceMappingURL=bundleCssShim.mjs.map

package/dist/_chunks-es/bundleCssShim.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundleCssShim.mjs","names":[],"sources":["../../src/bundleCssShim.ts"],"sourcesContent":["import type {Rolldown} from 'tsdown'\n\n/**\n * Emits a no-op JavaScript shim (`export default \"\"`) alongside the extracted CSS. The conditional\n * `./<css>` export points its `node`/`default` conditions at this file so that the self-referential\n * `import \"<pkg>/<css>\"` resolves to a harmless module in runtimes that cannot import `.css` files,\n * instead of throwing `Error: Unknown file extension \".css\"`.\n *\n * A matching `.d.ts` declaration is emitted next to the shim as well. Both the `browser`/`style`\n * (`<css>`) and the `node`/`default` (`<css>.js`) conditions of the `./<css>` export resolve their\n * types to the same `<css>.d.ts` file, so type-aware tooling (e.g. dts export checkers that load a\n * `.d.ts` for every export target) does not crash on a missing declaration file.\n *\n * @param options.fileName - The shim file name, e.g. `bundle.css.js`.\n * @internal\n */\nexport function bundleCssShim(options: {fileName: string}): Rolldown.Plugin {\n  const cssName = options.fileName.replace(/\\.js$/, '')\n\n  return {\n    name: 'sanity-tsdown-config:bundle-css-shim',\n    generateBundle() {\n      this.emitFile({\n        type: 'asset',\n        fileName: options.fileName,\n        source: `// No-op shim for \\`${cssName}\\` in runtimes that cannot import \\`.css\\` files directly.\\nexport default \"\"\\n`,\n      })\n      this.emitFile({\n        type: 'asset',\n        fileName: `${cssName}.d.ts`,\n        source: `// Type declarations for \\`${cssName}\\` and its no-op JS shim.\\ndeclare const _default: string\\nexport default _default\\n`,\n      })\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,SAA8C;CAC1E,IAAM,UAAU,QAAQ,SAAS,QAAQ,SAAS,EAAE;CAEpD,OAAO;EACL,MAAM;EACN,iBAAiB;GAMf,AALA,KAAK,SAAS;IACZ,MAAM;IACN,UAAU,QAAQ;IAClB,QAAQ,uBAAuB,QAAQ;GACzC,CAAC,GACD,KAAK,SAAS;IACZ,MAAM;IACN,UAAU,GAAG,QAAQ;IACrB,QAAQ,8BAA8B,QAAQ;GAChD,CAAC;EACH;CACF;AACF"}

package/dist/_chunks-es/optimizeCss.mjs

@@ -1,38 +0,0 @@
-import { basename } from "node:path";
-import browserslist from "browserslist";
-import { browserslistToTargets, transform } from "lightningcss";
-/**
-* Post-processes the CSS file extracted by `@vanilla-extract/rollup-plugin` with `lightningcss`,
-* applying browserslist targets and (unless disabled) minification. Ported from the equivalent
-* `@sanity/pkg-utils` Rollup plugin.
-* @internal
-*/
-function optimizeCss(options) {
-	return {
-		name: "sanity-tsdown-config:optimize-css",
-		async generateBundle(_outputOptions, bundle, _isWrite) {
-			for (let [fileName, assetOrChunk] of Object.entries(bundle)) if (assetOrChunk.type === "asset") {
-				let asset = assetOrChunk;
-				if (asset.fileName === options.extractFileName || asset.originalFileNames.includes(options.extractFileName)) {
-					let sourceMap = bundle[`${fileName}.map`];
-					await transformCss(asset, sourceMap?.type === "asset" ? sourceMap : void 0, options.browserslist, options.minify ?? !0);
-				}
-			}
-		}
-	};
-}
-async function transformCss(asset, sourceMapAsset, browserslistConfig, minify) {
-	let css = asset.source.toString(), file = asset.fileName, targets = browserslistToTargets(browserslist(browserslistConfig)), lightningCssResult = transform({
-		filename: file,
-		code: Buffer.from(css),
-		minify,
-		cssModules: !1,
-		targets,
-		sourceMap: !!sourceMapAsset,
-		inputSourceMap: sourceMapAsset ? sourceMapAsset.source.toString() : void 0
-	});
-	lightningCssResult.warnings.length && console.warn(lightningCssResult.warnings), asset.source = new TextDecoder().decode(lightningCssResult.code), sourceMapAsset && lightningCssResult.map && (sourceMapAsset.source = new TextDecoder().decode(lightningCssResult.map), asset.source += `\n/*# sourceMappingURL=${basename(sourceMapAsset.fileName)}*/\n`);
-}
-export { optimizeCss };
-
-//# sourceMappingURL=optimizeCss.mjs.map

package/dist/_chunks-es/optimizeCss.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"optimizeCss.mjs","names":[],"sources":["../../src/optimizeCss.ts"],"sourcesContent":["import {basename} from 'node:path'\nimport browserslist from 'browserslist'\nimport {browserslistToTargets, transform} from 'lightningcss'\nimport type {Rolldown} from 'tsdown'\n\n/**\n * Post-processes the CSS file extracted by `@vanilla-extract/rollup-plugin` with `lightningcss`,\n * applying browserslist targets and (unless disabled) minification. Ported from the equivalent\n * `@sanity/pkg-utils` Rollup plugin.\n * @internal\n */\nexport function optimizeCss(options: {\n  extractFileName: string\n  browserslist: string | string[]\n  minify?: boolean\n}): Rolldown.Plugin {\n  return {\n    name: 'sanity-tsdown-config:optimize-css',\n\n    async generateBundle(_outputOptions, bundle, _isWrite) {\n      for (const [fileName, assetOrChunk] of Object.entries(bundle)) {\n        // find the extracted CSS asset\n        if (assetOrChunk.type === 'asset') {\n          const asset = assetOrChunk\n          if (\n            asset.fileName === options.extractFileName ||\n            asset.originalFileNames.includes(options.extractFileName)\n          ) {\n            const sourceMap = bundle[`${fileName}.map`]\n            await transformCss(\n              asset,\n              sourceMap?.type === 'asset' ? sourceMap : undefined,\n              options.browserslist,\n              options.minify ?? true,\n            )\n          }\n        }\n      }\n    },\n  }\n}\n\nasync function transformCss(\n  asset: Rolldown.OutputAsset,\n  sourceMapAsset: Rolldown.OutputAsset | undefined,\n  browserslistConfig: string | string[],\n  minify: boolean,\n) {\n  const css = asset.source.toString()\n  const file = asset.fileName\n\n  const targets = browserslistToTargets(browserslist(browserslistConfig))\n\n  // process (and, unless disabled, minify) css using lightningcss\n  const lightningCssResult = transform({\n    filename: file,\n    code: Buffer.from(css),\n    minify,\n    cssModules: false,\n    targets,\n    sourceMap: !!sourceMapAsset,\n    inputSourceMap: sourceMapAsset ? sourceMapAsset.source.toString() : undefined,\n  })\n\n  if (lightningCssResult.warnings.length) {\n    console.warn(lightningCssResult.warnings)\n  }\n\n  asset.source = new TextDecoder().decode(lightningCssResult.code)\n  if (sourceMapAsset && lightningCssResult.map) {\n    sourceMapAsset.source = new TextDecoder().decode(lightningCssResult.map)\n    asset.source += `\\n/*# sourceMappingURL=${basename(sourceMapAsset.fileName)}*/\\n`\n  }\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,YAAY,SAIR;CAClB,OAAO;EACL,MAAM;EAEN,MAAM,eAAe,gBAAgB,QAAQ,UAAU;GACrD,KAAK,IAAM,CAAC,UAAU,iBAAiB,OAAO,QAAQ,MAAM,GAE1D,IAAI,aAAa,SAAS,SAAS;IACjC,IAAM,QAAQ;IACd,IACE,MAAM,aAAa,QAAQ,mBAC3B,MAAM,kBAAkB,SAAS,QAAQ,eAAe,GACxD;KACA,IAAM,YAAY,OAAO,GAAG,SAAS;KACrC,MAAM,aACJ,OACA,WAAW,SAAS,UAAU,YAAY,KAAA,GAC1C,QAAQ,cACR,QAAQ,UAAU,EACpB;IACF;GACF;EAEJ;CACF;AACF;AAEA,eAAe,aACb,OACA,gBACA,oBACA,QACA;CACA,IAAM,MAAM,MAAM,OAAO,SAAS,GAC5B,OAAO,MAAM,UAEb,UAAU,sBAAsB,aAAa,kBAAkB,CAAC,GAGhE,qBAAqB,UAAU;EACnC,UAAU;EACV,MAAM,OAAO,KAAK,GAAG;EACrB;EACA,YAAY;EACZ;EACA,WAAW,CAAC,CAAC;EACb,gBAAgB,iBAAiB,eAAe,OAAO,SAAS,IAAI,KAAA;CACtE,CAAC;CAOD,AALI,mBAAmB,SAAS,UAC9B,QAAQ,KAAK,mBAAmB,QAAQ,GAG1C,MAAM,SAAS,IAAI,YAAY,CAAC,CAAC,OAAO,mBAAmB,IAAI,GAC3D,kBAAkB,mBAAmB,QACvC,eAAe,SAAS,IAAI,YAAY,CAAC,CAAC,OAAO,mBAAmB,GAAG,GACvE,MAAM,UAAU,0BAA0B,SAAS,eAAe,QAAQ,EAAE;AAEhF"}

package/dist/_chunks-es/vanillaExtract.mjs

@@ -1,77 +0,0 @@
-import path from "node:path";
-import { readFileSync } from "node:fs";
-/**
-* Normalize the `vanillaExtract` option into a consistent shape and resolve whether compatibility
-* mode is active.
-* @internal
-*/
-function resolveVanillaExtract(value) {
-	let enabled = !!value, options = value === !0 || !value ? {} : value;
-	return {
-		enabled,
-		options,
-		compatMode: enabled ? options.extract?.compatMode ?? !0 : !1
-	};
-}
-/**
-* Resolve the name of the emitted CSS file. Unlike `@sanity/pkg-utils`, tsdown produces a single
-* bundle that is shared across runtimes, so there are no runtime-suffixed defaults.
-* @internal
-*/
-function resolveVanillaExtractCssName(options) {
-	return options.extract?.name ?? "bundle.css";
-}
-/**
-* Build the conditional CSS export object that vanilla-extract compat mode expects, e.g.
-* ```json
-* {
-*   "browser": "./dist/bundle.css",
-*   "style": "./dist/bundle.css",
-*   "node": "./dist/bundle.css.js",
-*   "default": "./dist/bundle.css.js"
-* }
-* ```
-* @internal
-*/
-function createConditionalCssExport(cssName, outDir) {
-	let cssFile = `./${outDir}/${cssName}`, shimFile = `./${outDir}/${cssName}.js`;
-	return {
-		browser: cssFile,
-		style: cssFile,
-		node: shimFile,
-		default: shimFile
-	};
-}
-/**
-* Insert (or replace) the `"./<cssName>"` export in an `exports`-shaped map, preserving the
-* existing order and placing it before `./package.json` when present. Used with tsdown's
-* `exports.customExports` so both `exports` and `publishConfig.exports` receive the entry.
-* @internal
-*/
-function insertCssExport(exports, exportKey, conditionalExport) {
-	let nextExports = {}, inserted = !1;
-	for (let [key, value] of Object.entries(exports)) key !== exportKey && (key === "./package.json" && !inserted && (nextExports[exportKey] = conditionalExport, inserted = !0), nextExports[key] = value);
-	return inserted || (nextExports[exportKey] = conditionalExport), nextExports;
-}
-const RE_DTS = /\.d\.[cm]?ts$/;
-/**
-* Build an `intro` function that prepends `autoImport` to the `index` entry chunk only. The
-* `.d.ts` chunks generated by tsdown share the build, so they are explicitly excluded.
-* @internal
-*/
-function composeIntro(autoImport) {
-	return (chunk) => chunk.isEntry && chunk.name === "index" && !RE_DTS.test(chunk.fileName) ? `${autoImport}\n` : "";
-}
-/**
-* Resolve the package name from `package.json`, required by compat mode to inject the
-* self-referential CSS import.
-* @internal
-*/
-function readPackageName(cwd) {
-	let pkgPath = path.resolve(cwd, "package.json"), pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-	if (typeof pkg.name != "string" || !pkg.name) throw Error(`Unable to resolve the package name from ${pkgPath}, which is required by \`vanillaExtract\` compat mode to inject the self-referential CSS import. Set \`vanillaExtract: {extract: {compatMode: false}}\` to wire up the CSS export manually.`);
-	return pkg.name;
-}
-export { composeIntro, createConditionalCssExport, insertCssExport, readPackageName, resolveVanillaExtract, resolveVanillaExtractCssName };
-
-//# sourceMappingURL=vanillaExtract.mjs.map

package/dist/_chunks-es/vanillaExtract.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"vanillaExtract.mjs","names":[],"sources":["../../src/vanillaExtract.ts"],"sourcesContent":["import {readFileSync} from 'node:fs'\nimport path from 'node:path'\nimport type {Options as VanillaExtractPluginOptions} from '@vanilla-extract/rollup-plugin'\nimport type {Rolldown} from 'tsdown'\n\n/** The default name of the extracted CSS file. */\nconst DEFAULT_VANILLA_EXTRACT_CSS_NAME = 'bundle.css'\n\n/**\n * Options for the `@vanilla-extract/rollup-plugin` integration, including the same extensions as\n * `@sanity/pkg-utils` (`minify`, `browserslist`, and `extract.compatMode`).\n * @public\n */\nexport interface PackageVanillaExtractOptions extends Omit<VanillaExtractPluginOptions, 'extract'> {\n  /**\n   * Minify the extracted CSS with `lightningcss`.\n   * @defaultValue true\n   */\n  minify?: boolean\n  /**\n   * Browserslist query passed to `lightningcss` when optimizing the extracted CSS.\n   * @defaultValue `@sanity/browserslist-config`\n   */\n  browserslist?: string | string[]\n  /**\n   * Different formatting of identifiers (e.g. class names, keyframes, CSS Vars, etc).\n   * @defaultValue \"short\"\n   */\n  identifiers?: VanillaExtractPluginOptions['identifiers']\n  /**\n   * Extract the CSS into a separate file. The CSS is always extracted, so this configures _how_.\n   */\n  extract?: {\n    /**\n     * Name of the emitted `.css` file (and, with `compatMode`, the `exports` subpath + shim base).\n     * @defaultValue \"bundle.css\"\n     */\n    name?: string\n    /**\n     * Generate a `.css.map` sourcemap file.\n     * @defaultValue true\n     */\n    sourcemap?: boolean\n    /**\n     * Compatibility mode automatically wires up the conditional CSS export pattern so userland does\n     * not have to. When enabled, the config:\n     *\n     * - injects `import \"<pkg-name>/<name>\"` into the `index` entry chunk,\n     * - emits a no-op `<name>.js` shim for runtimes that cannot import `.css` files, and\n     * - writes the conditional `\"./<name>\"` export to `package.json`\n     *   (`browser`/`style` → the real CSS, `node`/`default` → the shim).\n     *\n     * The result is that `import \"<pkg>/<name>\"` resolves to the real CSS in bundlers/browsers and\n     * to the no-op shim in Node and similar runtimes. Disable it to wire these up yourself.\n     * @defaultValue true\n     */\n    compatMode?: boolean\n  }\n}\n\n/** @internal */\nexport interface ResolvedVanillaExtract {\n  enabled: boolean\n  /** Normalized options (the object form, or `{}` when `vanillaExtract: true`). */\n  options: PackageVanillaExtractOptions\n  /**\n   * Whether to automatically wire up the conditional CSS export pattern (intro import, JS shim, and\n   * the `package.json` export). Only `true` when vanilla-extract is enabled.\n   */\n  compatMode: boolean\n}\n\n/**\n * Normalize the `vanillaExtract` option into a consistent shape and resolve whether compatibility\n * mode is active.\n * @internal\n */\nexport function resolveVanillaExtract(\n  value: boolean | PackageVanillaExtractOptions | undefined,\n): ResolvedVanillaExtract {\n  const enabled = Boolean(value)\n  const options: PackageVanillaExtractOptions = value === true || !value ? {} : value\n  const compatMode = enabled ? (options.extract?.compatMode ?? true) : false\n\n  return {enabled, options, compatMode}\n}\n\n/**\n * Resolve the name of the emitted CSS file. Unlike `@sanity/pkg-utils`, tsdown produces a single\n * bundle that is shared across runtimes, so there are no runtime-suffixed defaults.\n * @internal\n */\nexport function resolveVanillaExtractCssName(options: PackageVanillaExtractOptions): string {\n  return options.extract?.name ?? DEFAULT_VANILLA_EXTRACT_CSS_NAME\n}\n\n/**\n * Build the conditional CSS export object that vanilla-extract compat mode expects, e.g.\n * ```json\n * {\n *   \"browser\": \"./dist/bundle.css\",\n *   \"style\": \"./dist/bundle.css\",\n *   \"node\": \"./dist/bundle.css.js\",\n *   \"default\": \"./dist/bundle.css.js\"\n * }\n * ```\n * @internal\n */\nexport function createConditionalCssExport(\n  cssName: string,\n  outDir: string,\n): Record<string, string> {\n  const cssFile = `./${outDir}/${cssName}`\n  const shimFile = `./${outDir}/${cssName}.js`\n  return {browser: cssFile, style: cssFile, node: shimFile, default: shimFile}\n}\n\n/**\n * Insert (or replace) the `\"./<cssName>\"` export in an `exports`-shaped map, preserving the\n * existing order and placing it before `./package.json` when present. Used with tsdown's\n * `exports.customExports` so both `exports` and `publishConfig.exports` receive the entry.\n * @internal\n */\nexport function insertCssExport(\n  exports: Record<string, unknown>,\n  exportKey: string,\n  conditionalExport: Record<string, string>,\n): Record<string, unknown> {\n  const nextExports: Record<string, unknown> = {}\n  let inserted = false\n  for (const [key, value] of Object.entries(exports)) {\n    if (key === exportKey) continue\n    if (key === './package.json' && !inserted) {\n      nextExports[exportKey] = conditionalExport\n      inserted = true\n    }\n    nextExports[key] = value\n  }\n  if (!inserted) {\n    nextExports[exportKey] = conditionalExport\n  }\n  return nextExports\n}\n\nconst RE_DTS = /\\.d\\.[cm]?ts$/\n\n/**\n * Build an `intro` function that prepends `autoImport` to the `index` entry chunk only. The\n * `.d.ts` chunks generated by tsdown share the build, so they are explicitly excluded.\n * @internal\n */\nexport function composeIntro(autoImport: string): (chunk: Rolldown.RenderedChunk) => string {\n  return (chunk) =>\n    chunk.isEntry && chunk.name === 'index' && !RE_DTS.test(chunk.fileName) ? `${autoImport}\\n` : ''\n}\n\n/**\n * Resolve the package name from `package.json`, required by compat mode to inject the\n * self-referential CSS import.\n * @internal\n */\nexport function readPackageName(cwd: string): string {\n  const pkgPath = path.resolve(cwd, 'package.json')\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as {name?: unknown}\n  if (typeof pkg.name !== 'string' || !pkg.name) {\n    throw new Error(\n      `Unable to resolve the package name from ${pkgPath}, which is required by \\`vanillaExtract\\` compat mode to inject the self-referential CSS import. Set \\`vanillaExtract: {extract: {compatMode: false}}\\` to wire up the CSS export manually.`,\n    )\n  }\n  return pkg.name\n}\n"],"mappings":";;;;;;;AA6EA,SAAgB,sBACd,OACwB;CACxB,IAAM,UAAU,EAAQ,OAClB,UAAwC,UAAU,MAAQ,CAAC,QAAQ,CAAC,IAAI;CAG9E,OAAO;EAAC;EAAS;EAAS,YAFP,UAAW,QAAQ,SAAS,cAAc,KAAQ;CAEjC;AACtC;;;;;;AAOA,SAAgB,6BAA6B,SAA+C;CAC1F,OAAO,QAAQ,SAAS,QAAQ;AAClC;;;;;;;;;;;;;AAcA,SAAgB,2BACd,SACA,QACwB;CACxB,IAAM,UAAU,KAAK,OAAO,GAAG,WACzB,WAAW,KAAK,OAAO,GAAG,QAAQ;CACxC,OAAO;EAAC,SAAS;EAAS,OAAO;EAAS,MAAM;EAAU,SAAS;CAAQ;AAC7E;;;;;;;AAQA,SAAgB,gBACd,SACA,WACA,mBACyB;CACzB,IAAM,cAAuC,CAAC,GAC1C,WAAW;CACf,KAAK,IAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAC3C,QAAQ,cACR,QAAQ,oBAAoB,CAAC,aAC/B,YAAY,aAAa,mBACzB,WAAW,KAEb,YAAY,OAAO;CAKrB,OAHK,aACH,YAAY,aAAa,oBAEpB;AACT;AAEA,MAAM,SAAS;;;;;;AAOf,SAAgB,aAAa,YAA+D;CAC1F,QAAQ,UACN,MAAM,WAAW,MAAM,SAAS,WAAW,CAAC,OAAO,KAAK,MAAM,QAAQ,IAAI,GAAG,WAAW,MAAM;AAClG;;;;;;AAOA,SAAgB,gBAAgB,KAAqB;CACnD,IAAM,UAAU,KAAK,QAAQ,KAAK,cAAc,GAE1C,MAAM,KAAK,MAAM,aAAa,SAAS,MAAM,CAAC;CACpD,IAAI,OAAO,IAAI,QAAS,YAAY,CAAC,IAAI,MACvC,MAAU,MACR,2CAA2C,QAAQ,4LACrD;CAEF,OAAO,IAAI;AACb"}