tailwindcss-patch 8.2.4 → 8.4.0

package/dist/{chunk-OQKHXYAK.js → chunk-PF5ZTTYM.js}

@@ -289,105 +289,6 @@ function groupTokensByFile(report, options) {
   }, {});
 }
 
-// src/options/legacy.ts
-function normalizeLegacyFeatures(patch) {
-  const apply = _optionalChain([patch, 'optionalAccess', _6 => _6.applyPatches]);
-  const extend = _optionalChain([apply, 'optionalAccess', _7 => _7.extendLengthUnits]);
-  let extendOption = false;
-  if (extend && typeof extend === "object") {
-    extendOption = {
-      ...extend,
-      enabled: true
-    };
-  } else if (extend === true) {
-    extendOption = {
-      enabled: true,
-      units: ["rpx"],
-      overwrite: _optionalChain([patch, 'optionalAccess', _8 => _8.overwrite])
-    };
-  }
-  return {
-    exposeContext: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _9 => _9.exportContext]), () => ( true)),
-    extendLengthUnits: extendOption
-  };
-}
-function fromLegacyOptions(options) {
-  if (!options) {
-    return {};
-  }
-  const patch = options.patch;
-  const features = normalizeLegacyFeatures(patch);
-  const output = _optionalChain([patch, 'optionalAccess', _10 => _10.output]);
-  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _11 => _11.tailwindcss]);
-  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _12 => _12.version]);
-  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _13 => _13.v2]);
-  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _14 => _14.v3]);
-  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _15 => _15.v4]);
-  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _16 => _16.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _17 => _17.config])));
-  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _18 => _18.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _19 => _19.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _20 => _20.cwd])));
-  return {
-    cwd: _optionalChain([patch, 'optionalAccess', _21 => _21.cwd]),
-    overwrite: _optionalChain([patch, 'optionalAccess', _22 => _22.overwrite]),
-    filter: _optionalChain([patch, 'optionalAccess', _23 => _23.filter]),
-    cache: typeof options.cache === "boolean" ? options.cache : options.cache ? {
-      ...options.cache,
-      enabled: _nullishCoalesce(options.cache.enabled, () => ( true))
-    } : void 0,
-    output: output ? {
-      file: output.filename,
-      pretty: output.loose ? 2 : false,
-      removeUniversalSelector: output.removeUniversalSelector
-    } : void 0,
-    tailwind: {
-      packageName: _optionalChain([patch, 'optionalAccess', _24 => _24.packageName]),
-      version: tailwindVersion,
-      resolve: _optionalChain([patch, 'optionalAccess', _25 => _25.resolve]),
-      config: tailwindConfigPath,
-      cwd: tailwindCwd,
-      v2: tailwindV2,
-      v3: tailwindV3,
-      v4: tailwindV4
-    },
-    features: {
-      exposeContext: features.exposeContext,
-      extendLengthUnits: features.extendLengthUnits
-    }
-  };
-}
-function fromUnifiedConfig(registry) {
-  if (!registry) {
-    return {};
-  }
-  const tailwind = registry.tailwind;
-  const output = registry.output;
-  const pretty = (() => {
-    if (_optionalChain([output, 'optionalAccess', _26 => _26.pretty]) === void 0) {
-      return void 0;
-    }
-    if (typeof output.pretty === "boolean") {
-      return output.pretty ? 2 : false;
-    }
-    return output.pretty;
-  })();
-  return {
-    output: output ? {
-      file: output.file,
-      pretty,
-      removeUniversalSelector: output.stripUniversalSelector
-    } : void 0,
-    tailwind: tailwind ? {
-      version: tailwind.version,
-      packageName: tailwind.package,
-      resolve: tailwind.resolve,
-      config: tailwind.config,
-      cwd: tailwind.cwd,
-      v2: tailwind.legacy,
-      v3: tailwind.classic,
-      v4: tailwind.next
-    } : void 0
-  };
-}
-
 // src/options/normalize.ts
 
 
@@ -431,11 +332,11 @@ function normalizeCacheOptions(cache, projectRoot) {
   };
 }
 function normalizeOutputOptions(output) {
-  const enabled = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _27 => _27.enabled]), () => ( true));
-  const file = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _28 => _28.file]), () => ( ".tw-patch/tw-class-list.json"));
-  const format = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _29 => _29.format]), () => ( "json"));
-  const pretty = toPrettyValue(_nullishCoalesce(_optionalChain([output, 'optionalAccess', _30 => _30.pretty]), () => ( true)));
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _31 => _31.removeUniversalSelector]), () => ( true));
+  const enabled = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _6 => _6.enabled]), () => ( true));
+  const file = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _7 => _7.file]), () => ( ".tw-patch/tw-class-list.json"));
+  const format = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _8 => _8.format]), () => ( "json"));
+  const pretty = toPrettyValue(_nullishCoalesce(_optionalChain([output, 'optionalAccess', _9 => _9.pretty]), () => ( true)));
+  const removeUniversalSelector = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _10 => _10.removeUniversalSelector]), () => ( true));
   return {
     enabled,
     file,
@@ -445,13 +346,13 @@ function normalizeOutputOptions(output) {
   };
 }
 function normalizeExposeContextOptions(features) {
-  if (_optionalChain([features, 'optionalAccess', _32 => _32.exposeContext]) === false) {
+  if (_optionalChain([features, 'optionalAccess', _11 => _11.exposeContext]) === false) {
     return {
       enabled: false,
       refProperty: "contextRef"
     };
   }
-  if (typeof _optionalChain([features, 'optionalAccess', _33 => _33.exposeContext]) === "object" && features.exposeContext) {
+  if (typeof _optionalChain([features, 'optionalAccess', _12 => _12.exposeContext]) === "object" && features.exposeContext) {
     return {
       enabled: true,
       refProperty: _nullishCoalesce(features.exposeContext.refProperty, () => ( "contextRef"))
@@ -463,7 +364,7 @@ function normalizeExposeContextOptions(features) {
   };
 }
 function normalizeExtendLengthUnitsOptions(features) {
-  const extend = _optionalChain([features, 'optionalAccess', _34 => _34.extendLengthUnits]);
+  const extend = _optionalChain([features, 'optionalAccess', _13 => _13.extendLengthUnits]);
   if (extend === false || extend === void 0) {
     return null;
   }
@@ -483,11 +384,11 @@ function normalizeExtendLengthUnitsOptions(features) {
   };
 }
 function normalizeTailwindV4Options(v4, fallbackBase) {
-  const configuredBase = _optionalChain([v4, 'optionalAccess', _35 => _35.base]) ? _pathe2.default.resolve(v4.base) : void 0;
+  const configuredBase = _optionalChain([v4, 'optionalAccess', _14 => _14.base]) ? _pathe2.default.resolve(v4.base) : void 0;
   const base = _nullishCoalesce(configuredBase, () => ( fallbackBase));
-  const cssEntries = Array.isArray(_optionalChain([v4, 'optionalAccess', _36 => _36.cssEntries])) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => _pathe2.default.resolve(entry)) : [];
-  const userSources = _optionalChain([v4, 'optionalAccess', _37 => _37.sources]);
-  const hasUserDefinedSources = Boolean(_optionalChain([userSources, 'optionalAccess', _38 => _38.length]));
+  const cssEntries = Array.isArray(_optionalChain([v4, 'optionalAccess', _15 => _15.cssEntries])) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => _pathe2.default.resolve(entry)) : [];
+  const userSources = _optionalChain([v4, 'optionalAccess', _16 => _16.sources]);
+  const hasUserDefinedSources = Boolean(_optionalChain([userSources, 'optionalAccess', _17 => _17.length]));
   const sources = hasUserDefinedSources ? userSources : [
     {
       base,
@@ -498,20 +399,20 @@ function normalizeTailwindV4Options(v4, fallbackBase) {
   return {
     base,
     configuredBase,
-    css: _optionalChain([v4, 'optionalAccess', _39 => _39.css]),
+    css: _optionalChain([v4, 'optionalAccess', _18 => _18.css]),
     cssEntries,
     sources,
     hasUserDefinedSources
   };
 }
 function normalizeTailwindOptions(tailwind, projectRoot) {
-  const packageName = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _40 => _40.packageName]), () => ( "tailwindcss"));
-  const versionHint = _optionalChain([tailwind, 'optionalAccess', _41 => _41.version]);
-  const resolve = _optionalChain([tailwind, 'optionalAccess', _42 => _42.resolve]);
-  const cwd = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _43 => _43.cwd]), () => ( projectRoot));
-  const config = _optionalChain([tailwind, 'optionalAccess', _44 => _44.config]);
-  const postcssPlugin = _optionalChain([tailwind, 'optionalAccess', _45 => _45.postcssPlugin]);
-  const v4 = normalizeTailwindV4Options(_optionalChain([tailwind, 'optionalAccess', _46 => _46.v4]), cwd);
+  const packageName = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _19 => _19.packageName]), () => ( "tailwindcss"));
+  const versionHint = _optionalChain([tailwind, 'optionalAccess', _20 => _20.version]);
+  const resolve = _optionalChain([tailwind, 'optionalAccess', _21 => _21.resolve]);
+  const cwd = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _22 => _22.cwd]), () => ( projectRoot));
+  const config = _optionalChain([tailwind, 'optionalAccess', _23 => _23.config]);
+  const postcssPlugin = _optionalChain([tailwind, 'optionalAccess', _24 => _24.postcssPlugin]);
+  const v4 = normalizeTailwindV4Options(_optionalChain([tailwind, 'optionalAccess', _25 => _25.v4]), cwd);
   return {
     packageName,
     versionHint,
@@ -519,8 +420,8 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
     cwd,
     config,
     postcssPlugin,
-    v2: _optionalChain([tailwind, 'optionalAccess', _47 => _47.v2]),
-    v3: _optionalChain([tailwind, 'optionalAccess', _48 => _48.v3]),
+    v2: _optionalChain([tailwind, 'optionalAccess', _26 => _26.v2]),
+    v3: _optionalChain([tailwind, 'optionalAccess', _27 => _27.v3]),
     v4
   };
 }
@@ -616,7 +517,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', _49 => _49.sources, 'optionalAccess', _50 => _50.length])) {
+    if (!_optionalChain([v4Options, 'access', _28 => _28.sources, 'optionalAccess', _29 => _29.length])) {
       return void 0;
     }
     if (!v4Options.hasUserDefinedSources && !resolvedConfiguredBase) {
@@ -765,6 +666,105 @@ var _localpkg = require('local-pkg');
 
 var _semver = require('semver');
 
+// src/options/legacy.ts
+function normalizeLegacyFeatures(patch) {
+  const apply = _optionalChain([patch, 'optionalAccess', _30 => _30.applyPatches]);
+  const extend = _optionalChain([apply, 'optionalAccess', _31 => _31.extendLengthUnits]);
+  let extendOption = false;
+  if (extend && typeof extend === "object") {
+    extendOption = {
+      ...extend,
+      enabled: true
+    };
+  } else if (extend === true) {
+    extendOption = {
+      enabled: true,
+      units: ["rpx"],
+      overwrite: _optionalChain([patch, 'optionalAccess', _32 => _32.overwrite])
+    };
+  }
+  return {
+    exposeContext: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _33 => _33.exportContext]), () => ( true)),
+    extendLengthUnits: extendOption
+  };
+}
+function fromLegacyOptions(options) {
+  if (!options) {
+    return {};
+  }
+  const patch = options.patch;
+  const features = normalizeLegacyFeatures(patch);
+  const output = _optionalChain([patch, 'optionalAccess', _34 => _34.output]);
+  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _35 => _35.tailwindcss]);
+  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _36 => _36.version]);
+  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _37 => _37.v2]);
+  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _38 => _38.v3]);
+  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _39 => _39.v4]);
+  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _40 => _40.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _41 => _41.config])));
+  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _42 => _42.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _43 => _43.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _44 => _44.cwd])));
+  return {
+    cwd: _optionalChain([patch, 'optionalAccess', _45 => _45.cwd]),
+    overwrite: _optionalChain([patch, 'optionalAccess', _46 => _46.overwrite]),
+    filter: _optionalChain([patch, 'optionalAccess', _47 => _47.filter]),
+    cache: typeof options.cache === "boolean" ? options.cache : options.cache ? {
+      ...options.cache,
+      enabled: _nullishCoalesce(options.cache.enabled, () => ( true))
+    } : void 0,
+    output: output ? {
+      file: output.filename,
+      pretty: output.loose ? 2 : false,
+      removeUniversalSelector: output.removeUniversalSelector
+    } : void 0,
+    tailwind: {
+      packageName: _optionalChain([patch, 'optionalAccess', _48 => _48.packageName]),
+      version: tailwindVersion,
+      resolve: _optionalChain([patch, 'optionalAccess', _49 => _49.resolve]),
+      config: tailwindConfigPath,
+      cwd: tailwindCwd,
+      v2: tailwindV2,
+      v3: tailwindV3,
+      v4: tailwindV4
+    },
+    features: {
+      exposeContext: features.exposeContext,
+      extendLengthUnits: features.extendLengthUnits
+    }
+  };
+}
+function fromUnifiedConfig(registry) {
+  if (!registry) {
+    return {};
+  }
+  const tailwind = registry.tailwind;
+  const output = registry.output;
+  const pretty = (() => {
+    if (_optionalChain([output, 'optionalAccess', _50 => _50.pretty]) === void 0) {
+      return void 0;
+    }
+    if (typeof output.pretty === "boolean") {
+      return output.pretty ? 2 : false;
+    }
+    return output.pretty;
+  })();
+  return {
+    output: output ? {
+      file: output.file,
+      pretty,
+      removeUniversalSelector: output.stripUniversalSelector
+    } : void 0,
+    tailwind: tailwind ? {
+      version: tailwind.version,
+      packageName: tailwind.package,
+      resolve: tailwind.resolve,
+      config: tailwind.config,
+      cwd: tailwind.cwd,
+      v2: tailwind.legacy,
+      v3: tailwind.classic,
+      v4: tailwind.next
+    } : void 0
+  };
+}
+
 // src/patching/operations/export-context/index.ts
 
 
@@ -806,8 +806,8 @@ function transformProcessTailwindFeaturesReturnContextV2(content) {
   });
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path9) {
-      const node = path9.node;
+    FunctionDeclaration(path10) {
+      const node = path10.node;
       if (_optionalChain([node, 'access', _51 => _51.id, 'optionalAccess', _52 => _52.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
@@ -838,8 +838,8 @@ function transformPostcssPluginV2(content, options) {
   const ast = _parser.parse.call(void 0, content);
   let hasPatched = false;
   traverse(ast, {
-    Program(path9) {
-      const program = path9.node;
+    Program(path10) {
+      const program = path10.node;
       const index = program.body.findIndex((statement) => {
         return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _53 => _53.id, 'optionalAccess', _54 => _54.name]) === "_default";
       });
@@ -873,11 +873,11 @@ function transformPostcssPluginV2(content, options) {
         );
       }
     },
-    FunctionDeclaration(path9) {
+    FunctionDeclaration(path10) {
       if (hasPatched) {
         return;
       }
-      const fn = path9.node;
+      const fn = path10.node;
       if (_optionalChain([fn, 'access', _55 => _55.id, 'optionalAccess', _56 => _56.name]) !== "_default") {
         return;
       }
@@ -966,8 +966,8 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   const ast = _parser.parse.call(void 0, content);
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path9) {
-      const node = path9.node;
+    FunctionDeclaration(path10) {
+      const node = path10.node;
       if (_optionalChain([node, 'access', _57 => _57.id, 'optionalAccess', _58 => _58.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
@@ -999,8 +999,8 @@ function transformPostcssPlugin(content, { refProperty }) {
   const valueMember = t2.memberExpression(refIdentifier, t2.identifier("value"));
   let hasPatched = false;
   traverse(ast, {
-    Program(path9) {
-      const program = path9.node;
+    Program(path10) {
+      const program = path10.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', _59 => _59.expression, 'access', _60 => _60.right, 'access', _61 => _61.id, 'optionalAccess', _62 => _62.name]) === "tailwindcss";
       });
@@ -1038,11 +1038,11 @@ function transformPostcssPlugin(content, { refProperty }) {
         );
       }
     },
-    FunctionExpression(path9) {
+    FunctionExpression(path10) {
       if (hasPatched) {
         return;
       }
-      const fn = path9.node;
+      const fn = path10.node;
       if (_optionalChain([fn, 'access', _63 => _63.id, 'optionalAccess', _64 => _64.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
@@ -1208,21 +1208,21 @@ function updateLengthUnitsArray(content, options) {
   let arrayRef;
   let changed = false;
   traverse(ast, {
-    Identifier(path9) {
-      if (path9.node.name === variableName && t3.isVariableDeclarator(path9.parent) && t3.isArrayExpression(path9.parent.init)) {
-        arrayRef = path9.parent.init;
+    Identifier(path10) {
+      if (path10.node.name === variableName && t3.isVariableDeclarator(path10.parent) && t3.isArrayExpression(path10.parent.init)) {
+        arrayRef = path10.parent.init;
         const existing = new Set(
-          path9.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+          path10.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
         );
         for (const unit of units) {
           if (!existing.has(unit)) {
-            path9.parent.init.elements = path9.parent.init.elements.map((element) => {
+            path10.parent.init.elements = path10.parent.init.elements.map((element) => {
               if (t3.isStringLiteral(element)) {
                 return t3.stringLiteral(element.value);
               }
               return element;
             });
-            path9.parent.init.elements.push(t3.stringLiteral(unit));
+            path10.parent.init.elements.push(t3.stringLiteral(unit));
             changed = true;
           }
         }
@@ -1303,13 +1303,13 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     const { code, file, match } = item;
     const ast = _parser.parse.call(void 0, match[0], { sourceType: "unambiguous" });
     traverse(ast, {
-      ArrayExpression(path9) {
+      ArrayExpression(path10) {
         for (const unit of opts.units) {
-          if (path9.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
+          if (path10.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
             item.hasPatched = true;
             return;
           }
-          path9.node.elements.push(t3.stringLiteral(unit));
+          path10.node.elements.push(t3.stringLiteral(unit));
         }
       }
     });
@@ -1562,6 +1562,473 @@ var TailwindcssPatcher = (_class = class {
   }
 }, _class);
 
+// src/cli/commands.ts
+
+var _config = require('@tailwindcss-mangle/config');
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// ../shared/src/utils.ts
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+var preserveClassNames = [
+  // https://tailwindcss.com/docs/transition-timing-function start
+  // https://github.com/sonofmagic/tailwindcss-mangle/issues/21
+  "ease-out",
+  "ease-linear",
+  "ease-in",
+  "ease-in-out"
+  // https://tailwindcss.com/docs/transition-timing-function end
+];
+var preserveClassNamesMap = preserveClassNames.reduce((acc, cur) => {
+  acc[cur] = true;
+  return acc;
+}, {});
+var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
+
+// src/cli/commands.ts
+var _cac = require('cac'); var _cac2 = _interopRequireDefault(_cac);
+
+
+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 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)
+  };
+}
+function resolveCwd(rawCwd) {
+  if (!rawCwd) {
+    return _process2.default.cwd();
+  }
+  return _pathe2.default.resolve(rawCwd);
+}
+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));
+  const name = addPrefixIfMissing(baseName, prefix);
+  const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _84 => _84.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
+  return { name, aliases };
+}
+function resolveOptionDefinitions(defaults, override) {
+  if (!override) {
+    return defaults;
+  }
+  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 applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, _nullishCoalesce(option.description, () => ( "")), option.config);
+  }
+}
+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;
+  }
+  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"
+  });
+  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;
+}
+
+
 
 
 
@@ -1578,4 +2045,4 @@ var TailwindcssPatcher = (_class = class {
 
 
 
-exports.logger_default = logger_default; exports.CacheStore = CacheStore; exports.extractRawCandidatesWithPositions = extractRawCandidatesWithPositions; exports.extractRawCandidates = extractRawCandidates; exports.extractValidCandidates = extractValidCandidates; exports.extractProjectCandidatesWithPositions = extractProjectCandidatesWithPositions; exports.groupTokensByFile = groupTokensByFile; exports.fromLegacyOptions = fromLegacyOptions; exports.fromUnifiedConfig = fromUnifiedConfig; exports.normalizeOptions = normalizeOptions; exports.collectClassesFromContexts = collectClassesFromContexts; exports.collectClassesFromTailwindV4 = collectClassesFromTailwindV4; exports.loadRuntimeContexts = loadRuntimeContexts; exports.runTailwindBuild = runTailwindBuild; exports.TailwindcssPatcher = TailwindcssPatcher;
+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;