weapp-tailwindcss 4.5.2 → 4.6.0

package/dist/chunk-IY2OKZE6.mjs

@@ -0,0 +1,773 @@
+import {
+  defuOverrideArray
+} from "./chunk-ZNKIYZRQ.mjs";
+
+// src/context/tailwindcss.ts
+import { createRequire as createRequire2 } from "module";
+import path2 from "path";
+import process2 from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { logger as logger2 } from "@weapp-tailwindcss/logger";
+
+// src/tailwindcss/index.ts
+import { getPackageInfoSync } from "local-pkg";
+
+// src/tailwindcss/patcher.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import process from "process";
+import { fileURLToPath } from "url";
+import { logger } from "@weapp-tailwindcss/logger";
+import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
+import { TailwindcssPatcher } from "tailwindcss-patch";
+var GENERIC_RELATIVE_SPECIFIERS = [".", ".."];
+var DEFAULT_TAILWIND_CONFIG_SPECIFIERS = [
+  "stubs/config.full.js",
+  "defaultConfig.js"
+];
+function isPathSpecifier(specifier) {
+  if (!specifier) {
+    return false;
+  }
+  if (specifier.startsWith("file://")) {
+    return true;
+  }
+  if (path.isAbsolute(specifier)) {
+    return true;
+  }
+  return GENERIC_RELATIVE_SPECIFIERS.some((prefix) => specifier.startsWith(`${prefix}/`) || specifier.startsWith(`${prefix}\\`));
+}
+function resolveModuleFromPaths(specifier, paths) {
+  if (!specifier || isPathSpecifier(specifier) || paths.length === 0) {
+    return void 0;
+  }
+  try {
+    const req = createRequire(import.meta.url);
+    return req.resolve(specifier, { paths });
+  } catch {
+    return void 0;
+  }
+}
+function resolveTailwindConfigFallback(packageName, paths) {
+  if (!packageName) {
+    return void 0;
+  }
+  for (const suffix of DEFAULT_TAILWIND_CONFIG_SPECIFIERS) {
+    const candidate = `${packageName}/${suffix}`;
+    const resolved = resolveModuleFromPaths(candidate, paths);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return void 0;
+}
+function createFallbackTailwindcssPatcher() {
+  const packageInfo = {
+    name: "tailwindcss",
+    version: void 0,
+    rootPath: "",
+    packageJsonPath: "",
+    packageJson: {}
+  };
+  return {
+    packageInfo,
+    async patch() {
+      return {
+        exposeContext: void 0,
+        extendLengthUnits: void 0
+      };
+    },
+    async getClassSet() {
+      return /* @__PURE__ */ new Set();
+    },
+    async extract(_options) {
+      const classSet = /* @__PURE__ */ new Set();
+      return {
+        classList: [],
+        classSet
+      };
+    }
+  };
+}
+var hasLoggedMissingTailwind = false;
+function findNearestPackageRoot(startDir) {
+  if (!startDir) {
+    return void 0;
+  }
+  let current = path.resolve(startDir);
+  while (true) {
+    const pkgPath = path.join(current, "package.json");
+    if (existsSync(pkgPath)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function appendNodeModules(paths, dir) {
+  if (!dir) {
+    return;
+  }
+  const nodeModulesDir = path.join(dir, "node_modules");
+  if (existsSync(nodeModulesDir)) {
+    paths.add(nodeModulesDir);
+  }
+}
+var TAILWIND_CONFIG_FILES = [
+  "tailwind.config.js",
+  "tailwind.config.cjs",
+  "tailwind.config.mjs",
+  "tailwind.config.ts",
+  "tailwind.config.cts",
+  "tailwind.config.mts"
+];
+function findTailwindConfig(searchRoots) {
+  for (const root of searchRoots) {
+    for (const file of TAILWIND_CONFIG_FILES) {
+      const candidate = path.resolve(root, file);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+function createDefaultResolvePaths(basedir) {
+  const paths = /* @__PURE__ */ new Set();
+  let fallbackCandidates = [];
+  if (basedir) {
+    const resolvedBase = path.resolve(basedir);
+    appendNodeModules(paths, resolvedBase);
+    fallbackCandidates.push(resolvedBase);
+    const packageRoot = findNearestPackageRoot(resolvedBase);
+    if (packageRoot) {
+      appendNodeModules(paths, packageRoot);
+      fallbackCandidates.push(packageRoot);
+    }
+  }
+  const cwd = process.cwd();
+  appendNodeModules(paths, cwd);
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    const candidate = existsSync(modulePath) && !path.extname(modulePath) ? modulePath : path.dirname(modulePath);
+    paths.add(candidate);
+  } catch {
+    paths.add(import.meta.url);
+  }
+  if (paths.size === 0) {
+    fallbackCandidates = fallbackCandidates.filter(Boolean);
+    if (fallbackCandidates.length === 0) {
+      fallbackCandidates.push(cwd);
+    }
+    for (const candidate of fallbackCandidates) {
+      paths.add(candidate);
+    }
+  }
+  return [...paths];
+}
+function normalizeExtendLengthUnits(value) {
+  if (value === false) {
+    return false;
+  }
+  if (value === true) {
+    return { enabled: true };
+  }
+  if (value && typeof value === "object") {
+    return {
+      enabled: true,
+      ...value
+    };
+  }
+  return void 0;
+}
+function normalizeTailwindcssPatcherOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  if ("patch" in options) {
+    const { cache, patch } = options;
+    const normalized = {};
+    if (cache !== void 0) {
+      normalized.cache = cache;
+    }
+    if (patch?.overwrite !== void 0) {
+      normalized.overwrite = patch.overwrite;
+    }
+    if (patch?.filter) {
+      normalized.filter = patch.filter;
+    }
+    const extendLengthUnits = normalizeExtendLengthUnits(patch?.applyPatches?.extendLengthUnits);
+    const exposeContext = patch?.applyPatches?.exportContext;
+    if (extendLengthUnits !== void 0 || exposeContext !== void 0) {
+      normalized.features = {
+        exposeContext,
+        extendLengthUnits
+      };
+    }
+    const cwd = patch?.cwd ?? patch?.basedir;
+    if (cwd) {
+      normalized.cwd = cwd;
+    }
+    const tailwindOptions = patch?.tailwindcss ? { ...patch.tailwindcss } : void 0;
+    const legacyResolve = patch?.resolve;
+    let nextTailwindOptions = tailwindOptions;
+    if (nextTailwindOptions?.version === 2 && !nextTailwindOptions.packageName) {
+      nextTailwindOptions = {
+        ...nextTailwindOptions,
+        packageName: "@tailwindcss/postcss7-compat",
+        postcssPlugin: nextTailwindOptions.postcssPlugin
+      };
+      if (!nextTailwindOptions.postcssPlugin) {
+        nextTailwindOptions.postcssPlugin = "@tailwindcss/postcss7-compat";
+      }
+    }
+    if (nextTailwindOptions || legacyResolve) {
+      const resolveOptions = nextTailwindOptions?.resolve;
+      const mergedResolve = legacyResolve || resolveOptions ? {
+        ...resolveOptions ?? {},
+        ...legacyResolve ?? {}
+      } : void 0;
+      normalized.tailwind = {
+        ...nextTailwindOptions ?? {},
+        ...mergedResolve ? { resolve: mergedResolve } : {}
+      };
+    }
+    return normalized;
+  }
+  return options;
+}
+function createTailwindcssPatcher(options) {
+  const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+  const cache = {};
+  if (cacheDir) {
+    if (path.isAbsolute(cacheDir)) {
+      cache.dir = cacheDir;
+    } else if (basedir) {
+      cache.dir = path.resolve(basedir, cacheDir);
+    } else {
+      cache.dir = path.resolve(process.cwd(), cacheDir);
+    }
+  }
+  if (basedir) {
+    cache.cwd = basedir;
+  }
+  const resolvePaths = createDefaultResolvePaths(cache.cwd ?? basedir ?? process.cwd());
+  const normalizedUserOptions = normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
+  const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnitsPatch);
+  const baseTailwindOptions = defuOverrideArray2(
+    tailwindcss ?? {},
+    {
+      cwd: basedir,
+      resolve: {
+        paths: resolvePaths
+      }
+    }
+  );
+  if (baseTailwindOptions.version === 2) {
+    if (!baseTailwindOptions.packageName) {
+      baseTailwindOptions.packageName = "@tailwindcss/postcss7-compat";
+    }
+    if (!baseTailwindOptions.postcssPlugin) {
+      baseTailwindOptions.postcssPlugin = "@tailwindcss/postcss7-compat";
+    }
+  } else if (!baseTailwindOptions.packageName) {
+    baseTailwindOptions.packageName = "tailwindcss";
+  }
+  if (!baseTailwindOptions.postcssPlugin) {
+    baseTailwindOptions.postcssPlugin = baseTailwindOptions.version === 4 ? "@tailwindcss/postcss" : "tailwindcss";
+  }
+  if (typeof baseTailwindOptions.postcssPlugin === "string") {
+    const resolvedPlugin = resolveModuleFromPaths(baseTailwindOptions.postcssPlugin, resolvePaths);
+    if (resolvedPlugin) {
+      baseTailwindOptions.postcssPlugin = resolvedPlugin;
+    }
+  }
+  const baseOptions = {
+    cwd: basedir,
+    cache,
+    tailwind: baseTailwindOptions,
+    features: {
+      exposeContext: true,
+      extendLengthUnits
+    }
+  };
+  const resolvedOptions = defuOverrideArray2(
+    normalizedUserOptions ?? {},
+    baseOptions
+  );
+  if (resolvedOptions.tailwind) {
+    const existingResolve = resolvedOptions.tailwind.resolve ?? {};
+    const customPaths = Array.isArray(existingResolve.paths) && existingResolve.paths.length > 0;
+    const sourcePaths = customPaths ? existingResolve.paths : resolvePaths;
+    resolvedOptions.tailwind.resolve = {
+      ...existingResolve,
+      paths: Array.from(new Set(sourcePaths))
+    };
+    logger.debug("Tailwind resolve config %O", {
+      packageName: resolvedOptions.tailwind.packageName,
+      version: resolvedOptions.tailwind.version,
+      resolve: resolvedOptions.tailwind.resolve,
+      cwd: resolvedOptions.tailwind.cwd
+    });
+    if (typeof resolvedOptions.tailwind.postcssPlugin === "string") {
+      const resolvedPlugin = resolveModuleFromPaths(
+        resolvedOptions.tailwind.postcssPlugin,
+        resolvedOptions.tailwind.resolve?.paths ?? resolvePaths
+      );
+      if (resolvedPlugin) {
+        resolvedOptions.tailwind.postcssPlugin = resolvedPlugin;
+      }
+    }
+    const searchRoots = /* @__PURE__ */ new Set();
+    if (resolvedOptions.tailwind.cwd) {
+      searchRoots.add(resolvedOptions.tailwind.cwd);
+    }
+    for (const resolvePath of resolvedOptions.tailwind.resolve?.paths ?? []) {
+      const parentDir = path.dirname(resolvePath);
+      searchRoots.add(parentDir);
+    }
+    const configPath = findTailwindConfig(searchRoots);
+    if (!resolvedOptions.tailwind.config) {
+      if (configPath) {
+        resolvedOptions.tailwind.config = configPath;
+      } else {
+        const fallbackConfig = resolveTailwindConfigFallback(
+          resolvedOptions.tailwind.packageName,
+          resolvedOptions.tailwind.resolve.paths ?? resolvePaths
+        );
+        if (fallbackConfig) {
+          resolvedOptions.tailwind.config = fallbackConfig;
+        }
+      }
+    }
+    if (!resolvedOptions.tailwind.cwd && configPath) {
+      resolvedOptions.tailwind.cwd = path.dirname(configPath);
+    }
+  }
+  try {
+    return new TailwindcssPatcher(resolvedOptions);
+  } catch (error) {
+    const searchPaths = resolvedOptions.tailwind?.resolve?.paths;
+    if (error instanceof Error && /tailwindcss not found/i.test(error.message)) {
+      if (!hasLoggedMissingTailwind) {
+        logger.warn("Tailwind CSS \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7 Tailwind \u76F8\u5173\u8865\u4E01\u3002\u82E5\u9700\u4F7F\u7528 Tailwind \u80FD\u529B\uFF0C\u8BF7\u5B89\u88C5 tailwindcss\u3002");
+        hasLoggedMissingTailwind = true;
+      }
+      return createFallbackTailwindcssPatcher();
+    }
+    if (error instanceof Error && /unable to locate tailwind css package/i.test(error.message)) {
+      logger.error('\u65E0\u6CD5\u5B9A\u4F4D Tailwind CSS \u5305 "%s"\uFF0C\u5DF2\u5C1D\u8BD5\u8DEF\u5F84: %O', resolvedOptions.tailwind?.packageName, searchPaths);
+    }
+    throw error;
+  }
+}
+
+// src/context/tailwindcss.ts
+var ENV_BASEDIR_KEYS = [
+  "WEAPP_TAILWINDCSS_BASEDIR",
+  "WEAPP_TAILWINDCSS_BASE_DIR",
+  "TAILWINDCSS_BASEDIR",
+  "TAILWINDCSS_BASE_DIR",
+  "UNI_INPUT_DIR",
+  "UNI_INPUT_ROOT",
+  "UNI_CLI_ROOT",
+  "UNI_APP_INPUT_DIR",
+  "INIT_CWD",
+  "PWD"
+];
+var GENERIC_ENV_BASEDIR_KEYS = /* @__PURE__ */ new Set(["INIT_CWD", "PWD"]);
+function pickEnvBasedir() {
+  for (const key of ENV_BASEDIR_KEYS) {
+    const value = process2.env[key];
+    if (value && path2.isAbsolute(value)) {
+      return { key, value };
+    }
+  }
+  return void 0;
+}
+function pickPackageEnvBasedir() {
+  const packageJsonPath = process2.env.npm_package_json;
+  if (packageJsonPath) {
+    const packageDir = path2.dirname(packageJsonPath);
+    if (packageDir && path2.isAbsolute(packageDir)) {
+      return packageDir;
+    }
+  }
+  const localPrefix = process2.env.npm_config_local_prefix;
+  if (localPrefix && path2.isAbsolute(localPrefix)) {
+    return localPrefix;
+  }
+  return void 0;
+}
+function detectCallerBasedir() {
+  const stack = new Error("resolveTailwindcssBasedir stack probe").stack;
+  if (!stack) {
+    return void 0;
+  }
+  if (process2.env.WEAPP_TW_DEBUG_STACK === "1") {
+    logger2.debug("caller stack: %s", stack);
+  }
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const match = line.match(/\(([^)]+)\)/u) ?? line.match(/at\s+(\S.*)$/u);
+    const location = match?.[1];
+    if (!location) {
+      continue;
+    }
+    let filePath = location;
+    if (filePath.startsWith("file://")) {
+      try {
+        filePath = fileURLToPath2(filePath);
+      } catch {
+        continue;
+      }
+    }
+    const [candidate] = filePath.split(":");
+    const resolvedPath = path2.isAbsolute(filePath) ? filePath : candidate;
+    if (!path2.isAbsolute(resolvedPath)) {
+      continue;
+    }
+    if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) {
+      continue;
+    }
+    try {
+      return path2.dirname(resolvedPath);
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function resolveTailwindcssBasedir(basedir) {
+  const envBasedirResult = pickEnvBasedir();
+  const envBasedir = envBasedirResult?.value;
+  const envBasedirKey = envBasedirResult?.key;
+  const envBasedirIsGeneric = envBasedirKey ? GENERIC_ENV_BASEDIR_KEYS.has(envBasedirKey) : false;
+  const packageEnvBasedir = pickPackageEnvBasedir();
+  const shouldDetectCaller = !envBasedir || envBasedirIsGeneric;
+  const callerBasedir = shouldDetectCaller ? detectCallerBasedir() : void 0;
+  const anchor = envBasedir ?? packageEnvBasedir ?? callerBasedir ?? process2.cwd();
+  if (process2.env.WEAPP_TW_DEBUG_STACK === "1") {
+    logger2.debug("resolveTailwindcssBasedir anchor %O", {
+      basedir,
+      envBasedir,
+      envBasedirKey,
+      envBasedirIsGeneric,
+      packageEnvBasedir,
+      callerBasedir,
+      npm_package_json: process2.env.npm_package_json,
+      cwd: process2.cwd(),
+      anchor
+    });
+  }
+  if (basedir && basedir.trim().length > 0) {
+    if (path2.isAbsolute(basedir)) {
+      return path2.normalize(basedir);
+    }
+    return path2.resolve(anchor, basedir);
+  }
+  if (envBasedir && !envBasedirIsGeneric) {
+    return path2.normalize(envBasedir);
+  }
+  if (packageEnvBasedir) {
+    return path2.normalize(packageEnvBasedir);
+  }
+  if (callerBasedir) {
+    const normalizedCaller = path2.normalize(callerBasedir);
+    const librarySegment = `${path2.sep}weapp-tailwindcss${path2.sep}`;
+    if (!normalizedCaller.includes(librarySegment)) {
+      return normalizedCaller;
+    }
+  }
+  if (envBasedir) {
+    return path2.normalize(envBasedir);
+  }
+  const packageName = process2.env.PNPM_PACKAGE_NAME;
+  if (packageName) {
+    try {
+      const anchorRequire = createRequire2(path2.join(anchor, "__resolve_tailwindcss_basedir__.cjs"));
+      const packageJsonPath = anchorRequire.resolve(`${packageName}/package.json`);
+      if (process2.env.WEAPP_TW_DEBUG_STACK === "1") {
+        logger2.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+      }
+      return path2.normalize(path2.dirname(packageJsonPath));
+    } catch {
+      if (process2.env.WEAPP_TW_DEBUG_STACK === "1") {
+        logger2.debug("failed to resolve package json for %s", packageName);
+      }
+    }
+  }
+  return path2.normalize(process2.cwd());
+}
+function normalizeCssEntries(entries, anchor) {
+  if (!entries || entries.length === 0) {
+    return void 0;
+  }
+  const normalized = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const trimmed = entry.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    const resolved = path2.isAbsolute(trimmed) ? path2.normalize(trimmed) : path2.normalize(path2.resolve(anchor, trimmed));
+    normalized.add(resolved);
+  }
+  return normalized.size > 0 ? [...normalized] : void 0;
+}
+function groupCssEntriesByBase(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const baseDir = path2.normalize(path2.dirname(entry));
+    const bucket = groups.get(baseDir);
+    if (bucket) {
+      bucket.push(entry);
+    } else {
+      groups.set(baseDir, [entry]);
+    }
+  }
+  return groups;
+}
+function overrideTailwindcssPatcherOptionsForBase(options, baseDir, cssEntries) {
+  if (!options) {
+    return options;
+  }
+  if ("patch" in options) {
+    const patchOptions = options.patch;
+    if (!patchOptions) {
+      return options;
+    }
+    const nextPatch = {
+      ...patchOptions,
+      basedir: baseDir,
+      cwd: patchOptions.cwd ?? baseDir
+    };
+    if (patchOptions.tailwindcss) {
+      nextPatch.tailwindcss = {
+        ...patchOptions.tailwindcss,
+        v4: {
+          ...patchOptions.tailwindcss.v4 ?? {},
+          base: baseDir,
+          cssEntries
+        }
+      };
+    }
+    return {
+      ...options,
+      patch: nextPatch
+    };
+  }
+  if (!options.tailwind) {
+    return options;
+  }
+  return {
+    ...options,
+    tailwind: {
+      ...options.tailwind,
+      v4: {
+        ...options.tailwind.v4 ?? {},
+        base: baseDir,
+        cssEntries
+      }
+    }
+  };
+}
+function createPatcherForBase(baseDir, cssEntries, options) {
+  const {
+    tailwindcss,
+    tailwindcssPatcherOptions,
+    supportCustomLengthUnitsPatch,
+    appType
+  } = options;
+  const defaultTailwindcssConfig = {
+    cwd: baseDir,
+    v2: {
+      cwd: baseDir
+    },
+    v3: {
+      cwd: baseDir
+    },
+    v4: {
+      base: baseDir,
+      cssEntries
+    }
+  };
+  if (cssEntries?.length && (tailwindcss == null || tailwindcss.version == null)) {
+    defaultTailwindcssConfig.version = 4;
+  }
+  const mergedTailwindOptions = defuOverrideArray(
+    tailwindcss ?? {},
+    defaultTailwindcssConfig
+  );
+  if (!mergedTailwindOptions.v4) {
+    mergedTailwindOptions.v4 = {
+      base: baseDir,
+      cssEntries: cssEntries ?? []
+    };
+  } else {
+    mergedTailwindOptions.v4.base = baseDir;
+    if (cssEntries?.length) {
+      mergedTailwindOptions.v4.cssEntries = cssEntries;
+    } else if (!mergedTailwindOptions.v4.cssEntries) {
+      mergedTailwindOptions.v4.cssEntries = [];
+    }
+  }
+  const patchedOptions = overrideTailwindcssPatcherOptionsForBase(
+    tailwindcssPatcherOptions,
+    baseDir,
+    cssEntries ?? []
+  );
+  return createTailwindcssPatcher({
+    basedir: baseDir,
+    cacheDir: appType === "mpx" ? "node_modules/tailwindcss-patch/.cache" : void 0,
+    supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
+    tailwindcss: mergedTailwindOptions,
+    tailwindcssPatcherOptions: patchedOptions
+  });
+}
+function createMultiTailwindcssPatcher(patchers) {
+  if (patchers.length <= 1) {
+    return patchers[0];
+  }
+  const [first] = patchers;
+  const multiPatcher = {
+    packageInfo: first?.packageInfo,
+    majorVersion: first?.majorVersion,
+    options: first?.options,
+    async patch() {
+      let exposeContext;
+      let extendLengthUnits;
+      for (const patcher of patchers) {
+        const result = await patcher.patch();
+        if (result?.exposeContext && exposeContext == null) {
+          exposeContext = result.exposeContext;
+        }
+        if (result?.extendLengthUnits && extendLengthUnits == null) {
+          extendLengthUnits = result.extendLengthUnits;
+        }
+      }
+      return {
+        exposeContext,
+        extendLengthUnits
+      };
+    },
+    async getClassSet() {
+      const aggregated = /* @__PURE__ */ new Set();
+      for (const patcher of patchers) {
+        const current = await patcher.getClassSet();
+        for (const className of current) {
+          aggregated.add(className);
+        }
+      }
+      return aggregated;
+    },
+    async extract(options) {
+      const aggregatedSet = /* @__PURE__ */ new Set();
+      const aggregatedList = [];
+      let filename;
+      for (const patcher of patchers) {
+        const result = await patcher.extract(options);
+        if (!result) {
+          continue;
+        }
+        if (filename === void 0 && result.filename) {
+          filename = result.filename;
+        }
+        if (result.classList) {
+          for (const className of result.classList) {
+            if (!aggregatedSet.has(className)) {
+              aggregatedList.push(className);
+            }
+            aggregatedSet.add(className);
+          }
+        }
+        if (result.classSet) {
+          for (const className of result.classSet) {
+            aggregatedSet.add(className);
+          }
+        }
+      }
+      return {
+        classList: aggregatedList,
+        classSet: aggregatedSet,
+        filename
+      };
+    }
+  };
+  if (patchers.every((patcher) => typeof patcher.getClassSetSync === "function")) {
+    multiPatcher.getClassSetSync = () => {
+      const aggregated = /* @__PURE__ */ new Set();
+      for (const patcher of patchers) {
+        const current = patcher.getClassSetSync?.();
+        if (!current) {
+          continue;
+        }
+        for (const className of current) {
+          aggregated.add(className);
+        }
+      }
+      return aggregated;
+    };
+  }
+  return multiPatcher;
+}
+function tryCreateMultiTailwindcssPatcher(cssEntries, options) {
+  const groups = groupCssEntriesByBase(cssEntries);
+  if (groups.size <= 1) {
+    return void 0;
+  }
+  logger2.debug("detected multiple Tailwind CSS entry bases: %O", [...groups.keys()]);
+  const patchers = [];
+  for (const [baseDir, entries] of groups) {
+    patchers.push(createPatcherForBase(baseDir, entries, options));
+  }
+  return createMultiTailwindcssPatcher(patchers);
+}
+function createTailwindcssPatcherFromContext(ctx) {
+  const {
+    tailwindcssBasedir,
+    supportCustomLengthUnitsPatch,
+    tailwindcss,
+    tailwindcssPatcherOptions,
+    cssEntries: rawCssEntries,
+    appType
+  } = ctx;
+  const resolvedTailwindcssBasedir = resolveTailwindcssBasedir(tailwindcssBasedir);
+  ctx.tailwindcssBasedir = resolvedTailwindcssBasedir;
+  logger2.debug("tailwindcss basedir resolved: %s", resolvedTailwindcssBasedir);
+  const normalizedCssEntries = normalizeCssEntries(rawCssEntries, resolvedTailwindcssBasedir);
+  if (normalizedCssEntries) {
+    ctx.cssEntries = normalizedCssEntries;
+  }
+  const multiPatcher = normalizedCssEntries ? tryCreateMultiTailwindcssPatcher(normalizedCssEntries, {
+    tailwindcss,
+    tailwindcssPatcherOptions,
+    supportCustomLengthUnitsPatch,
+    appType
+  }) : void 0;
+  if (multiPatcher) {
+    return multiPatcher;
+  }
+  const effectiveCssEntries = normalizedCssEntries ?? rawCssEntries;
+  return createPatcherForBase(
+    resolvedTailwindcssBasedir,
+    effectiveCssEntries,
+    {
+      tailwindcss,
+      tailwindcssPatcherOptions,
+      supportCustomLengthUnitsPatch,
+      appType
+    }
+  );
+}
+
+export {
+  resolveTailwindcssBasedir,
+  createTailwindcssPatcherFromContext
+};