tailwindcss-patch 8.3.0 → 8.4.0

package/README.md

@@ -59,6 +59,40 @@ cli.help()
 cli.parse()
 ```
 
+#### Custom command hooks
+
+Hosts can override per-command lifecycles by supplying `commandHandlers`. Each handler receives a context object (with the resolved `cwd`, parsed `args`, memoized `loadConfig`/`createPatcher` helpers, and the shared `logger`) plus a `next()` callback that runs the built-in action.
+
+```ts
+mountTailwindcssPatchCommands(cli, {
+  commandHandlers: {
+    install: async (ctx) => {
+      const patcher = await ctx.createPatcher()
+      await clearTailwindcssPatcherCache(ctx.cwd)
+      await patcher.patch()
+      await saveCliPatchTargetRecord({ cwd: ctx.cwd })
+    },
+    extract: async (ctx, next) => {
+      const result = await next() // run the default extract implementation
+      ctx.logger.success(`[host] wrote ${result.classList.length} classes`)
+      return result
+    },
+  },
+  commandOptions: {
+    extract: {
+      description: 'Localised extract command',
+      appendDefaultOptions: false,
+      optionDefs: [
+        { flags: '--entry <file>', description: 'Tailwind CSS entry file' },
+        { flags: '--preview', description: 'Print a preview instead of writing' },
+      ],
+    },
+  },
+})
+```
+
+Skip `next()` to fully replace a command (e.g. custom `init` or cache clearing before `install`). Calling `next()` returns the default result—`ExtractResult`, `TailwindTokenReport`, etc.—so hosts can log metadata or feed it into their own telemetry without re-implementing the commands.
+
 ### Extract options
 
 | Flag                     | Description                                                      |
@@ -73,13 +107,13 @@ The CLI loads `tailwindcss-patch.config.ts` via `@tailwindcss-mangle/config`. Le
 
 ### Token report options
 
-| Flag                     | Description                                                                 |
-| ------------------------ | --------------------------------------------------------------------------- |
-| `--cwd <dir>`            | Use a different working directory when loading configuration.               |
-| `--output <file>`        | Override the token report target file (defaults to `.tw-patch/tw-token-report.json`). |
+| Flag                                   | Description                                                                               |
+| -------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `--cwd <dir>`                          | Use a different working directory when loading configuration.                             |
+| `--output <file>`                      | Override the token report target file (defaults to `.tw-patch/tw-token-report.json`).     |
 | `--format <json\|lines\|grouped-json>` | Choose between a JSON payload (default), newline summaries, or JSON grouped by file path. |
-| `--group-key <relative\|absolute>` | Control grouped-json keys (defaults to relative paths). |
-| `--no-write`             | Skip writing to disk and only print a preview.                              |
+| `--group-key <relative\|absolute>`     | Control grouped-json keys (defaults to relative paths).                                   |
+| `--no-write`                           | Skip writing to disk and only print a preview.                                            |
 
 ## Programmatic API
 

package/dist/{chunk-7ZWFVW77.js → chunk-PF5ZTTYM.js}

@@ -1660,156 +1660,143 @@ var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
 var _cac = require('cac'); var _cac2 = _interopRequireDefault(_cac);
 
 
-var tailwindcssPatchCommands = [
-  "install",
-  "extract",
-  "tokens",
-  "init"
-];
-function createTailwindcssPatchCli(options = {}) {
-  const cli = _cac2.default.call(void 0, _nullishCoalesce(options.name, () => ( "tw-patch")));
-  mountTailwindcssPatchCommands(cli, options.mountOptions);
-  return cli;
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init"];
+var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
+var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
+function formatTokenLine(entry) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
 }
-function mountTailwindcssPatchCommands(cli, options = {}) {
-  const prefix = _nullishCoalesce(options.commandPrefix, () => ( ""));
-  const selectedCommands = _nullishCoalesce(options.commands, () => ( tailwindcssPatchCommands));
-  const TOKEN_FORMATS = ["json", "lines", "grouped-json"];
-  const registrars = {
-    install() {
-      const { name, aliases } = resolveCommandNames("install", options, prefix);
-      const command = cli.command(name, "Apply Tailwind CSS runtime patches").option("--cwd <dir>", "Working directory", { default: _process2.default.cwd() }).action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        await patcher.patch();
-        logger_default.success("Tailwind CSS runtime patched successfully.");
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    extract() {
-      const { name, aliases } = resolveCommandNames("extract", options, prefix);
-      const command = cli.command(name, "Collect generated class names into a cache file").option("--cwd <dir>", "Working directory", { default: _process2.default.cwd() }).option("--output <file>", "Override output file path").option("--format <format>", "Output format (json|lines)").option("--css <file>", "Tailwind CSS entry CSS when using v4").option("--no-write", "Skip writing to disk").action(async (args) => {
-        const overrides = {};
-        if (args.output || args.format) {
-          overrides.output = {
-            file: args.output,
-            format: args.format
-          };
-        }
-        if (args.css) {
-          overrides.tailwind = {
-            v4: {
-              cssEntries: [args.css]
-            }
-          };
-        }
-        const patchOptions = await loadPatchOptions(args.cwd, overrides);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const result = await patcher.extract({ write: args.write });
-        if (result.filename) {
-          logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
-        } else {
-          logger_default.success(`Collected ${result.classList.length} classes.`);
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    tokens() {
-      const { name, aliases } = resolveCommandNames("tokens", options, prefix);
-      const command = cli.command(name, "Extract Tailwind tokens with file/position metadata").option("--cwd <dir>", "Working directory", { default: _process2.default.cwd() }).option("--output <file>", "Override output file path", { default: ".tw-patch/tw-token-report.json" }).option("--format <format>", "Output format (json|lines|grouped-json)", { default: "json" }).option("--group-key <key>", "Grouping key for grouped-json output (relative|absolute)", { default: "relative" }).option("--no-write", "Skip writing to disk").action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const report = await patcher.collectContentTokens();
-        const shouldWrite = _nullishCoalesce(args.write, () => ( true));
-        let format = _nullishCoalesce(args.format, () => ( "json"));
-        if (!TOKEN_FORMATS.includes(format)) {
-          format = "json";
-        }
-        const targetFile = _nullishCoalesce(args.output, () => ( ".tw-patch/tw-token-report.json"));
-        const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
-        const buildGrouped = () => groupTokensByFile(report, {
-          key: groupKey,
-          stripAbsolutePaths: groupKey !== "absolute"
-        });
-        const grouped = format === "grouped-json" ? buildGrouped() : null;
-        const resolveGrouped = () => _nullishCoalesce(grouped, () => ( buildGrouped()));
-        if (shouldWrite) {
-          const target = _pathe2.default.resolve(targetFile);
-          await _fsextra2.default.ensureDir(_pathe2.default.dirname(target));
-          if (format === "json") {
-            await _fsextra2.default.writeJSON(target, report, { spaces: 2 });
-          } else if (format === "grouped-json") {
-            await _fsextra2.default.writeJSON(target, resolveGrouped(), { spaces: 2 });
-          } else {
-            const lines = report.entries.map(formatTokenLine);
-            await _fsextra2.default.writeFile(target, `${lines.join("\n")}
-`, "utf8");
-          }
-          logger_default.success(
-            `Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(_process2.default.cwd(), ".")}`
-          );
-        } else {
-          logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
-          if (format === "lines") {
-            const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (report.entries.length > 5) {
-                logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
-              }
-            }
-          } else if (format === "grouped-json") {
-            const map = resolveGrouped();
-            const { preview, moreFiles } = formatGroupedPreview(map);
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (moreFiles > 0) {
-                logger_default.info(`\u2026and ${moreFiles} more files.`);
-              }
-            }
-          } else {
-            const previewEntries = report.entries.slice(0, 3);
-            if (previewEntries.length) {
-              logger_default.log("");
-              logger_default.info(JSON.stringify(previewEntries, null, 2));
-            }
-          }
-        }
-        if (report.skippedFiles.length) {
-          logger_default.warn("Skipped files:");
-          for (const skipped of report.skippedFiles) {
-            logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
-          }
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    init() {
-      const { name, aliases } = resolveCommandNames("init", options, prefix);
-      const command = cli.command(name, "Generate a tailwindcss-patch config file").option("--cwd <dir>", "Working directory", { default: _process2.default.cwd() }).action(async (args) => {
-        await _config.initConfig.call(void 0, args.cwd);
-        logger_default.success(`\u2728 ${_config.CONFIG_NAME}.config.ts initialized!`);
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    }
+function formatGroupedPreview(map, limit = 3) {
+  const files = Object.keys(map);
+  if (!files.length) {
+    return { preview: "", moreFiles: 0 };
+  }
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file];
+    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
+    const suffix = tokens.length > 3 ? ", \u2026" : "";
+    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  });
+  return {
+    preview: lines.join("\n"),
+    moreFiles: Math.max(0, files.length - limit)
   };
-  for (const name of selectedCommands) {
-    const register = registrars[name];
-    if (register) {
-      register();
-    }
+}
+function resolveCwd(rawCwd) {
+  if (!rawCwd) {
+    return _process2.default.cwd();
   }
-  return cli;
+  return _pathe2.default.resolve(rawCwd);
 }
-async function loadPatchOptions(cwd, overrides) {
+function createDefaultRunner(factory) {
+  let promise;
+  return () => {
+    if (!promise) {
+      promise = factory();
+    }
+    return promise;
+  };
+}
+async function loadPatchOptionsForCwd(cwd, overrides) {
   const { config } = await _config.getConfig.call(void 0, cwd);
   const legacyConfig = config;
   const base = _optionalChain([config, 'optionalAccess', _79 => _79.registry]) ? fromUnifiedConfig(config.registry) : _optionalChain([legacyConfig, 'optionalAccess', _80 => _80.patch]) ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
   const merged = defu(_nullishCoalesce(overrides, () => ( {})), base);
   return merged;
 }
+function createCommandContext(cli, command, commandName, args, cwd) {
+  let cachedOptions;
+  let cachedPatcher;
+  let cachedConfig;
+  const loadPatchOptionsForContext = (overrides) => {
+    if (overrides) {
+      return loadPatchOptionsForCwd(cwd, overrides);
+    }
+    if (!cachedOptions) {
+      cachedOptions = loadPatchOptionsForCwd(cwd);
+    }
+    return cachedOptions;
+  };
+  const createPatcherForContext = async (overrides) => {
+    if (overrides) {
+      const patchOptions = await loadPatchOptionsForCwd(cwd, overrides);
+      return new TailwindcssPatcher(patchOptions);
+    }
+    if (!cachedPatcher) {
+      cachedPatcher = loadPatchOptionsForContext().then((options) => new TailwindcssPatcher(options));
+    }
+    return cachedPatcher;
+  };
+  return {
+    cli,
+    command,
+    commandName,
+    args,
+    cwd,
+    logger: logger_default,
+    loadConfig: () => {
+      if (!cachedConfig) {
+        cachedConfig = _config.getConfig.call(void 0, cwd);
+      }
+      return cachedConfig;
+    },
+    loadPatchOptions: loadPatchOptionsForContext,
+    createPatcher: createPatcherForContext
+  };
+}
+function createCwdOptionDefinition(description = "Working directory") {
+  return {
+    flags: "--cwd <dir>",
+    description,
+    config: { default: _process2.default.cwd() }
+  };
+}
+function buildDefaultCommandDefinitions() {
+  return {
+    install: {
+      description: "Apply Tailwind CSS runtime patches",
+      optionDefs: [createCwdOptionDefinition()]
+    },
+    extract: {
+      description: "Collect generated class names into a cache file",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path" },
+        { flags: "--format <format>", description: "Output format (json|lines)" },
+        { flags: "--css <file>", description: "Tailwind CSS entry CSS when using v4" },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    tokens: {
+      description: "Extract Tailwind tokens with file/position metadata",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path", config: { default: DEFAULT_TOKEN_REPORT } },
+        {
+          flags: "--format <format>",
+          description: "Output format (json|lines|grouped-json)",
+          config: { default: "json" }
+        },
+        {
+          flags: "--group-key <key>",
+          description: "Grouping key for grouped-json output (relative|absolute)",
+          config: { default: "relative" }
+        },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    init: {
+      description: "Generate a tailwindcss-patch config file",
+      optionDefs: [createCwdOptionDefinition()]
+    }
+  };
+}
+function addPrefixIfMissing(value, prefix) {
+  if (!prefix || value.startsWith(prefix)) {
+    return value;
+  }
+  return `${prefix}${value}`;
+}
 function resolveCommandNames(command, mountOptions, prefix) {
   const override = _optionalChain([mountOptions, 'access', _81 => _81.commandOptions, 'optionalAccess', _82 => _82[command]]);
   const baseName = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _83 => _83.name]), () => ( command));
@@ -1817,30 +1804,228 @@ function resolveCommandNames(command, mountOptions, prefix) {
   const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _84 => _84.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
   return { name, aliases };
 }
-function addPrefixIfMissing(value, prefix) {
-  if (!prefix || value.startsWith(prefix)) {
-    return value;
+function resolveOptionDefinitions(defaults, override) {
+  if (!override) {
+    return defaults;
   }
-  return `${prefix}${value}`;
+  const appendDefaults = _nullishCoalesce(override.appendDefaultOptions, () => ( true));
+  const customDefs = _nullishCoalesce(override.optionDefs, () => ( []));
+  if (!appendDefaults) {
+    return customDefs;
+  }
+  if (customDefs.length === 0) {
+    return defaults;
+  }
+  return [...defaults, ...customDefs];
 }
-function formatTokenLine(entry) {
-  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
+function applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, _nullishCoalesce(option.description, () => ( "")), option.config);
+  }
 }
-function formatGroupedPreview(map, limit = 3) {
-  const files = Object.keys(map);
-  if (!files.length) {
-    return { preview: "", moreFiles: 0 };
+function runWithCommandHandler(cli, command, commandName, args, handler, defaultHandler) {
+  const cwd = resolveCwd(args.cwd);
+  const context = createCommandContext(cli, command, commandName, args, cwd);
+  const runDefault = createDefaultRunner(() => defaultHandler(context));
+  if (!handler) {
+    return runDefault();
+  }
+  return handler(context, runDefault);
+}
+function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
+  const names = resolveCommandNames(command, mountOptions, prefix);
+  const definition = defaults[command];
+  const override = _optionalChain([mountOptions, 'access', _85 => _85.commandOptions, 'optionalAccess', _86 => _86[command]]);
+  const description = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _87 => _87.description]), () => ( definition.description));
+  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
+  return { ...names, description, optionDefs };
+}
+async function installCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  await patcher.patch();
+  logger_default.success("Tailwind CSS runtime patched successfully.");
+}
+async function extractCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const overrides = {};
+  let hasOverrides = false;
+  if (args.output || args.format) {
+    overrides.output = {
+      file: args.output,
+      format: args.format
+    };
+    hasOverrides = true;
   }
-  const lines = files.slice(0, limit).map((file) => {
-    const tokens = map[file];
-    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
-    const suffix = tokens.length > 3 ? ", \u2026" : "";
-    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  if (args.css) {
+    overrides.tailwind = {
+      v4: {
+        cssEntries: [args.css]
+      }
+    };
+    hasOverrides = true;
+  }
+  const patcher = await ctx.createPatcher(hasOverrides ? overrides : void 0);
+  const result = await patcher.extract({ write: args.write });
+  if (result.filename) {
+    logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
+  } else {
+    logger_default.success(`Collected ${result.classList.length} classes.`);
+  }
+  return result;
+}
+async function tokensCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.collectContentTokens();
+  const shouldWrite = _nullishCoalesce(args.write, () => ( true));
+  let format = _nullishCoalesce(args.format, () => ( "json"));
+  if (!TOKEN_FORMATS.includes(format)) {
+    format = "json";
+  }
+  const targetFile = _nullishCoalesce(args.output, () => ( DEFAULT_TOKEN_REPORT));
+  const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
+  const buildGrouped = () => groupTokensByFile(report, {
+    key: groupKey,
+    stripAbsolutePaths: groupKey !== "absolute"
   });
-  return {
-    preview: lines.join("\n"),
-    moreFiles: Math.max(0, files.length - limit)
+  const grouped = format === "grouped-json" ? buildGrouped() : null;
+  const resolveGrouped = () => _nullishCoalesce(grouped, () => ( buildGrouped()));
+  if (shouldWrite) {
+    const target = _pathe2.default.resolve(targetFile);
+    await _fsextra2.default.ensureDir(_pathe2.default.dirname(target));
+    if (format === "json") {
+      await _fsextra2.default.writeJSON(target, report, { spaces: 2 });
+    } else if (format === "grouped-json") {
+      await _fsextra2.default.writeJSON(target, resolveGrouped(), { spaces: 2 });
+    } else {
+      const lines = report.entries.map(formatTokenLine);
+      await _fsextra2.default.writeFile(target, `${lines.join("\n")}
+`, "utf8");
+    }
+    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(_process2.default.cwd(), ".")}`);
+  } else {
+    logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
+    if (format === "lines") {
+      const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (report.entries.length > 5) {
+          logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
+        }
+      }
+    } else if (format === "grouped-json") {
+      const map = resolveGrouped();
+      const { preview, moreFiles } = formatGroupedPreview(map);
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (moreFiles > 0) {
+          logger_default.info(`\u2026and ${moreFiles} more files.`);
+        }
+      }
+    } else {
+      const previewEntries = report.entries.slice(0, 3);
+      if (previewEntries.length) {
+        logger_default.log("");
+        logger_default.info(JSON.stringify(previewEntries, null, 2));
+      }
+    }
+  }
+  if (report.skippedFiles.length) {
+    logger_default.warn("Skipped files:");
+    for (const skipped of report.skippedFiles) {
+      logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
+    }
+  }
+  return report;
+}
+async function initCommandDefaultHandler(ctx) {
+  await _config.initConfig.call(void 0, ctx.cwd);
+  logger_default.success(`\u2728 ${_config.CONFIG_NAME}.config.ts initialized!`);
+}
+function mountTailwindcssPatchCommands(cli, options = {}) {
+  const prefix = _nullishCoalesce(options.commandPrefix, () => ( ""));
+  const selectedCommands = _nullishCoalesce(options.commands, () => ( tailwindcssPatchCommands));
+  const defaultDefinitions = buildDefaultCommandDefinitions();
+  const registrars = {
+    install: () => {
+      const metadata = resolveCommandMetadata("install", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "install",
+          args,
+          _optionalChain([options, 'access', _88 => _88.commandHandlers, 'optionalAccess', _89 => _89.install]),
+          installCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    extract: () => {
+      const metadata = resolveCommandMetadata("extract", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "extract",
+          args,
+          _optionalChain([options, 'access', _90 => _90.commandHandlers, 'optionalAccess', _91 => _91.extract]),
+          extractCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    tokens: () => {
+      const metadata = resolveCommandMetadata("tokens", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "tokens",
+          args,
+          _optionalChain([options, 'access', _92 => _92.commandHandlers, 'optionalAccess', _93 => _93.tokens]),
+          tokensCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    init: () => {
+      const metadata = resolveCommandMetadata("init", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "init",
+          args,
+          _optionalChain([options, 'access', _94 => _94.commandHandlers, 'optionalAccess', _95 => _95.init]),
+          initCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    }
   };
+  for (const name of selectedCommands) {
+    const register = registrars[name];
+    if (register) {
+      register();
+    }
+  }
+  return cli;
+}
+function createTailwindcssPatchCli(options = {}) {
+  const cli = _cac2.default.call(void 0, _nullishCoalesce(options.name, () => ( "tw-patch")));
+  mountTailwindcssPatchCommands(cli, options.mountOptions);
+  return cli;
 }
 
 
@@ -1860,4 +2045,4 @@ function formatGroupedPreview(map, limit = 3) {
 
 
 
-exports.logger_default = logger_default; exports.CacheStore = CacheStore; exports.extractRawCandidatesWithPositions = extractRawCandidatesWithPositions; exports.extractRawCandidates = extractRawCandidates; exports.extractValidCandidates = extractValidCandidates; exports.extractProjectCandidatesWithPositions = extractProjectCandidatesWithPositions; exports.groupTokensByFile = groupTokensByFile; exports.normalizeOptions = normalizeOptions; exports.collectClassesFromContexts = collectClassesFromContexts; exports.collectClassesFromTailwindV4 = collectClassesFromTailwindV4; exports.loadRuntimeContexts = loadRuntimeContexts; exports.runTailwindBuild = runTailwindBuild; exports.TailwindcssPatcher = TailwindcssPatcher; exports.tailwindcssPatchCommands = tailwindcssPatchCommands; exports.createTailwindcssPatchCli = createTailwindcssPatchCli; exports.mountTailwindcssPatchCommands = mountTailwindcssPatchCommands;
+exports.logger_default = logger_default; exports.CacheStore = CacheStore; exports.extractRawCandidatesWithPositions = extractRawCandidatesWithPositions; exports.extractRawCandidates = extractRawCandidates; exports.extractValidCandidates = extractValidCandidates; exports.extractProjectCandidatesWithPositions = extractProjectCandidatesWithPositions; exports.groupTokensByFile = groupTokensByFile; exports.normalizeOptions = normalizeOptions; exports.collectClassesFromContexts = collectClassesFromContexts; exports.collectClassesFromTailwindV4 = collectClassesFromTailwindV4; exports.loadRuntimeContexts = loadRuntimeContexts; exports.runTailwindBuild = runTailwindBuild; exports.TailwindcssPatcher = TailwindcssPatcher; exports.tailwindcssPatchCommands = tailwindcssPatchCommands; exports.mountTailwindcssPatchCommands = mountTailwindcssPatchCommands; exports.createTailwindcssPatchCli = createTailwindcssPatchCli;