tailwindcss-patch 8.7.4-alpha.0 → 9.0.0-alpha.2

package/dist/{chunk-ZXW4S356.js → chunk-TOAZIPHJ.js}

@@ -20,7 +20,7 @@ var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
 // package.json
 var package_default = {
   name: "tailwindcss-patch",
-  version: "8.7.4-alpha.0",
+  version: "9.0.0-alpha.2",
   description: "patch tailwindcss for exposing context and extract classes",
   author: "ice breaker <1324318532@qq.com>",
   license: "MIT",
@@ -41,17 +41,17 @@ var package_default = {
   ],
   exports: {
     ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
+      types: "./src/index.ts",
+      import: "./src/index.ts",
+      require: "./src/index.ts"
     },
     "./migration-report.schema.json": "./schema/migration-report.schema.json",
     "./restore-result.schema.json": "./schema/restore-result.schema.json",
     "./validate-result.schema.json": "./schema/validate-result.schema.json"
   },
-  main: "./dist/index.js",
-  module: "./dist/index.mjs",
-  types: "./dist/index.d.ts",
+  main: "./src/index.ts",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
   bin: {
     "tw-patch": "dev/bin.ts",
     "tailwindcss-patch": "dev/bin.ts"
@@ -59,18 +59,23 @@ var package_default = {
   files: [
     "bin",
     "dist",
-    "schema"
+    "schema",
+    "src"
   ],
   scripts: {
     dev: "tsup --watch --sourcemap",
     build: "tsup",
     test: "vitest run",
+    "test:types": "pnpm build && tsd --typings dist/index.d.mts --files test-d/**/*.test-d.ts",
     "test:dev": "vitest",
     "bench:cold-start": "node --import tsx bench/cold-start.ts",
     patch: "tsx dev/bin.ts install",
     r0: "tsx dev/bin.ts extract",
     r1: "tsx dev/bin.ts extract --css index.css"
   },
+  tsd: {
+    directory: "test-d"
+  },
   publishConfig: {
     access: "public",
     registry: "https://registry.npmjs.org/",
@@ -1516,14 +1521,6 @@ ${Date.now()}`, { flag: "wx" });
 
 
 
-var hasWarnedDeprecatedOptions = false;
-var deprecatedOptionMapping = {
-  cwd: "projectRoot",
-  overwrite: "apply.overwrite",
-  tailwind: "tailwindcss",
-  features: "apply",
-  output: "extract"
-};
 function resolveRealpathSafe(value) {
   const resolved = _pathe2.default.resolve(value);
   try {
@@ -1668,66 +1665,32 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
     v4
   };
 }
-function resolveOptionSlices(options) {
-  const projectRoot = _nullishCoalesce(options.projectRoot, () => ( options.cwd));
-  const overwrite = _nullishCoalesce(_optionalChain([options, 'access', _42 => _42.apply, 'optionalAccess', _43 => _43.overwrite]), () => ( options.overwrite));
-  const tailwind = _nullishCoalesce(options.tailwindcss, () => ( options.tailwind));
-  const exposeContext = _optionalChain([options, 'access', _44 => _44.apply, 'optionalAccess', _45 => _45.exposeContext]) !== void 0 ? options.apply.exposeContext : _optionalChain([options, 'access', _46 => _46.features, 'optionalAccess', _47 => _47.exposeContext]);
-  const extendLengthUnits = _optionalChain([options, 'access', _48 => _48.apply, 'optionalAccess', _49 => _49.extendLengthUnits]) !== void 0 ? options.apply.extendLengthUnits : _optionalChain([options, 'access', _50 => _50.features, 'optionalAccess', _51 => _51.extendLengthUnits]);
-  const write = _nullishCoalesce(_optionalChain([options, 'access', _52 => _52.extract, 'optionalAccess', _53 => _53.write]), () => ( _optionalChain([options, 'access', _54 => _54.output, 'optionalAccess', _55 => _55.enabled])));
-  const file = _nullishCoalesce(_optionalChain([options, 'access', _56 => _56.extract, 'optionalAccess', _57 => _57.file]), () => ( _optionalChain([options, 'access', _58 => _58.output, 'optionalAccess', _59 => _59.file])));
-  const format = _nullishCoalesce(_optionalChain([options, 'access', _60 => _60.extract, 'optionalAccess', _61 => _61.format]), () => ( _optionalChain([options, 'access', _62 => _62.output, 'optionalAccess', _63 => _63.format])));
-  const pretty = _nullishCoalesce(_optionalChain([options, 'access', _64 => _64.extract, 'optionalAccess', _65 => _65.pretty]), () => ( _optionalChain([options, 'access', _66 => _66.output, 'optionalAccess', _67 => _67.pretty])));
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([options, 'access', _68 => _68.extract, 'optionalAccess', _69 => _69.removeUniversalSelector]), () => ( _optionalChain([options, 'access', _70 => _70.output, 'optionalAccess', _71 => _71.removeUniversalSelector])));
-  const extract = {
-    ...write === void 0 ? {} : { write },
-    ...file === void 0 ? {} : { file },
-    ...format === void 0 ? {} : { format },
-    ...pretty === void 0 ? {} : { pretty },
-    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector }
-  };
-  return {
-    ...projectRoot === void 0 ? {} : { projectRoot },
-    ...overwrite === void 0 ? {} : { overwrite },
-    ...tailwind === void 0 ? {} : { tailwind },
-    ...Object.keys(extract).length === 0 ? {} : { extract },
-    ...exposeContext === void 0 ? {} : { exposeContext },
-    ...extendLengthUnits === void 0 ? {} : { extendLengthUnits }
-  };
-}
-function findUsedDeprecatedOptions(options) {
-  const result = [];
-  for (const key of Object.keys(deprecatedOptionMapping)) {
-    if (options[key] !== void 0) {
-      result.push(key);
-    }
-  }
-  return result;
-}
-function warnDeprecatedOptionsIfNeeded(options) {
-  if (hasWarnedDeprecatedOptions) {
-    return;
-  }
-  const used = findUsedDeprecatedOptions(options);
+var deprecatedOptionMapping = {
+  cwd: "projectRoot",
+  overwrite: "apply.overwrite",
+  tailwind: "tailwindcss",
+  features: "apply",
+  output: "extract"
+};
+function assertNoDeprecatedOptions(options) {
+  const used = Object.keys(deprecatedOptionMapping).filter((key) => Object.prototype.hasOwnProperty.call(options, key));
   if (used.length === 0) {
     return;
   }
-  hasWarnedDeprecatedOptions = true;
   const mapping = used.map((key) => `${key} -> ${deprecatedOptionMapping[key]}`).join(", ");
-  logger_default.warn(
-    `[deprecated] TailwindcssPatcher options (${used.join(", ")}) are deprecated and will be removed in the next major version. Please migrate to: ${mapping}.`
+  throw new Error(
+    `Legacy TailwindcssPatcher options are no longer supported: ${used.join(", ")}. Use the modern fields instead: ${mapping}.`
   );
 }
 function normalizeOptions(options = {}) {
-  warnDeprecatedOptionsIfNeeded(options);
-  const resolved = resolveOptionSlices(options);
-  const projectRoot = resolveRealpathSafe(resolved.projectRoot ? _pathe2.default.resolve(resolved.projectRoot) : _process2.default.cwd());
-  const overwrite = _nullishCoalesce(resolved.overwrite, () => ( true));
-  const output = normalizeOutputOptions(resolved.extract);
+  assertNoDeprecatedOptions(options);
+  const projectRoot = resolveRealpathSafe(options.projectRoot ? _pathe2.default.resolve(options.projectRoot) : _process2.default.cwd());
+  const overwrite = _nullishCoalesce(_optionalChain([options, 'access', _42 => _42.apply, 'optionalAccess', _43 => _43.overwrite]), () => ( true));
+  const output = normalizeOutputOptions(options.extract);
   const cache = normalizeCacheOptions(options.cache, projectRoot);
-  const tailwind = normalizeTailwindOptions(resolved.tailwind, projectRoot);
-  const exposeContext = normalizeExposeContextOptions(resolved.exposeContext);
-  const extendLengthUnits = normalizeExtendLengthUnitsOptions(resolved.extendLengthUnits);
+  const tailwind = normalizeTailwindOptions(options.tailwindcss, projectRoot);
+  const exposeContext = normalizeExposeContextOptions(_optionalChain([options, 'access', _44 => _44.apply, 'optionalAccess', _45 => _45.exposeContext]));
+  const extendLengthUnits = normalizeExtendLengthUnitsOptions(_optionalChain([options, 'access', _46 => _46.apply, 'optionalAccess', _47 => _47.extendLengthUnits]));
   const filter = (className) => {
     if (output.removeUniversalSelector && className === "*") {
       return false;
@@ -1752,122 +1715,70 @@ function normalizeOptions(options = {}) {
 }
 
 // src/options/legacy.ts
-function normalizeLegacyFeatures(patch) {
-  const apply = _optionalChain([patch, 'optionalAccess', _72 => _72.applyPatches]);
-  const extend = _optionalChain([apply, 'optionalAccess', _73 => _73.extendLengthUnits]);
-  let extendOption = false;
-  if (extend && typeof extend === "object") {
-    extendOption = {
-      ...extend,
-      enabled: true
-    };
-  } else if (extend === true) {
-    extendOption = {
-      enabled: true,
-      units: ["rpx"],
-      ..._optionalChain([patch, 'optionalAccess', _74 => _74.overwrite]) === void 0 ? {} : { overwrite: patch.overwrite }
-    };
+var deprecatedRegistryMapping = {
+  output: "extract",
+  tailwind: "tailwindcss"
+};
+var deprecatedTailwindMapping = {
+  package: "packageName",
+  legacy: "v2",
+  classic: "v3",
+  next: "v4"
+};
+function assertNoDeprecatedRegistryOptions(registry) {
+  const usedRegistryKeys = Object.keys(deprecatedRegistryMapping).filter((key) => Object.prototype.hasOwnProperty.call(registry, key));
+  if (usedRegistryKeys.length > 0) {
+    const mapping = usedRegistryKeys.map((key) => `${key} -> ${deprecatedRegistryMapping[key]}`).join(", ");
+    throw new Error(
+      `Legacy registry fields are no longer supported: ${usedRegistryKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
+    );
   }
-  return {
-    exposeContext: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _75 => _75.exportContext]), () => ( true)),
-    extendLengthUnits: extendOption
-  };
-}
-function fromLegacyOptions(options) {
-  if (!options) {
-    return {};
+  const tailwind = registry.tailwindcss;
+  if (!tailwind) {
+    return;
+  }
+  const usedTailwindKeys = Object.keys(deprecatedTailwindMapping).filter((key) => Object.prototype.hasOwnProperty.call(tailwind, key));
+  if (usedTailwindKeys.length > 0) {
+    const mapping = usedTailwindKeys.map((key) => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(", ");
+    throw new Error(
+      `Legacy "registry.tailwindcss" fields are no longer supported: ${usedTailwindKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
+    );
   }
-  const patch = options.patch;
-  const features = normalizeLegacyFeatures(patch);
-  const output = _optionalChain([patch, 'optionalAccess', _76 => _76.output]);
-  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _77 => _77.tailwindcss]);
-  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _78 => _78.version]);
-  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _79 => _79.v2]);
-  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _80 => _80.v3]);
-  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _81 => _81.v4]);
-  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _82 => _82.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _83 => _83.config])));
-  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _84 => _84.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _85 => _85.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _86 => _86.cwd])));
-  const normalizedExtract = output ? {
-    ...output.filename === void 0 ? {} : { file: output.filename },
-    pretty: output.loose ? 2 : false,
-    ...output.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: output.removeUniversalSelector }
-  } : void 0;
-  const normalizedTailwindcss = {
-    ..._optionalChain([patch, 'optionalAccess', _87 => _87.packageName]) === void 0 ? {} : { packageName: patch.packageName },
-    ...tailwindVersion === void 0 ? {} : { version: tailwindVersion },
-    ..._optionalChain([patch, 'optionalAccess', _88 => _88.resolve]) === void 0 ? {} : { resolve: patch.resolve },
-    ...tailwindConfigPath === void 0 ? {} : { config: tailwindConfigPath },
-    ...tailwindCwd === void 0 ? {} : { cwd: tailwindCwd },
-    ...tailwindV2 === void 0 ? {} : { v2: tailwindV2 },
-    ...tailwindV3 === void 0 ? {} : { v3: tailwindV3 },
-    ...tailwindV4 === void 0 ? {} : { v4: tailwindV4 }
-  };
-  const normalizedCache = typeof options.cache === "boolean" ? options.cache : options.cache ? {
-    ...options.cache,
-    enabled: _nullishCoalesce(options.cache.enabled, () => ( true))
-  } : void 0;
-  const normalizedApply = {
-    ..._optionalChain([patch, 'optionalAccess', _89 => _89.overwrite]) === void 0 ? {} : { overwrite: patch.overwrite },
-    exposeContext: features.exposeContext,
-    extendLengthUnits: features.extendLengthUnits
-  };
-  return {
-    ..._optionalChain([patch, 'optionalAccess', _90 => _90.cwd]) === void 0 ? {} : { projectRoot: patch.cwd },
-    ..._optionalChain([patch, 'optionalAccess', _91 => _91.filter]) === void 0 ? {} : { filter: patch.filter },
-    ...normalizedCache === void 0 ? {} : { cache: normalizedCache },
-    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
-    ...Object.keys(normalizedTailwindcss).length === 0 ? {} : { tailwindcss: normalizedTailwindcss },
-    apply: normalizedApply
-  };
 }
 function fromUnifiedConfig(registry) {
   if (!registry) {
     return {};
   }
-  const tailwind = _nullishCoalesce(registry.tailwindcss, () => ( registry.tailwind));
-  const modernExtract = registry.extract;
-  const legacyOutput = registry.output;
-  const pretty = (() => {
-    const value = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _92 => _92.pretty]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _93 => _93.pretty])));
-    if (value === void 0) {
-      return void 0;
-    }
-    if (typeof value === "boolean") {
-      return value ? 2 : false;
-    }
-    return value;
-  })();
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _94 => _94.removeUniversalSelector]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _95 => _95.stripUniversalSelector])));
-  const outputFile = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _96 => _96.file]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _97 => _97.file])));
-  const normalizedExtract = modernExtract || legacyOutput ? {
-    ..._optionalChain([modernExtract, 'optionalAccess', _98 => _98.write]) === void 0 ? {} : { write: modernExtract.write },
-    ...outputFile === void 0 ? {} : { file: outputFile },
-    ...pretty === void 0 ? {} : { pretty },
-    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector },
-    ..._optionalChain([modernExtract, 'optionalAccess', _99 => _99.format]) === void 0 ? {} : { format: modernExtract.format }
+  assertNoDeprecatedRegistryOptions(registry);
+  const extract = registry.extract ? {
+    ...registry.extract.write === void 0 ? {} : { write: registry.extract.write },
+    ...registry.extract.file === void 0 ? {} : { file: registry.extract.file },
+    ...registry.extract.format === void 0 ? {} : { format: registry.extract.format },
+    ...registry.extract.pretty === void 0 ? {} : { pretty: registry.extract.pretty },
+    ...registry.extract.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: registry.extract.removeUniversalSelector }
   } : void 0;
-  const normalizedTailwindcss = tailwind ? {
-    ...tailwind.version === void 0 ? {} : { version: tailwind.version },
-    ...tailwind.packageName === void 0 ? tailwind.package === void 0 ? {} : { packageName: tailwind.package } : { packageName: tailwind.packageName },
-    ...tailwind.resolve === void 0 ? {} : { resolve: tailwind.resolve },
-    ...tailwind.config === void 0 ? {} : { config: tailwind.config },
-    ...tailwind.cwd === void 0 ? {} : { cwd: tailwind.cwd },
-    ...tailwind.v2 === void 0 ? tailwind.legacy === void 0 ? {} : { v2: tailwind.legacy } : { v2: tailwind.v2 },
-    ...tailwind.v3 === void 0 ? tailwind.classic === void 0 ? {} : { v3: tailwind.classic } : { v3: tailwind.v3 },
-    ...tailwind.v4 === void 0 ? tailwind.next === void 0 ? {} : { v4: tailwind.next } : { v4: tailwind.v4 }
+  const tailwindcss = registry.tailwindcss ? {
+    ...registry.tailwindcss.version === void 0 ? {} : { version: registry.tailwindcss.version },
+    ...registry.tailwindcss.packageName === void 0 ? {} : { packageName: registry.tailwindcss.packageName },
+    ...registry.tailwindcss.resolve === void 0 ? {} : { resolve: registry.tailwindcss.resolve },
+    ...registry.tailwindcss.config === void 0 ? {} : { config: registry.tailwindcss.config },
+    ...registry.tailwindcss.cwd === void 0 ? {} : { cwd: registry.tailwindcss.cwd },
+    ...registry.tailwindcss.v2 === void 0 ? {} : { v2: registry.tailwindcss.v2 },
+    ...registry.tailwindcss.v3 === void 0 ? {} : { v3: registry.tailwindcss.v3 },
+    ...registry.tailwindcss.v4 === void 0 ? {} : { v4: registry.tailwindcss.v4 }
   } : void 0;
-  const normalizedApply = registry.apply ? {
+  const apply = registry.apply ? {
     ...registry.apply.overwrite === void 0 ? {} : { overwrite: registry.apply.overwrite },
     ...registry.apply.exposeContext === void 0 ? {} : { exposeContext: registry.apply.exposeContext },
     ...registry.apply.extendLengthUnits === void 0 ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }
   } : void 0;
   return {
     ...registry.projectRoot === void 0 ? {} : { projectRoot: registry.projectRoot },
-    ...normalizedApply === void 0 ? {} : { apply: normalizedApply },
+    ...apply === void 0 ? {} : { apply },
     ...registry.cache === void 0 ? {} : { cache: registry.cache },
     ...registry.filter === void 0 ? {} : { filter: registry.filter },
-    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
-    ...normalizedTailwindcss === void 0 ? {} : { tailwindcss: normalizedTailwindcss }
+    ...extract === void 0 ? {} : { extract },
+    ...tailwindcss === void 0 ? {} : { tailwindcss }
   };
 }
 
@@ -1879,19 +1790,22 @@ var defuPromise;
 function isNodeError(error) {
   return !!error && typeof error === "object" && ("code" in error || "message" in error);
 }
-function isMissingConfigModuleError(error) {
-  if (!isNodeError(error) || error.code !== "MODULE_NOT_FOUND") {
+function isMissingModuleError(error, pkgName2) {
+  if (!isNodeError(error)) {
     return false;
   }
-  const message = _nullishCoalesce(error.message, () => ( ""));
-  return message.includes("@tailwindcss-mangle/config");
-}
-function isMissingSharedModuleError(error) {
-  if (!isNodeError(error) || error.code !== "MODULE_NOT_FOUND") {
+  const code = error.code;
+  if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
     return false;
   }
   const message = _nullishCoalesce(error.message, () => ( ""));
-  return message.includes("@tailwindcss-mangle/shared");
+  return message.includes(pkgName2) || message.includes(`${pkgName2}/dist/`);
+}
+function isMissingConfigModuleError(error) {
+  return isMissingModuleError(error, "@tailwindcss-mangle/config");
+}
+function isMissingSharedModuleError(error) {
+  return isMissingModuleError(error, "@tailwindcss-mangle/shared");
 }
 async function loadWorkspaceConfigModule() {
   if (!configModulePromise) {
@@ -1922,8 +1836,10 @@ async function loadPatchOptionsForWorkspace(cwd, overrides) {
   const merge = await loadWorkspaceDefu();
   const configModule = await loadWorkspaceConfigModule();
   const { config } = await configModule.getConfig(cwd);
-  const legacyConfig = config;
-  const base = _optionalChain([config, 'optionalAccess', _100 => _100.registry]) ? fromUnifiedConfig(config.registry) : _optionalChain([legacyConfig, 'optionalAccess', _101 => _101.patch]) ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
+  if (config && typeof config === "object" && "patch" in config && config.patch !== void 0) {
+    throw new Error('Legacy workspace config field "patch" is no longer supported. Move patcher options under "registry".');
+  }
+  const base = _optionalChain([config, 'optionalAccess', _48 => _48.registry]) ? fromUnifiedConfig(config.registry) : {};
   const merged = merge(_nullishCoalesce(overrides, () => ( {})), base);
   return merged;
 }
@@ -2064,7 +1980,7 @@ async function extractValidCandidates(options) {
   return validCandidates;
 }
 function normalizeSources(sources, cwd) {
-  const baseSources = _optionalChain([sources, 'optionalAccess', _102 => _102.length]) ? sources : [
+  const baseSources = _optionalChain([sources, 'optionalAccess', _49 => _49.length]) ? sources : [
     {
       base: cwd,
       pattern: "**/*",
@@ -2129,8 +2045,8 @@ function toRelativeFile(cwd, filename) {
   return relative === "" ? _pathe2.default.basename(filename) : relative;
 }
 async function extractProjectCandidatesWithPositions(options) {
-  const cwd = _optionalChain([options, 'optionalAccess', _103 => _103.cwd]) ? _pathe2.default.resolve(options.cwd) : _process2.default.cwd();
-  const normalizedSources = normalizeSources(_optionalChain([options, 'optionalAccess', _104 => _104.sources]), cwd);
+  const cwd = _optionalChain([options, 'optionalAccess', _50 => _50.cwd]) ? _pathe2.default.resolve(options.cwd) : _process2.default.cwd();
+  const normalizedSources = normalizeSources(_optionalChain([options, 'optionalAccess', _51 => _51.sources]), cwd);
   const { Scanner } = await getOxideModule();
   const scanner = new Scanner({
     sources: normalizedSources
@@ -2184,18 +2100,16 @@ async function extractProjectCandidatesWithPositions(options) {
   };
 }
 function groupTokensByFile(report, options) {
-  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _105 => _105.key]), () => ( "relative"));
-  const stripAbsolute = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _106 => _106.stripAbsolutePaths]), () => ( key !== "absolute"));
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.key]), () => ( "relative"));
+  const stripAbsolute = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.stripAbsolutePaths]), () => ( key !== "absolute"));
   return report.entries.reduce((acc, entry) => {
     const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
-    if (!acc[bucketKey]) {
-      acc[bucketKey] = [];
-    }
+    const bucket = _nullishCoalesce(acc[bucketKey], () => ( (acc[bucketKey] = [])));
     const value = stripAbsolute ? {
       ...entry,
       file: entry.relativeFile
     } : entry;
-    acc[bucketKey].push(value);
+    bucket.push(value);
     return acc;
   }, {});
 }
@@ -2210,18 +2124,22 @@ function isObject(val) {
   return val !== null && typeof val === "object" && Array.isArray(val) === false;
 }
 function spliceChangesIntoString(str, changes) {
-  if (!changes[0]) {
+  const firstChange = changes[0];
+  if (!firstChange) {
     return str;
   }
   changes.sort((a, b) => {
     return a.end - b.end || a.start - b.start;
   });
   let result = "";
-  let previous = changes[0];
+  let previous = firstChange;
   result += str.slice(0, previous.start);
   result += previous.replacement;
   for (let i = 1; i < changes.length; ++i) {
     const change = changes[i];
+    if (!change) {
+      continue;
+    }
     result += str.slice(previous.end, change.start);
     result += change.replacement;
     previous = change;
@@ -2261,7 +2179,7 @@ async function collectClassesFromTailwindV4(options) {
   const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
   const resolvedDefaultBase = _nullishCoalesce(toAbsolute(v4Options.base), () => ( _process2.default.cwd()));
   const resolveSources = (base) => {
-    if (!_optionalChain([v4Options, 'access', _107 => _107.sources, 'optionalAccess', _108 => _108.length])) {
+    if (!_optionalChain([v4Options, 'access', _54 => _54.sources, 'optionalAccess', _55 => _55.length])) {
       return void 0;
     }
     return v4Options.sources.map((source) => ({
@@ -2396,18 +2314,18 @@ function clearTailwindV3RuntimeState(pluginName) {
     if (!_fsextra2.default.pathExistsSync(sharedStatePath)) {
       return;
     }
-    const sharedState = _optionalChain([require3, 'access', _109 => _109.cache, 'access', _110 => _110[sharedStatePath], 'optionalAccess', _111 => _111.exports]);
-    _optionalChain([sharedState, 'optionalAccess', _112 => _112.contextMap, 'optionalAccess', _113 => _113.clear, 'call', _114 => _114()]);
-    _optionalChain([sharedState, 'optionalAccess', _115 => _115.configContextMap, 'optionalAccess', _116 => _116.clear, 'call', _117 => _117()]);
-    _optionalChain([sharedState, 'optionalAccess', _118 => _118.contextSourcesMap, 'optionalAccess', _119 => _119.clear, 'call', _120 => _120()]);
-    _optionalChain([sharedState, 'optionalAccess', _121 => _121.sourceHashMap, 'optionalAccess', _122 => _122.clear, 'call', _123 => _123()]);
+    const sharedState = _optionalChain([require3, 'access', _56 => _56.cache, 'access', _57 => _57[sharedStatePath], 'optionalAccess', _58 => _58.exports]);
+    _optionalChain([sharedState, 'optionalAccess', _59 => _59.contextMap, 'optionalAccess', _60 => _60.clear, 'call', _61 => _61()]);
+    _optionalChain([sharedState, 'optionalAccess', _62 => _62.configContextMap, 'optionalAccess', _63 => _63.clear, 'call', _64 => _64()]);
+    _optionalChain([sharedState, 'optionalAccess', _65 => _65.contextSourcesMap, 'optionalAccess', _66 => _66.clear, 'call', _67 => _67()]);
+    _optionalChain([sharedState, 'optionalAccess', _68 => _68.sourceHashMap, 'optionalAccess', _69 => _69.clear, 'call', _70 => _70()]);
     for (const candidate of ["lib/plugin.js", "lib/index.js"]) {
       const runtimeEntry = _pathe2.default.join(root, candidate);
       if (!_fsextra2.default.pathExistsSync(runtimeEntry)) {
         continue;
       }
-      const runtimeModule = _optionalChain([require3, 'access', _124 => _124.cache, 'access', _125 => _125[runtimeEntry], 'optionalAccess', _126 => _126.exports]);
-      _optionalChain([runtimeModule, 'optionalAccess', _127 => _127.contextRef, 'optionalAccess', _128 => _128.value, 'optionalAccess', _129 => _129.splice, 'call', _130 => _130(0, runtimeModule.contextRef.value.length)]);
+      const runtimeModule = _optionalChain([require3, 'access', _71 => _71.cache, 'access', _72 => _72[runtimeEntry], 'optionalAccess', _73 => _73.exports]);
+      _optionalChain([runtimeModule, 'optionalAccess', _74 => _74.contextRef, 'optionalAccess', _75 => _75.value, 'optionalAccess', _76 => _76.splice, 'call', _77 => _77(0, runtimeModule.contextRef.value.length)]);
       break;
     }
   } catch (e10) {
@@ -2489,7 +2407,7 @@ function transformProcessTailwindFeaturesReturnContextV2(content) {
   traverse(ast, {
     FunctionDeclaration(path18) {
       const node = path18.node;
-      if (_optionalChain([node, 'access', _131 => _131.id, 'optionalAccess', _132 => _132.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+      if (_optionalChain([node, 'access', _78 => _78.id, 'optionalAccess', _79 => _79.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
       const returnStatement3 = node.body.body[0];
@@ -2522,7 +2440,7 @@ function transformPostcssPluginV2(content, options) {
     Program(path18) {
       const program = path18.node;
       const index = program.body.findIndex((statement) => {
-        return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _133 => _133.id, 'optionalAccess', _134 => _134.name]) === "_default";
+        return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _80 => _80.id, 'optionalAccess', _81 => _81.name]) === "_default";
       });
       if (index === -1) {
         return;
@@ -2530,7 +2448,12 @@ function transformPostcssPluginV2(content, options) {
       const previous = program.body[index - 1];
       const beforePrevious = program.body[index - 2];
       const alreadyHasVariable = Boolean(
-        previous && t.isVariableDeclaration(previous) && previous.declarations.length === 1 && t.isIdentifier(previous.declarations[0].id) && previous.declarations[0].id.name === refIdentifier.name
+        previous && t.isVariableDeclaration(previous) && previous.declarations.length === 1 && (() => {
+          const declaration = previous.declarations[0];
+          return Boolean(
+            declaration && t.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name
+          );
+        })()
       );
       const alreadyAssignsExports = Boolean(
         beforePrevious && t.isExpressionStatement(beforePrevious) && t.isAssignmentExpression(beforePrevious.expression) && t.isMemberExpression(beforePrevious.expression.left) && t.isIdentifier(beforePrevious.expression.right) && beforePrevious.expression.right.name === refIdentifier.name && generate(beforePrevious.expression.left).code === generate(exportMember).code
@@ -2559,7 +2482,7 @@ function transformPostcssPluginV2(content, options) {
         return;
       }
       const fn = path18.node;
-      if (_optionalChain([fn, 'access', _135 => _135.id, 'optionalAccess', _136 => _136.name]) !== "_default") {
+      if (_optionalChain([fn, 'access', _82 => _82.id, 'optionalAccess', _83 => _83.name]) !== "_default") {
         return;
       }
       if (fn.body.body.length !== 1 || !t.isReturnStatement(fn.body.body[0])) {
@@ -2649,7 +2572,7 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   traverse(ast, {
     FunctionDeclaration(path18) {
       const node = path18.node;
-      if (_optionalChain([node, 'access', _137 => _137.id, 'optionalAccess', _138 => _138.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
+      if (_optionalChain([node, 'access', _84 => _84.id, 'optionalAccess', _85 => _85.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = node.body.body;
@@ -2683,7 +2606,7 @@ function transformPostcssPlugin(content, { refProperty }) {
     Program(path18) {
       const program = path18.node;
       const index = program.body.findIndex((statement) => {
-        return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && _optionalChain([statement, 'access', _139 => _139.expression, 'access', _140 => _140.right, 'access', _141 => _141.id, 'optionalAccess', _142 => _142.name]) === "tailwindcss";
+        return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && _optionalChain([statement, 'access', _86 => _86.expression, 'access', _87 => _87.right, 'access', _88 => _88.id, 'optionalAccess', _89 => _89.name]) === "tailwindcss";
       });
       if (index === -1) {
         return;
@@ -2691,7 +2614,12 @@ function transformPostcssPlugin(content, { refProperty }) {
       const previousStatement = program.body[index - 1];
       const lastStatement = program.body[program.body.length - 1];
       const alreadyHasVariable = Boolean(
-        previousStatement && t2.isVariableDeclaration(previousStatement) && previousStatement.declarations.length === 1 && t2.isIdentifier(previousStatement.declarations[0].id) && previousStatement.declarations[0].id.name === refIdentifier.name
+        previousStatement && t2.isVariableDeclaration(previousStatement) && previousStatement.declarations.length === 1 && (() => {
+          const declaration = previousStatement.declarations[0];
+          return Boolean(
+            declaration && t2.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name
+          );
+        })()
       );
       const alreadyAssignsModuleExports = Boolean(
         t2.isExpressionStatement(lastStatement) && t2.isAssignmentExpression(lastStatement.expression) && t2.isMemberExpression(lastStatement.expression.left) && t2.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === refIdentifier.name && generate(lastStatement.expression.left).code === generate(moduleExportsMember).code
@@ -2724,7 +2652,7 @@ function transformPostcssPlugin(content, { refProperty }) {
         return;
       }
       const fn = path18.node;
-      if (_optionalChain([fn, 'access', _143 => _143.id, 'optionalAccess', _144 => _144.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
+      if (_optionalChain([fn, 'access', _90 => _90.id, 'optionalAccess', _91 => _91.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = fn.body.body;
@@ -3121,7 +3049,7 @@ function checkExtendLengthUnitsPatch(context) {
 function getPatchStatusReport(context) {
   return {
     package: {
-      name: _nullishCoalesce(context.packageInfo.name, () => ( _optionalChain([context, 'access', _145 => _145.packageInfo, 'access', _146 => _146.packageJson, 'optionalAccess', _147 => _147.name]))),
+      name: _nullishCoalesce(context.packageInfo.name, () => ( _optionalChain([context, 'access', _92 => _92.packageInfo, 'access', _93 => _93.packageJson, 'optionalAccess', _94 => _94.name]))),
       version: context.packageInfo.version,
       root: context.packageInfo.rootPath
     },
@@ -3241,7 +3169,7 @@ function applyTailwindPatches(context) {
       majorVersion
     });
   }
-  if (_optionalChain([options, 'access', _148 => _148.features, 'access', _149 => _149.extendLengthUnits, 'optionalAccess', _150 => _150.enabled])) {
+  if (_optionalChain([options, 'access', _95 => _95.features, 'access', _96 => _96.extendLengthUnits, 'optionalAccess', _97 => _97.enabled])) {
     if (majorVersion === 3) {
       results.extendLengthUnits = applyExtendLengthUnitsPatchV3(
         packageInfo.rootPath,
@@ -3257,25 +3185,7 @@ function applyTailwindPatches(context) {
   return results;
 }
 
-// src/api/tailwindcss-patcher.ts
-function resolveMajorVersion(version, hint) {
-  if (hint && [2, 3, 4].includes(hint)) {
-    return hint;
-  }
-  if (version) {
-    const coerced = _semver.coerce.call(void 0, version);
-    if (coerced) {
-      const major = coerced.major;
-      if (major === 2 || major === 3 || major === 4) {
-        return major;
-      }
-      if (major >= 4) {
-        return 4;
-      }
-    }
-  }
-  return 3;
-}
+// src/runtime/collector.ts
 function resolveTailwindExecutionOptions(normalized, majorVersion) {
   const base = normalized.tailwind;
   if (majorVersion === 2 && base.v2) {
@@ -3298,6 +3208,128 @@ function resolveTailwindExecutionOptions(normalized, majorVersion) {
     postcssPlugin: base.postcssPlugin
   };
 }
+var BaseCollector = class {
+  constructor(packageInfo, options, majorVersion) {
+    this.packageInfo = packageInfo;
+    this.options = options;
+    this.majorVersion = majorVersion;
+  }
+  async patch() {
+    return applyTailwindPatches({
+      packageInfo: this.packageInfo,
+      options: this.options,
+      majorVersion: this.majorVersion
+    });
+  }
+  async getPatchStatus() {
+    return getPatchStatusReport({
+      packageInfo: this.packageInfo,
+      options: this.options,
+      majorVersion: this.majorVersion
+    });
+  }
+  getContexts() {
+    return loadRuntimeContexts(
+      this.packageInfo,
+      this.majorVersion,
+      this.options.features.exposeContext.refProperty
+    );
+  }
+};
+var RuntimeCollector = class extends BaseCollector {
+  constructor(packageInfo, options, majorVersion, snapshotFactory) {
+    super(packageInfo, options, majorVersion);
+    this.snapshotFactory = snapshotFactory;
+  }
+  
+  async collectClassSet() {
+    const contexts = this.getContexts();
+    return collectClassesFromContexts(contexts, this.options.filter);
+  }
+  getPatchSnapshot() {
+    return this.snapshotFactory();
+  }
+  async runTailwindBuildIfNeeded() {
+    if (this.inFlightBuild) {
+      return this.inFlightBuild;
+    }
+    const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
+    const buildOptions = {
+      cwd: executionOptions.cwd,
+      majorVersion: this.majorVersion,
+      ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
+      ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
+    };
+    this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
+    try {
+      await this.inFlightBuild;
+    } finally {
+      this.inFlightBuild = void 0;
+    }
+  }
+};
+var TailwindV4Collector = class extends BaseCollector {
+  constructor(packageInfo, options, snapshotFactory) {
+    super(packageInfo, options, 4);
+    this.snapshotFactory = snapshotFactory;
+  }
+  
+  async collectClassSet() {
+    return collectClassesFromTailwindV4(this.options);
+  }
+  getPatchSnapshot() {
+    return this.snapshotFactory();
+  }
+};
+
+// src/api/tailwindcss-patcher.ts
+function resolveInstalledMajorVersion(version) {
+  if (!version) {
+    return void 0;
+  }
+  const coerced = _semver.coerce.call(void 0, version);
+  if (!coerced) {
+    return void 0;
+  }
+  const major = coerced.major;
+  if (major === 2 || major === 3 || major === 4) {
+    return major;
+  }
+  if (major >= 4) {
+    return 4;
+  }
+  return void 0;
+}
+function validateInstalledVersion(packageVersion, expectedMajor, packageName) {
+  const installedMajor = resolveInstalledMajorVersion(packageVersion);
+  if (installedMajor === void 0) {
+    return;
+  }
+  if (installedMajor !== expectedMajor) {
+    throw new Error(
+      `Configured tailwindcss.version=${expectedMajor}, but resolved package "${packageName}" is version ${packageVersion}. Update the configuration or resolve the correct package.`
+    );
+  }
+}
+function resolveMajorVersionOrThrow(configuredMajor, packageVersion, packageName) {
+  if (configuredMajor !== void 0) {
+    validateInstalledVersion(packageVersion, configuredMajor, packageName);
+    return configuredMajor;
+  }
+  const installedMajor = resolveInstalledMajorVersion(packageVersion);
+  if (installedMajor !== void 0) {
+    return installedMajor;
+  }
+  throw new Error(
+    `Unable to infer Tailwind CSS major version from resolved package "${packageName}" (${_nullishCoalesce(packageVersion, () => ( "unknown"))}). Set "tailwindcss.version" to 2, 3, or 4 explicitly.`
+  );
+}
+function createCollector(packageInfo, options, majorVersion, snapshotFactory) {
+  if (majorVersion === 4) {
+    return new TailwindV4Collector(packageInfo, options, snapshotFactory);
+  }
+  return new RuntimeCollector(packageInfo, options, majorVersion, snapshotFactory);
+}
 var TailwindcssPatcher = (_class2 = class {
   
   
@@ -3307,8 +3339,7 @@ var TailwindcssPatcher = (_class2 = class {
   
   
   constructor(options = {}) {;_class2.prototype.__init4.call(this);
-    const resolvedOptions = options && typeof options === "object" && "patch" in options ? fromLegacyOptions(options) : options;
-    this.options = normalizeOptions(resolvedOptions);
+    this.options = normalizeOptions(options);
     const packageInfo = _localpkg.getPackageInfoSync.call(void 0, 
       this.options.tailwind.packageName,
       this.options.tailwind.resolve
@@ -3317,9 +3348,10 @@ var TailwindcssPatcher = (_class2 = class {
       throw new Error(`Unable to locate Tailwind CSS package "${this.options.tailwind.packageName}".`);
     }
     this.packageInfo = packageInfo;
-    this.majorVersion = resolveMajorVersion(
+    this.majorVersion = resolveMajorVersionOrThrow(
+      this.options.tailwind.versionHint,
       this.packageInfo.version,
-      this.options.tailwind.versionHint
+      this.options.tailwind.packageName
     );
     this.cacheContext = createCacheContextDescriptor(
       this.options,
@@ -3327,56 +3359,30 @@ var TailwindcssPatcher = (_class2 = class {
       this.majorVersion
     );
     this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
+    this.collector = createCollector(
+      this.packageInfo,
+      this.options,
+      this.majorVersion,
+      () => this.createPatchSnapshot()
+    );
   }
   async patch() {
-    const snapshot = this.createPatchSnapshot();
+    const snapshot = this.collector.getPatchSnapshot();
     if (this.patchMemo && this.patchMemo.snapshot === snapshot) {
       return this.patchMemo.result;
     }
-    const result = applyTailwindPatches({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
+    const result = await this.collector.patch();
     this.patchMemo = {
       result,
-      snapshot: this.createPatchSnapshot()
+      snapshot: this.collector.getPatchSnapshot()
     };
     return result;
   }
   async getPatchStatus() {
-    return getPatchStatusReport({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
+    return this.collector.getPatchStatus();
   }
   getContexts() {
-    return loadRuntimeContexts(
-      this.packageInfo,
-      this.majorVersion,
-      this.options.features.exposeContext.refProperty
-    );
-  }
-  async runTailwindBuildIfNeeded() {
-    if (this.majorVersion === 2 || this.majorVersion === 3) {
-      if (this.inFlightBuild) {
-        return this.inFlightBuild;
-      }
-      const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
-      const buildOptions = {
-        cwd: executionOptions.cwd,
-        majorVersion: this.majorVersion,
-        ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
-        ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
-      };
-      this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
-      try {
-        await this.inFlightBuild;
-      } finally {
-        this.inFlightBuild = void 0;
-      }
-    }
+    return this.collector.getContexts();
   }
   createPatchSnapshot() {
     const entries = [];
@@ -3400,7 +3406,7 @@ var TailwindcssPatcher = (_class2 = class {
         }
       }
     }
-    if (_optionalChain([this, 'access', _151 => _151.options, 'access', _152 => _152.features, 'access', _153 => _153.extendLengthUnits, 'optionalAccess', _154 => _154.enabled])) {
+    if (_optionalChain([this, 'access', _98 => _98.options, 'access', _99 => _99.features, 'access', _100 => _100.extendLengthUnits, 'optionalAccess', _101 => _101.enabled])) {
       if (this.majorVersion === 3) {
         const target = _nullishCoalesce(this.options.features.extendLengthUnits.lengthUnitsFilePath, () => ( "lib/util/dataTypes.js"));
         pushSnapshot(_pathe2.default.resolve(this.packageInfo.rootPath, target));
@@ -3420,20 +3426,23 @@ var TailwindcssPatcher = (_class2 = class {
   }
   async collectClassSet() {
     if (this.majorVersion === 4) {
-      return collectClassesFromTailwindV4(this.options);
+      return this.collector.collectClassSet();
     }
     const contexts = this.getContexts();
     return collectClassesFromContexts(contexts, this.options.filter);
   }
+  async runTailwindBuildIfNeeded() {
+    await _optionalChain([this, 'access', _102 => _102.collector, 'access', _103 => _103.runTailwindBuildIfNeeded, 'optionalCall', _104 => _104()]);
+  }
   debugCacheRead(meta) {
     if (meta.hit) {
       logger_default.debug(
-        `[cache] hit fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _155 => _155.fingerprint, 'optionalAccess', _156 => _156.slice, 'call', _157 => _157(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
+        `[cache] hit fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _105 => _105.fingerprint, 'optionalAccess', _106 => _106.slice, 'call', _107 => _107(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
       );
       return;
     }
     logger_default.debug(
-      `[cache] miss reason=${meta.reason} fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _158 => _158.fingerprint, 'optionalAccess', _159 => _159.slice, 'call', _160 => _160(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
+      `[cache] miss reason=${meta.reason} fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _108 => _108.fingerprint, 'optionalAccess', _109 => _109.slice, 'call', _110 => _110(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
     );
   }
   async mergeWithCache(set) {
@@ -3517,7 +3526,7 @@ var TailwindcssPatcher = (_class2 = class {
     return merged;
   }
   async extract(options) {
-    const shouldWrite = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _161 => _161.write]), () => ( this.options.output.enabled));
+    const shouldWrite = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _111 => _111.write]), () => ( this.options.output.enabled));
     const classSet = await this.getClassSet();
     const classList = Array.from(classSet);
     const result = {
@@ -3553,19 +3562,19 @@ var TailwindcssPatcher = (_class2 = class {
   __init4() {this.extractValidCandidates = exports.extractValidCandidates = extractValidCandidates}
   async collectContentTokens(options) {
     return extractProjectCandidatesWithPositions({
-      cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _162 => _162.cwd]), () => ( this.options.projectRoot)),
-      sources: _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _163 => _163.sources]), () => ( _optionalChain([this, 'access', _164 => _164.options, 'access', _165 => _165.tailwind, 'access', _166 => _166.v4, 'optionalAccess', _167 => _167.sources]))), () => ( []))
+      cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _112 => _112.cwd]), () => ( this.options.projectRoot)),
+      sources: _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _113 => _113.sources]), () => ( _optionalChain([this, 'access', _114 => _114.options, 'access', _115 => _115.tailwind, 'access', _116 => _116.v4, 'optionalAccess', _117 => _117.sources]))), () => ( []))
     });
   }
   async collectContentTokensByFile(options) {
     const collectContentOptions = {
-      ..._optionalChain([options, 'optionalAccess', _168 => _168.cwd]) === void 0 ? {} : { cwd: options.cwd },
-      ..._optionalChain([options, 'optionalAccess', _169 => _169.sources]) === void 0 ? {} : { sources: options.sources }
+      ..._optionalChain([options, 'optionalAccess', _118 => _118.cwd]) === void 0 ? {} : { cwd: options.cwd },
+      ..._optionalChain([options, 'optionalAccess', _119 => _119.sources]) === void 0 ? {} : { sources: options.sources }
     };
     const report = await this.collectContentTokens(collectContentOptions);
     const groupOptions = {
-      ..._optionalChain([options, 'optionalAccess', _170 => _170.key]) === void 0 ? {} : { key: options.key },
-      ..._optionalChain([options, 'optionalAccess', _171 => _171.stripAbsolutePaths]) === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
+      ..._optionalChain([options, 'optionalAccess', _120 => _120.key]) === void 0 ? {} : { key: options.key },
+      ..._optionalChain([options, 'optionalAccess', _121 => _121.stripAbsolutePaths]) === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
     };
     return groupTokensByFile(report, groupOptions);
   }
@@ -4458,10 +4467,10 @@ function addPrefixIfMissing(value, prefix) {
   return `${prefix}${value}`;
 }
 function resolveCommandNames(command, mountOptions, prefix) {
-  const override = _optionalChain([mountOptions, 'access', _172 => _172.commandOptions, 'optionalAccess', _173 => _173[command]]);
-  const baseName = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _174 => _174.name]), () => ( command));
+  const override = _optionalChain([mountOptions, 'access', _122 => _122.commandOptions, 'optionalAccess', _123 => _123[command]]);
+  const baseName = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _124 => _124.name]), () => ( command));
   const name = addPrefixIfMissing(baseName, prefix);
-  const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _175 => _175.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
+  const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _125 => _125.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
   return { name, aliases };
 }
 function resolveOptionDefinitions(defaults, override) {
@@ -4481,8 +4490,8 @@ function resolveOptionDefinitions(defaults, override) {
 function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
   const names = resolveCommandNames(command, mountOptions, prefix);
   const definition = defaults[command];
-  const override = _optionalChain([mountOptions, 'access', _176 => _176.commandOptions, 'optionalAccess', _177 => _177[command]]);
-  const description = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _178 => _178.description]), () => ( definition.description));
+  const override = _optionalChain([mountOptions, 'access', _126 => _126.commandOptions, 'optionalAccess', _127 => _127[command]]);
+  const description = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _128 => _128.description]), () => ( definition.description));
   const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
   return { ...names, description, optionDefs };
 }
@@ -4564,7 +4573,7 @@ function runWithCommandHandler(cli, command, commandName, args, handler, default
 
 var DEFAULT_CONFIG_NAME = "tailwindcss-mangle";
 async function installCommandDefaultHandler(_ctx) {
-  const patcher = new TailwindcssPatcher();
+  const patcher = await _ctx.createPatcher();
   await patcher.patch();
   logger_default.success("Tailwind CSS runtime patched successfully.");
 }
@@ -4996,13 +5005,14 @@ function registerTailwindcssPatchCommand(cli, commandName, options, prefix, defa
   const command = cli.command(metadata.name, metadata.description);
   applyCommandOptions(command, metadata.optionDefs);
   command.action(async (args) => {
+    const defaultHandler = defaultCommandHandlers[commandName];
     return runWithCommandHandler(
       cli,
       command,
       commandName,
       args,
-      _optionalChain([options, 'access', _179 => _179.commandHandlers, 'optionalAccess', _180 => _180[commandName]]),
-      defaultCommandHandlers[commandName]
+      _optionalChain([options, 'access', _129 => _129.commandHandlers, 'optionalAccess', _130 => _130[commandName]]),
+      defaultHandler
     );
   });
   metadata.aliases.forEach((alias) => command.alias(alias));