weapp-tailwindcss 4.10.3 → 4.11.0-alpha.1

package/dist/chunk-LD7LZ4IK.mjs

@@ -0,0 +1,1933 @@
+import {
+  pushConcurrentTaskFactories,
+  resolveDisabledOptions,
+  resolveOutputSpecifier,
+  resolvePackageDir,
+  resolveTailwindcssImport,
+  rewriteTailwindcssImportsInCode,
+  toAbsoluteOutputPath
+} from "./chunk-F2CKKG6Q.mjs";
+import {
+  processCachedTask
+} from "./chunk-RRHPTTCP.mjs";
+import {
+  setupPatchRecorder
+} from "./chunk-QYZCRG7F.mjs";
+import {
+  babelParse,
+  collectRuntimeClassSet,
+  createAttributeMatcher,
+  createDebug,
+  generateCode,
+  getCompilerContext,
+  getRuntimeClassSetSignature,
+  refreshTailwindRuntimeState,
+  replaceWxml,
+  toCustomAttributesEntities,
+  traverse,
+  vitePluginName
+} from "./chunk-FZNYV7VH.mjs";
+import {
+  findNearestPackageRoot,
+  findTailwindConfig
+} from "./chunk-IEZ5RBMG.mjs";
+import {
+  resolveUniUtsPlatform
+} from "./chunk-OOHJLO5M.mjs";
+
+// src/bundlers/vite/index.ts
+import { existsSync } from "fs";
+import path4 from "path";
+import process4 from "process";
+import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
+
+// src/uni-app-x/transform.ts
+import { NodeTypes } from "@vue/compiler-dom";
+import { parse } from "@vue/compiler-sfc";
+import MagicString from "magic-string";
+function traverse2(node, visitor) {
+  visitor(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (child && typeof child === "object" && "type" in child) {
+        traverse2(child, visitor);
+      }
+    }
+  }
+}
+function updateStaticAttribute(ms, prop) {
+  if (!prop.value) {
+    return;
+  }
+  const start = prop.value.loc.start.offset + 1;
+  const end = prop.value.loc.end.offset - 1;
+  if (start < end) {
+    ms.update(start, end, replaceWxml(prop.value.content));
+  }
+}
+function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
+  if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) {
+    return;
+  }
+  const start = prop.exp.loc.start.offset;
+  const end = prop.exp.loc.end.offset;
+  if (start >= end) {
+    return;
+  }
+  const generated = generateCode(prop.exp.content, {
+    jsHandler,
+    runtimeSet,
+    wrapExpression: true
+  });
+  ms.update(start, end, generated);
+}
+function shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute) {
+  const lowerName = attrName.toLowerCase();
+  const shouldHandleDefault = !disabledDefaultTemplateHandler && lowerName === "class";
+  const shouldHandleCustom = matchCustomAttribute?.(tag, attrName) ?? false;
+  return {
+    shouldHandleDefault,
+    shouldHandleCustom,
+    shouldHandle: shouldHandleDefault || shouldHandleCustom
+  };
+}
+var defaultCreateJsHandlerOptions = {
+  babelParserOptions: {
+    plugins: [
+      "typescript"
+    ]
+  }
+};
+var UVUE_NVUE_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
+  if (!UVUE_NVUE_RE.test(id)) {
+    return;
+  }
+  const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
+  const matchCustomAttribute = createAttributeMatcher(customAttributesEntities);
+  const ms = new MagicString(code);
+  const { descriptor, errors } = parse(code);
+  if (errors.length === 0) {
+    if (descriptor.template?.ast) {
+      traverse2(descriptor.template.ast, (node) => {
+        if (node.type !== NodeTypes.ELEMENT) {
+          return;
+        }
+        const tag = node.tag;
+        for (const prop of node.props) {
+          if (prop.type === NodeTypes.ATTRIBUTE) {
+            const { shouldHandle, shouldHandleDefault } = shouldHandleAttribute(
+              tag,
+              prop.name,
+              disabledDefaultTemplateHandler,
+              matchCustomAttribute
+            );
+            if (!shouldHandle) {
+              continue;
+            }
+            updateStaticAttribute(ms, prop);
+            if (shouldHandleDefault) {
+              continue;
+            }
+          } else if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic) {
+            const attrName = prop.arg.content;
+            const { shouldHandle } = shouldHandleAttribute(
+              tag,
+              attrName,
+              disabledDefaultTemplateHandler,
+              matchCustomAttribute
+            );
+            if (!shouldHandle) {
+              continue;
+            }
+            updateDirectiveExpression(ms, prop, jsHandler, runtimeSet);
+          }
+        }
+      });
+    }
+    if (descriptor.script) {
+      const { code: code2 } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+      ms.update(descriptor.script.loc.start.offset, descriptor.script.loc.end.offset, code2);
+    }
+    if (descriptor.scriptSetup) {
+      const { code: code2 } = jsHandler(descriptor.scriptSetup.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+      ms.update(descriptor.scriptSetup.loc.start.offset, descriptor.scriptSetup.loc.end.offset, code2);
+    }
+  }
+  return {
+    code: ms.toString(),
+    // @ts-ignore
+    get map() {
+      return ms.generateMap();
+    }
+  };
+}
+
+// src/bundlers/vite/query.ts
+function parseVueRequest(id) {
+  const [filename, rawQuery] = id.split(`?`, 2);
+  const searchParams = new URLSearchParams(rawQuery);
+  const query = Object.fromEntries(searchParams);
+  if (query.vue != null) {
+    query.vue = true;
+  }
+  if (query.index != null) {
+    query.index = Number(query.index);
+  }
+  if (query.raw != null) {
+    query.raw = true;
+  }
+  if (query.url != null) {
+    query.url = true;
+  }
+  if (query.scoped != null) {
+    query.scoped = true;
+  }
+  const langTypeMatch = [...searchParams.keys()].find((key) => key.startsWith("lang."));
+  const langType = query.lang || (langTypeMatch ? langTypeMatch.slice("lang.".length) : void 0);
+  if (langType) {
+    query.lang = langType;
+  }
+  return {
+    filename,
+    query
+  };
+}
+
+// src/bundlers/vite/utils.ts
+import path from "path";
+import process from "process";
+import { cleanUrl, ensurePosix } from "@weapp-tailwindcss/shared";
+function slash(p) {
+  return ensurePosix(p);
+}
+var isWindows = process.platform === "win32";
+var cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`;
+var cssLangRE = new RegExp(cssLangs);
+function isCSSRequest(request) {
+  return cssLangRE.test(request);
+}
+function normalizePath(id) {
+  return path.posix.normalize(isWindows ? ensurePosix(id) : id);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+  const inputFileDir = path.dirname(file);
+  const sources = rawMap.sources.map((source) => {
+    const cleanSource = cleanUrl(decodeURIComponent(source));
+    if (cleanSource[0] === "<" && cleanSource.endsWith(">")) {
+      return `\0${cleanSource}`;
+    }
+    return normalizePath(path.resolve(inputFileDir, cleanSource));
+  });
+  return {
+    file,
+    mappings: rawMap.mappings,
+    names: rawMap.names,
+    sources,
+    sourcesContent: rawMap.sourcesContent,
+    version: rawMap.version
+  };
+}
+
+// src/uni-app-x/vite.ts
+var preprocessorLangs = /* @__PURE__ */ new Set(["scss", "sass", "less", "styl", "stylus"]);
+var INLINE_LANG_RE = /lang\.([a-z]+)/i;
+var PREPROCESSOR_EXT_RE = /\.(?:scss|sass|less|styl|stylus)(?:\?|$)/i;
+var UVUE_NVUE_QUERY_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+var UVUE_NVUE_RE2 = /\.(?:uvue|nvue)$/;
+function isPreprocessorRequest(id, lang) {
+  const normalizedLang = lang?.toLowerCase();
+  if (normalizedLang && preprocessorLangs.has(normalizedLang)) {
+    return true;
+  }
+  const inlineLangMatch = id.match(INLINE_LANG_RE);
+  if (inlineLangMatch && preprocessorLangs.has(inlineLangMatch[1].toLowerCase())) {
+    return true;
+  }
+  return PREPROCESSOR_EXT_RE.test(id);
+}
+function createUniAppXPlugins(options) {
+  const {
+    appType,
+    customAttributesEntities,
+    disabledDefaultTemplateHandler,
+    isIosPlatform: providedIosPlatform,
+    mainCssChunkMatcher,
+    runtimeState,
+    styleHandler,
+    jsHandler,
+    ensureRuntimeClassSet,
+    getResolvedConfig
+  } = options;
+  const isIosPlatform = providedIosPlatform ?? resolveUniUtsPlatform().isAppIos;
+  const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+  async function transformStyle(code, id, query) {
+    const parsed = query ?? parseVueRequest(id).query;
+    if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
+      const cacheKey = `${mainCssChunkMatcher(id, appType) ? "1" : "0"}:${id}`;
+      let styleHandlerOptions = cssHandlerOptionsCache.get(cacheKey);
+      if (!styleHandlerOptions) {
+        styleHandlerOptions = {
+          isMainChunk: mainCssChunkMatcher(id, appType),
+          postcssOptions: {
+            options: {
+              from: id,
+              map: {
+                inline: false,
+                annotation: false,
+                // PostCSS 可能返回虚拟文件，因此需要启用这一项以获取源内容
+                sourcesContent: true
+                // 若上游预处理器已经生成 source map，sources 中可能出现重复条目
+              }
+            }
+          }
+        };
+        cssHandlerOptionsCache.set(cacheKey, styleHandlerOptions);
+      }
+      const postcssResult = await styleHandler(code, styleHandlerOptions);
+      const rawPostcssMap = postcssResult.map.toJSON();
+      const postcssMap = await formatPostcssSourceMap(
+        rawPostcssMap,
+        cleanUrl(id)
+      );
+      return {
+        code: postcssResult.css,
+        map: postcssMap
+      };
+    }
+  }
+  const cssPrePlugin = {
+    name: "weapp-tailwindcss:uni-app-x:css:pre",
+    enforce: "pre",
+    async transform(code, id) {
+      await runtimeState.patchPromise;
+      const { query } = parseVueRequest(id);
+      const lang = query.lang;
+      if (isIosPlatform && isPreprocessorRequest(id, lang)) {
+        return;
+      }
+      return transformStyle(code, id, query);
+    }
+  };
+  const cssPlugin = {
+    name: "weapp-tailwindcss:uni-app-x:css",
+    async transform(code, id) {
+      await runtimeState.patchPromise;
+      return transformStyle(code, id);
+    }
+  };
+  const cssPlugins = [cssPlugin, cssPrePlugin];
+  const nvuePlugin = {
+    name: "weapp-tailwindcss:uni-app-x:nvue",
+    enforce: "pre",
+    async buildStart() {
+      await ensureRuntimeClassSet(true);
+    },
+    async transform(code, id) {
+      if (!UVUE_NVUE_QUERY_RE.test(id)) {
+        return;
+      }
+      const resolvedConfig = getResolvedConfig();
+      const isServeCommand = resolvedConfig?.command === "serve";
+      const isWatchBuild = resolvedConfig?.command === "build" && !!resolvedConfig.build?.watch;
+      const isNonWatchBuild = resolvedConfig?.command === "build" && !resolvedConfig.build?.watch;
+      const shouldForceRefresh = isServeCommand || isWatchBuild || isNonWatchBuild;
+      const currentRuntimeSet = shouldForceRefresh ? await ensureRuntimeClassSet(true) : await ensureRuntimeClassSet();
+      const extraOptions = customAttributesEntities.length > 0 || disabledDefaultTemplateHandler ? {
+        customAttributesEntities,
+        disabledDefaultTemplateHandler
+      } : void 0;
+      if (extraOptions) {
+        return transformUVue(code, id, jsHandler, currentRuntimeSet, extraOptions);
+      }
+      return transformUVue(code, id, jsHandler, currentRuntimeSet);
+    },
+    async handleHotUpdate(ctx) {
+      const resolvedConfig = getResolvedConfig();
+      if (resolvedConfig?.command !== "serve") {
+        return;
+      }
+      if (!UVUE_NVUE_RE2.test(ctx.file)) {
+        return;
+      }
+      await ensureRuntimeClassSet(true);
+    },
+    async watchChange(id) {
+      const resolvedConfig = getResolvedConfig();
+      if (resolvedConfig?.command !== "build" || !resolvedConfig.build?.watch) {
+        return;
+      }
+      if (!UVUE_NVUE_QUERY_RE.test(id)) {
+        return;
+      }
+      await ensureRuntimeClassSet(true);
+    }
+  };
+  return [
+    ...cssPlugins,
+    nvuePlugin
+  ];
+}
+function createUniAppXAssetTask(file, originalSource, outDir, options) {
+  return async () => {
+    const {
+      cache,
+      hashKey,
+      createHandlerOptions,
+      debug: debug3,
+      jsHandler,
+      onUpdate,
+      runtimeSet,
+      applyLinkedResults: applyLinkedResults2
+    } = options;
+    const absoluteFile = toAbsoluteOutputPath(file, outDir);
+    const rawSource = originalSource.source.toString();
+    const rawHashSource = options.hashSalt ? `${rawSource}
+/*${options.hashSalt}*/` : rawSource;
+    await processCachedTask({
+      cache,
+      cacheKey: file,
+      hashKey,
+      rawSource: rawHashSource,
+      applyResult(source) {
+        originalSource.source = source;
+      },
+      onCacheHit() {
+        debug3("js cache hit: %s", file);
+      },
+      async transform() {
+        const currentSource = originalSource.source.toString();
+        const { code, linked } = await jsHandler(currentSource, runtimeSet, createHandlerOptions(absoluteFile, {
+          uniAppX: options.uniAppX ?? true,
+          babelParserOptions: {
+            plugins: [
+              "typescript"
+            ],
+            sourceType: "unambiguous"
+          }
+        }));
+        onUpdate(file, currentSource, code);
+        debug3("js handle: %s", file);
+        applyLinkedResults2(linked);
+        return {
+          result: code
+        };
+      }
+    });
+  };
+}
+
+// src/bundlers/vite/generate-bundle.ts
+import path2 from "path";
+import process2 from "process";
+
+// src/bundlers/vite/bundle-entries.ts
+import { Buffer } from "buffer";
+function readOutputEntry(entry) {
+  if (entry.output.type === "chunk") {
+    return entry.output.code;
+  }
+  const source = entry.output.source;
+  if (typeof source === "string") {
+    return source;
+  }
+  if (source instanceof Uint8Array) {
+    return Buffer.from(source).toString();
+  }
+  const fallbackSource = source;
+  if (fallbackSource == null) {
+    return void 0;
+  }
+  if (typeof fallbackSource.toString === "function") {
+    return fallbackSource.toString();
+  }
+  return void 0;
+}
+function isJavaScriptEntry(entry) {
+  if (entry.output.type === "chunk") {
+    return true;
+  }
+  return entry.fileName.endsWith(".js");
+}
+function createBundleModuleGraphOptions(outputDir, entries) {
+  return {
+    resolve(specifier, importer) {
+      return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => entries.has(candidate));
+    },
+    load(id) {
+      const entry = entries.get(id);
+      if (!entry) {
+        return void 0;
+      }
+      return readOutputEntry(entry);
+    },
+    filter(id) {
+      return entries.has(id);
+    }
+  };
+}
+function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
+  if (!linked) {
+    return;
+  }
+  for (const [id, { code }] of Object.entries(linked)) {
+    const entry = entries.get(id);
+    if (!entry) {
+      continue;
+    }
+    const previous = readOutputEntry(entry);
+    if (previous == null || previous === code) {
+      continue;
+    }
+    if (entry.output.type === "chunk") {
+      entry.output.code = code;
+    } else {
+      entry.output.source = code;
+    }
+    onApplied?.(entry, code);
+    onLinkedUpdate(entry.fileName, previous, code);
+  }
+}
+
+// src/bundlers/vite/runtime-affecting-signature.ts
+import { Parser } from "htmlparser2";
+var CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+var CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+var CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+var CSS_WHITESPACE_RE = /\s+/g;
+function createHtmlRuntimeAffectingSignature(source) {
+  try {
+    const parts = [];
+    const parser = new Parser(
+      {
+        onattribute(name, value) {
+          parts.push(`a:${name}=${value}`);
+        },
+        oncomment(data) {
+          parts.push(`c:${data}`);
+        },
+        ontext(data) {
+          const value = data.trim();
+          if (value.length > 0) {
+            parts.push(`t:${value}`);
+          }
+        }
+      },
+      {
+        xmlMode: true
+      }
+    );
+    parser.write(source);
+    parser.end();
+    return parts.join("\n");
+  } catch {
+    return source;
+  }
+}
+function createJsRuntimeAffectingSignature(source) {
+  try {
+    const ast = babelParse(source, {
+      cache: true,
+      cacheKey: "vite-runtime-affecting:unambiguous",
+      plugins: ["jsx", "typescript"],
+      sourceType: "unambiguous"
+    });
+    const parts = [];
+    traverse(ast, {
+      noScope: true,
+      StringLiteral(path5) {
+        parts.push(`s:${path5.node.value}`);
+      },
+      TemplateElement(path5) {
+        parts.push(`t:${path5.node.value.raw}`);
+      },
+      JSXText(path5) {
+        const value = path5.node.value.trim();
+        if (value.length > 0) {
+          parts.push(`x:${value}`);
+        }
+      }
+    });
+    const comments = ast.comments;
+    if (Array.isArray(comments)) {
+      for (const comment of comments) {
+        if (typeof comment?.value === "string" && comment.value.length > 0) {
+          parts.push(`c:${comment.value}`);
+        }
+      }
+    }
+    return parts.join("\n");
+  } catch {
+    return source;
+  }
+}
+function createCssRuntimeAffectingSignature(source) {
+  return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+  if (type === "html") {
+    return createHtmlRuntimeAffectingSignature(source);
+  }
+  if (type === "js") {
+    return createJsRuntimeAffectingSignature(source);
+  }
+  if (type === "css") {
+    return createCssRuntimeAffectingSignature(source);
+  }
+  return source;
+}
+
+// src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
+  return {
+    iteration: 0,
+    sourceHashByFile: /* @__PURE__ */ new Map(),
+    runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+    linkedByEntry: /* @__PURE__ */ new Map(),
+    dependentsByLinkedFile: /* @__PURE__ */ new Map()
+  };
+}
+function createChangedByType() {
+  return {
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set(),
+    other: /* @__PURE__ */ new Set()
+  };
+}
+function createProcessFiles() {
+  return {
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set()
+  };
+}
+function readEntrySource(output) {
+  if (output.type === "chunk") {
+    return output.code;
+  }
+  return output.source.toString();
+}
+function classifyBundleEntry(file, opts) {
+  if (opts.cssMatcher(file)) {
+    return "css";
+  }
+  if (opts.htmlMatcher(file)) {
+    return "html";
+  }
+  if (opts.jsMatcher(file) || opts.wxsMatcher(file)) {
+    return "js";
+  }
+  return "other";
+}
+function collectJsEntries(fileName, output, outDir, store) {
+  const entry = { fileName, output };
+  if (!isJavaScriptEntry(entry)) {
+    return;
+  }
+  const absolute = toAbsoluteOutputPath(fileName, outDir);
+  store.set(absolute, entry);
+}
+function markProcessFile(type, file, processFiles) {
+  if (type === "html" || type === "js" || type === "css") {
+    processFiles[type].add(file);
+  }
+}
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+  const sourceHashByFile = /* @__PURE__ */ new Map();
+  const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
+  const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+  const changedByType = createChangedByType();
+  const runtimeAffectingChangedByType = createChangedByType();
+  const processFiles = createProcessFiles();
+  const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+  const jsEntries = /* @__PURE__ */ new Map();
+  const entries = [];
+  const firstRun = state.linkedByEntry.size === 0;
+  for (const [file, output] of Object.entries(bundle)) {
+    const type = classifyBundleEntry(file, opts);
+    const source = readEntrySource(output);
+    const hash = opts.cache.computeHash(source);
+    sourceHashByFile.set(file, hash);
+    const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+    runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+    const runtimeAffectingHash = opts.cache.computeHash(runtimeAffectingSignature);
+    runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+    const previousHash = state.sourceHashByFile.get(file);
+    const changed = previousHash == null || previousHash !== hash;
+    if (changed) {
+      changedByType[type].add(file);
+    }
+    const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+    const runtimeAffectingChanged = previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash;
+    if (runtimeAffectingChanged) {
+      runtimeAffectingChangedByType[type].add(file);
+    }
+    if (forceAll || firstRun) {
+      markProcessFile(type, file, processFiles);
+    } else if (type === "html") {
+      processFiles.html.add(file);
+    } else if (changed && (type === "js" || type === "css")) {
+      processFiles[type].add(file);
+    }
+    collectJsEntries(file, output, outDir, jsEntries);
+    entries.push({
+      file,
+      output,
+      source,
+      type
+    });
+  }
+  if (!forceAll && !firstRun) {
+    for (const changedFile of changedByType.js) {
+      const dependents = state.dependentsByLinkedFile.get(changedFile);
+      if (!dependents) {
+        continue;
+      }
+      for (const entryFile of dependents) {
+        processFiles.js.add(entryFile);
+        let impacts = linkedImpactsByEntry.get(entryFile);
+        if (!impacts) {
+          impacts = /* @__PURE__ */ new Set();
+          linkedImpactsByEntry.set(entryFile, impacts);
+        }
+        impacts.add(changedFile);
+      }
+    }
+  }
+  return {
+    entries,
+    jsEntries,
+    sourceHashByFile,
+    runtimeAffectingSignatureByFile,
+    runtimeAffectingHashByFile,
+    changedByType,
+    runtimeAffectingChangedByType,
+    processFiles,
+    linkedImpactsByEntry
+  };
+}
+function buildBundleSnapshotForBuild(bundle, opts, outDir) {
+  const processFiles = createProcessFiles();
+  const jsEntries = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const [file, output] of Object.entries(bundle)) {
+    const type = classifyBundleEntry(file, opts);
+    const source = readEntrySource(output);
+    markProcessFile(type, file, processFiles);
+    collectJsEntries(file, output, outDir, jsEntries);
+    entries.push({
+      file,
+      output,
+      source,
+      type
+    });
+  }
+  return {
+    entries,
+    jsEntries,
+    sourceHashByFile: /* @__PURE__ */ new Map(),
+    runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+    runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+    changedByType: createChangedByType(),
+    runtimeAffectingChangedByType: createChangedByType(),
+    processFiles,
+    linkedImpactsByEntry: /* @__PURE__ */ new Map()
+  };
+}
+function invertLinkedByEntry(linkedByEntry) {
+  const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+  for (const [entryFile, linkedFiles] of linkedByEntry.entries()) {
+    for (const linkedFile of linkedFiles) {
+      let dependents = dependentsByLinkedFile.get(linkedFile);
+      if (!dependents) {
+        dependents = /* @__PURE__ */ new Set();
+        dependentsByLinkedFile.set(linkedFile, dependents);
+      }
+      dependents.add(entryFile);
+    }
+  }
+  return dependentsByLinkedFile;
+}
+function updateBundleBuildState(state, snapshot, linkedByEntry) {
+  state.iteration += 1;
+  state.sourceHashByFile = snapshot.sourceHashByFile;
+  state.runtimeAffectingHashByFile = snapshot.runtimeAffectingHashByFile;
+  state.linkedByEntry = linkedByEntry;
+  state.dependentsByLinkedFile = invertLinkedByEntry(linkedByEntry);
+}
+
+// src/bundlers/vite/js-precheck.ts
+var FAST_JS_TRANSFORM_HINT_RE = /className\b|class\s*=|classList\.|\b(?:twMerge|clsx|classnames|cn|cva)\b|\[["'`]class["'`]\]|text-\[|bg-\[|\b(?:[whpm]|px|py|mx|my|rounded|flex|grid|gap)-/;
+var DEPENDENCY_HINT_RE = /\bimport\s*[("'`{*]|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
+function shouldSkipViteJsTransform(rawSource, options) {
+  if (!rawSource) {
+    return true;
+  }
+  if (options?.alwaysEscape) {
+    return false;
+  }
+  if (options?.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) {
+    return false;
+  }
+  if (options?.wrapExpression) {
+    return false;
+  }
+  if (DEPENDENCY_HINT_RE.test(rawSource)) {
+    return false;
+  }
+  return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+}
+
+// src/bundlers/vite/generate-bundle.ts
+function formatDebugFileList(files, limit = 8) {
+  if (files.size === 0) {
+    return "-";
+  }
+  const sorted = [...files].sort();
+  if (sorted.length <= limit) {
+    return sorted.join(",");
+  }
+  return `${sorted.slice(0, limit).join(",")},...(+${sorted.length - limit})`;
+}
+function createEmptyMetric() {
+  return {
+    total: 0,
+    transformed: 0,
+    cacheHits: 0,
+    elapsed: 0
+  };
+}
+function createEmptyMetrics() {
+  return {
+    runtimeSet: 0,
+    html: createEmptyMetric(),
+    js: createEmptyMetric(),
+    css: createEmptyMetric()
+  };
+}
+function measureElapsed(start) {
+  return performance.now() - start;
+}
+function formatCacheHitRate(metric) {
+  if (metric.total === 0) {
+    return "0.00%";
+  }
+  return `${(metric.cacheHits / metric.total * 100).toFixed(2)}%`;
+}
+function formatMs(value) {
+  return value.toFixed(2);
+}
+function summarizeStringDiff(previous, next) {
+  if (previous === next) {
+    return "same";
+  }
+  const previousLength = previous.length;
+  const nextLength = next.length;
+  const minLength = Math.min(previousLength, nextLength);
+  let prefixLength = 0;
+  while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) {
+    prefixLength += 1;
+  }
+  let previousSuffixCursor = previousLength - 1;
+  let nextSuffixCursor = nextLength - 1;
+  while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+    previousSuffixCursor -= 1;
+    nextSuffixCursor -= 1;
+  }
+  const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+  const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+  return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+  const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+  if (!changedLinkedFiles || changedLinkedFiles.size === 0) {
+    return void 0;
+  }
+  const parts = [...changedLinkedFiles].sort().map((file) => {
+    const hash = sourceHashByFile.get(file) ?? "missing";
+    return `${file}:${hash}`;
+  });
+  return parts.join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+  if (!linkedImpactSignature) {
+    return runtimeSignature;
+  }
+  return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
+function hasRuntimeAffectingSourceChanges(changedByType) {
+  return changedByType.html.size > 0 || changedByType.js.size > 0;
+}
+function canShareCssTransformResult(rawSource) {
+  return !rawSource.includes("@import") && !rawSource.includes("url(");
+}
+function createGenerateBundleHook(context) {
+  const state = createBundleBuildState();
+  const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+  return async function generateBundle(_opt, bundle) {
+    const {
+      opts,
+      runtimeState,
+      ensureBundleRuntimeClassSet,
+      debug: debug3,
+      getResolvedConfig
+    } = context;
+    const {
+      appType,
+      cache,
+      mainCssChunkMatcher,
+      onEnd,
+      onStart,
+      onUpdate,
+      styleHandler,
+      templateHandler,
+      jsHandler,
+      uniAppX
+    } = opts;
+    const getCssHandlerOptions = (file) => {
+      const majorVersion = runtimeState.twPatcher.majorVersion;
+      const isMainChunk = mainCssChunkMatcher(file, appType);
+      const cacheKey = `${majorVersion ?? "unknown"}:${isMainChunk ? "1" : "0"}:${file}`;
+      const cached = cssHandlerOptionsCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const created = {
+        isMainChunk,
+        postcssOptions: {
+          options: {
+            from: file
+          }
+        },
+        majorVersion
+      };
+      cssHandlerOptionsCache.set(cacheKey, created);
+      return created;
+    };
+    await runtimeState.patchPromise;
+    debug3("start");
+    onStart();
+    const metrics = createEmptyMetrics();
+    const forceRuntimeRefreshByEnv = process2.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    const disableDirtyOptimization = process2.env.WEAPP_TW_VITE_DISABLE_DIRTY === "1";
+    const disableJsPrecheck = process2.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
+    const debugCssDiff = process2.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
+    const resolvedConfig = getResolvedConfig();
+    const useIncrementalMode = resolvedConfig?.command !== "build";
+    const rootDir = resolvedConfig?.root ? path2.resolve(resolvedConfig.root) : process2.cwd();
+    const outDir = resolvedConfig?.build?.outDir ? path2.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
+    const snapshot = useIncrementalMode ? buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization) : buildBundleSnapshotForBuild(bundle, opts, outDir);
+    const useBundleRuntimeClassSet = useIncrementalMode || runtimeState.twPatcher.majorVersion === 4;
+    const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
+    const processFiles = snapshot.processFiles;
+    if (useIncrementalMode) {
+      debug3(
+        "dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]",
+        state.iteration + 1,
+        snapshot.changedByType.html.size,
+        formatDebugFileList(snapshot.changedByType.html),
+        snapshot.changedByType.js.size,
+        formatDebugFileList(snapshot.changedByType.js),
+        snapshot.changedByType.css.size,
+        formatDebugFileList(snapshot.changedByType.css),
+        snapshot.changedByType.other.size,
+        formatDebugFileList(snapshot.changedByType.other)
+      );
+      debug3(
+        "process iteration=%d html=%d[%s] js=%d[%s] css=%d[%s]",
+        state.iteration + 1,
+        processFiles.html.size,
+        formatDebugFileList(processFiles.html),
+        processFiles.js.size,
+        formatDebugFileList(processFiles.js),
+        processFiles.css.size,
+        formatDebugFileList(processFiles.css)
+      );
+    } else {
+      debug3(
+        "build mode full process html=%d[%s] js=%d[%s] css=%d[%s]",
+        processFiles.html.size,
+        formatDebugFileList(processFiles.html),
+        processFiles.js.size,
+        formatDebugFileList(processFiles.js),
+        processFiles.css.size,
+        formatDebugFileList(processFiles.css)
+      );
+    }
+    const jsEntries = snapshot.jsEntries;
+    const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
+    const runtimeStart = performance.now();
+    const runtime = useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv) : await context.ensureRuntimeClassSet(forceRuntimeRefreshByEnv);
+    const defaultTemplateHandlerOptions = {
+      runtimeSet: runtime
+    };
+    metrics.runtimeSet = measureElapsed(runtimeStart);
+    if (forceRuntimeRefreshBySource) {
+      debug3(
+        "runtimeSet forced refresh due to source changes: html=%d js=%d",
+        snapshot.runtimeAffectingChangedByType.html.size,
+        snapshot.runtimeAffectingChangedByType.js.size
+      );
+    }
+    debug3("get runtimeSet, class count: %d", runtime.size);
+    const runtimeSignature = getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
+    const handleLinkedUpdate = (fileName, previous, next) => {
+      onUpdate(fileName, previous, next);
+      debug3("js linked handle: %s", fileName);
+    };
+    const pendingLinkedUpdates = [];
+    const scheduleLinkedApply = (entry, code) => {
+      pendingLinkedUpdates.push(() => {
+        if (entry.output.type === "chunk") {
+          entry.output.code = code;
+        } else {
+          entry.output.source = code;
+        }
+      });
+    };
+    const applyLinkedUpdates = (linked) => {
+      applyLinkedResults(linked, jsEntries, handleLinkedUpdate, scheduleLinkedApply);
+    };
+    const createHandlerOptions = (absoluteFilename, extra) => ({
+      ...extra,
+      filename: absoluteFilename,
+      tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
+      moduleGraph: moduleGraphOptions,
+      babelParserOptions: {
+        ...extra?.babelParserOptions ?? {},
+        sourceFilename: absoluteFilename
+      }
+    });
+    const linkedByEntry = useIncrementalMode ? /* @__PURE__ */ new Map() : void 0;
+    const sharedCssResultCache = /* @__PURE__ */ new Map();
+    const tasks = [];
+    const jsTaskFactories = [];
+    for (const entry of snapshot.entries) {
+      const { file, output: originalSource, source: originalEntrySource, type } = entry;
+      if (type === "html" && originalSource.type === "asset") {
+        metrics.html.total++;
+        if (!processFiles.html.has(file)) {
+          continue;
+        }
+        const rawSource = originalEntrySource;
+        tasks.push(
+          processCachedTask({
+            cache,
+            cacheKey: file,
+            rawSource,
+            hashKey: `${file}:html:${runtimeSignature}`,
+            applyResult(source) {
+              originalSource.source = source;
+            },
+            onCacheHit() {
+              metrics.html.cacheHits++;
+              debug3("html cache hit: %s", file);
+            },
+            async transform() {
+              const start = performance.now();
+              const transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
+              metrics.html.elapsed += measureElapsed(start);
+              metrics.html.transformed++;
+              onUpdate(file, rawSource, transformed);
+              debug3("html handle: %s", file);
+              return {
+                result: transformed
+              };
+            }
+          })
+        );
+        continue;
+      }
+      if (type === "css" && originalSource.type === "asset") {
+        metrics.css.total++;
+        const rawSource = originalEntrySource;
+        const cssRuntimeAffectingSignature = snapshot.runtimeAffectingSignatureByFile.get(file) ?? rawSource;
+        const shareCssResult = canShareCssTransformResult(rawSource);
+        const cssSharedCacheKey = shareCssResult ? `${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${getCssHandlerOptions(file).isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}` : void 0;
+        tasks.push(
+          processCachedTask({
+            cache,
+            cacheKey: file,
+            hashKey: `${file}:css:${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
+            rawSource: cssRuntimeAffectingSignature,
+            applyResult(source) {
+              originalSource.source = source;
+            },
+            onCacheHit() {
+              metrics.css.cacheHits++;
+              debug3("css cache hit: %s", file);
+            },
+            async transform() {
+              if (cssSharedCacheKey) {
+                const sharedCssTask = sharedCssResultCache.get(cssSharedCacheKey);
+                if (sharedCssTask != null) {
+                  metrics.css.cacheHits++;
+                  debug3("css shared hit: %s", file);
+                  const sharedCss = await sharedCssTask;
+                  onUpdate(file, rawSource, sharedCss);
+                  return {
+                    result: sharedCss
+                  };
+                }
+              }
+              const runTransform = async () => {
+                const start = performance.now();
+                await runtimeState.patchPromise;
+                const { css: css2 } = await styleHandler(rawSource, getCssHandlerOptions(file));
+                if (debugCssDiff) {
+                  debug3("css diff %s: %s", file, summarizeStringDiff(rawSource, css2));
+                }
+                metrics.css.elapsed += measureElapsed(start);
+                metrics.css.transformed++;
+                return css2;
+              };
+              const cssTask = cssSharedCacheKey ? sharedCssResultCache.get(cssSharedCacheKey) ?? runTransform() : runTransform();
+              if (cssSharedCacheKey && !sharedCssResultCache.has(cssSharedCacheKey)) {
+                sharedCssResultCache.set(cssSharedCacheKey, cssTask);
+              }
+              const css = await cssTask;
+              onUpdate(file, rawSource, css);
+              debug3("css handle: %s", file);
+              return {
+                result: css
+              };
+            }
+          })
+        );
+        continue;
+      }
+      if (type !== "js") {
+        continue;
+      }
+      metrics.js.total++;
+      const shouldTransformJs = !useIncrementalMode || processFiles.js.has(file);
+      if (!shouldTransformJs) {
+        debug3("js skip transform (clean), replay cache: %s", file);
+      }
+      if (originalSource.type === "chunk") {
+        const absoluteFile = path2.resolve(outDir, file);
+        const initialRawSource = originalEntrySource;
+        const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+        if (linkedByEntry && linkedSet) {
+          linkedByEntry.set(file, linkedSet);
+        }
+        jsTaskFactories.push(async () => {
+          const linkedImpactSignature = useIncrementalMode ? createLinkedImpactSignature(
+            file,
+            snapshot.linkedImpactsByEntry,
+            snapshot.sourceHashByFile
+          ) : void 0;
+          const hashSalt = createJsHashSalt(runtimeSignature, linkedImpactSignature);
+          await processCachedTask({
+            cache,
+            cacheKey: file,
+            hashKey: `${file}:js`,
+            rawSource: `${initialRawSource}
+/*${hashSalt}*/`,
+            applyResult(source) {
+              originalSource.code = source;
+            },
+            onCacheHit() {
+              metrics.js.cacheHits++;
+              debug3("js cache hit: %s", file);
+            },
+            async transform() {
+              const start = performance.now();
+              const rawSource = originalSource.code;
+              if (!shouldTransformJs) {
+                debug3("js cache replay miss, fallback transform: %s", file);
+              }
+              const handlerOptions = createHandlerOptions(absoluteFile);
+              if (!disableJsPrecheck && shouldSkipViteJsTransform(rawSource, handlerOptions)) {
+                metrics.js.elapsed += measureElapsed(start);
+                metrics.js.transformed++;
+                return {
+                  result: rawSource
+                };
+              }
+              const { code, linked } = await jsHandler(rawSource, runtime, handlerOptions);
+              metrics.js.elapsed += measureElapsed(start);
+              metrics.js.transformed++;
+              onUpdate(file, rawSource, code);
+              debug3("js handle: %s", file);
+              if (linked) {
+                for (const id of Object.keys(linked)) {
+                  const linkedEntry = jsEntries.get(id);
+                  if (linkedEntry && linkedSet) {
+                    linkedSet.add(linkedEntry.fileName);
+                  }
+                }
+              }
+              applyLinkedUpdates(linked);
+              return {
+                result: code
+              };
+            }
+          });
+        });
+      } else if (uniAppX && originalSource.type === "asset") {
+        const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+        if (linkedByEntry && linkedSet) {
+          linkedByEntry.set(file, linkedSet);
+        }
+        const baseApplyLinkedUpdates = applyLinkedUpdates;
+        const wrappedApplyLinkedUpdates = (linked) => {
+          if (linked) {
+            for (const id of Object.keys(linked)) {
+              const linkedEntry = jsEntries.get(id);
+              if (linkedEntry && linkedSet) {
+                linkedSet.add(linkedEntry.fileName);
+              }
+            }
+          }
+          baseApplyLinkedUpdates(linked);
+        };
+        const factory = createUniAppXAssetTask(
+          file,
+          originalSource,
+          outDir,
+          {
+            cache,
+            hashKey: `${file}:js`,
+            hashSalt: createJsHashSalt(
+              runtimeSignature,
+              useIncrementalMode ? createLinkedImpactSignature(
+                file,
+                snapshot.linkedImpactsByEntry,
+                snapshot.sourceHashByFile
+              ) : void 0
+            ),
+            createHandlerOptions,
+            debug: debug3,
+            jsHandler,
+            onUpdate,
+            runtimeSet: runtime,
+            applyLinkedResults: wrappedApplyLinkedUpdates,
+            uniAppX
+          }
+        );
+        jsTaskFactories.push(async () => {
+          const start = performance.now();
+          if (!shouldTransformJs) {
+            debug3("js skip transform (clean, uni-app-x), replay cache: %s", file);
+            await factory();
+            metrics.js.elapsed += measureElapsed(start);
+            metrics.js.transformed++;
+            return;
+          }
+          const currentSource = originalEntrySource;
+          const absoluteFile = path2.resolve(outDir, file);
+          const precheckOptions = createHandlerOptions(absoluteFile, {
+            uniAppX: uniAppX ?? true,
+            babelParserOptions: {
+              plugins: ["typescript"],
+              sourceType: "unambiguous"
+            }
+          });
+          if (!disableJsPrecheck && shouldSkipViteJsTransform(currentSource, precheckOptions)) {
+            metrics.js.elapsed += measureElapsed(start);
+            metrics.js.transformed++;
+            return;
+          }
+          await factory();
+          metrics.js.elapsed += measureElapsed(start);
+          metrics.js.transformed++;
+        });
+      }
+    }
+    pushConcurrentTaskFactories(tasks, jsTaskFactories);
+    await Promise.all(tasks);
+    for (const apply of pendingLinkedUpdates) {
+      apply();
+    }
+    if (useIncrementalMode) {
+      updateBundleBuildState(state, snapshot, linkedByEntry ?? /* @__PURE__ */ new Map());
+    }
+    debug3(
+      "metrics iteration=%d runtime=%sms html(total=%d transform=%d hit=%d rate=%s elapsed=%sms) js(total=%d transform=%d hit=%d rate=%s elapsed=%sms) css(total=%d transform=%d hit=%d rate=%s elapsed=%sms)",
+      useIncrementalMode ? state.iteration : 0,
+      formatMs(metrics.runtimeSet),
+      metrics.html.total,
+      metrics.html.transformed,
+      metrics.html.cacheHits,
+      formatCacheHitRate(metrics.html),
+      formatMs(metrics.html.elapsed),
+      metrics.js.total,
+      metrics.js.transformed,
+      metrics.js.cacheHits,
+      formatCacheHitRate(metrics.js),
+      formatMs(metrics.js.elapsed),
+      metrics.css.total,
+      metrics.css.transformed,
+      metrics.css.cacheHits,
+      formatCacheHitRate(metrics.css),
+      formatMs(metrics.css.elapsed)
+    );
+    onEnd();
+    debug3("end");
+  };
+}
+
+// src/bundlers/vite/incremental-runtime-class-set.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import path3 from "path";
+import process3 from "process";
+import { extractRawCandidatesWithPositions, extractValidCandidates } from "tailwindcss-patch";
+var debug = createDebug("[vite:runtime-set] ");
+var require2 = createRequire(import.meta.url);
+var EXTENSION_DOT_PREFIX_RE = /^\./;
+var VALIDATION_FILE_NAME = "runtime-candidates.html";
+var tailwindNodeModulePromise;
+function toPosixPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function createCssImportSource(imports) {
+  return imports.map((value) => `@import "${toPosixPath(value)}";`).join("\n");
+}
+function isPostcssPluginImportTarget(value) {
+  if (!value) {
+    return false;
+  }
+  return value === "@tailwindcss/postcss" || value === "@tailwindcss/postcss7-compat" || value.includes("/postcss");
+}
+function resolveTailwindCssImportTarget(patcher) {
+  const tailwindOptions = patcher.options?.tailwind;
+  const cssEntries = tailwindOptions?.v4?.cssEntries?.filter((item) => typeof item === "string" && item.length > 0);
+  if (cssEntries && cssEntries.length > 0) {
+    return createCssImportSource(cssEntries);
+  }
+  const configuredPackageName = tailwindOptions?.packageName;
+  if (typeof configuredPackageName === "string" && configuredPackageName.length > 0 && !isPostcssPluginImportTarget(configuredPackageName)) {
+    return createCssImportSource([configuredPackageName]);
+  }
+  const packageName = patcher.packageInfo?.name;
+  if (typeof packageName === "string" && packageName.length > 0 && !isPostcssPluginImportTarget(packageName)) {
+    return createCssImportSource([packageName]);
+  }
+  return createCssImportSource(["tailwindcss"]);
+}
+function getProjectRoot(patcher) {
+  return patcher.options?.projectRoot ?? process3.cwd();
+}
+async function importTailwindNodeModule() {
+  if (!tailwindNodeModulePromise) {
+    tailwindNodeModulePromise = (async () => {
+      try {
+        const resolved = require2.resolve("@tailwindcss/node");
+        return await import(resolved);
+      } catch {
+        const tailwindcssPatchEntry = require2.resolve("tailwindcss-patch");
+        const resolved = require2.resolve("@tailwindcss/node", {
+          paths: [path3.dirname(tailwindcssPatchEntry)]
+        });
+        return await import(resolved);
+      }
+    })();
+  }
+  return tailwindNodeModulePromise;
+}
+function resolveMaybeAbsolute(base, value) {
+  if (!value) {
+    return void 0;
+  }
+  return path3.isAbsolute(value) ? value : path3.resolve(base, value);
+}
+async function resolveTailwindCssSource(patcher) {
+  const projectRoot = getProjectRoot(patcher);
+  const tailwindOptions = patcher.options?.tailwind;
+  const configuredBase = resolveMaybeAbsolute(projectRoot, tailwindOptions?.v4?.base);
+  const configDir = tailwindOptions?.config ? path3.dirname(tailwindOptions.config) : void 0;
+  const sharedFallbacks = [
+    configuredBase,
+    projectRoot,
+    tailwindOptions?.cwd,
+    configDir
+  ].filter((item) => typeof item === "string" && item.length > 0);
+  if (tailwindOptions?.v4?.css) {
+    return {
+      projectRoot,
+      base: configuredBase ?? projectRoot,
+      baseFallbacks: [...new Set(sharedFallbacks)],
+      css: tailwindOptions.v4.css
+    };
+  }
+  const cssEntries = tailwindOptions?.v4?.cssEntries?.filter((item) => typeof item === "string" && item.length > 0) ?? [];
+  if (cssEntries.length > 0) {
+    const resolvedEntries = cssEntries.map((entry) => resolveMaybeAbsolute(projectRoot, entry) ?? entry);
+    const cssChunks = [];
+    const entryDirs = [];
+    for (const entry of resolvedEntries) {
+      try {
+        cssChunks.push(await readFile(entry, "utf8"));
+        entryDirs.push(path3.dirname(entry));
+      } catch {
+      }
+    }
+    if (cssChunks.length > 0) {
+      const base = entryDirs[0] ?? configuredBase ?? projectRoot;
+      const baseFallbacks = [...new Set([
+        ...entryDirs.slice(1),
+        ...sharedFallbacks
+      ].filter((item) => typeof item === "string" && item.length > 0 && item !== base))];
+      return {
+        projectRoot,
+        base,
+        baseFallbacks,
+        css: cssChunks.join("\n")
+      };
+    }
+  }
+  return {
+    projectRoot,
+    base: configuredBase ?? projectRoot,
+    baseFallbacks: [...new Set(sharedFallbacks)],
+    css: resolveTailwindCssImportTarget(patcher)
+  };
+}
+function createExtractOptions(context, tempRoot, pattern) {
+  return {
+    cwd: context.projectRoot,
+    base: context.base,
+    baseFallbacks: context.baseFallbacks,
+    css: context.css,
+    sources: [{
+      base: tempRoot,
+      pattern,
+      negated: false
+    }]
+  };
+}
+function createRuntimeEntries(snapshot) {
+  return snapshot.entries.filter((entry) => entry.type === "html" || entry.type === "js");
+}
+function collectChangedRuntimeFiles(snapshot) {
+  return /* @__PURE__ */ new Set([
+    ...snapshot.runtimeAffectingChangedByType.html,
+    ...snapshot.runtimeAffectingChangedByType.js
+  ]);
+}
+async function writeTempEntryFile(tempRoot, file, source) {
+  const absoluteFile = path3.join(tempRoot, file);
+  await mkdir(path3.dirname(absoluteFile), { recursive: true });
+  await writeFile(absoluteFile, source, "utf8");
+  return file;
+}
+function resolveEntryExtension(entry) {
+  const ext = path3.extname(entry.file).replace(EXTENSION_DOT_PREFIX_RE, "");
+  if (ext.length > 0) {
+    return ext;
+  }
+  return entry.type === "html" ? "html" : "js";
+}
+function createCandidateValidationSource(candidates) {
+  return [...new Set(candidates)].sort().join("\n");
+}
+function removeCandidateSet(candidateCountByClass, runtimeSet, candidates) {
+  for (const className of candidates) {
+    const count = candidateCountByClass.get(className);
+    if (count == null) {
+      continue;
+    }
+    if (count <= 1) {
+      candidateCountByClass.delete(className);
+      runtimeSet.delete(className);
+      continue;
+    }
+    candidateCountByClass.set(className, count - 1);
+  }
+}
+function addCandidateSet(candidateCountByClass, runtimeSet, candidates) {
+  for (const className of candidates) {
+    const nextCount = (candidateCountByClass.get(className) ?? 0) + 1;
+    candidateCountByClass.set(className, nextCount);
+    runtimeSet.add(className);
+  }
+}
+function createBundleRuntimeClassSetManager(options = {}) {
+  const customExtractCandidates = options.extractCandidates;
+  const extractCandidates = customExtractCandidates ?? extractValidCandidates;
+  const extractRawCandidates = options.extractRawCandidates ?? extractRawCandidatesWithPositions;
+  const runtimeSet = /* @__PURE__ */ new Set();
+  const candidateCountByClass = /* @__PURE__ */ new Map();
+  const candidatesByFile = /* @__PURE__ */ new Map();
+  const candidateValidityCache = /* @__PURE__ */ new Map();
+  let runtimeSignature;
+  let resolvedTempRoot;
+  let validationContext;
+  let designSystemPromise;
+  async function reset() {
+    runtimeSet.clear();
+    candidateCountByClass.clear();
+    candidatesByFile.clear();
+    candidateValidityCache.clear();
+    runtimeSignature = void 0;
+    validationContext = void 0;
+    designSystemPromise = void 0;
+    if (resolvedTempRoot) {
+      await rm(resolvedTempRoot, { recursive: true, force: true });
+      resolvedTempRoot = void 0;
+    }
+  }
+  async function resolveValidationContextCached(patcher) {
+    if (!validationContext) {
+      validationContext = await resolveTailwindCssSource(patcher);
+    }
+    return validationContext;
+  }
+  async function loadDesignSystem(context) {
+    if (!designSystemPromise) {
+      designSystemPromise = (async () => {
+        const { __unstable__loadDesignSystem } = await importTailwindNodeModule();
+        let lastError;
+        for (const base of [context.base, ...context.baseFallbacks]) {
+          try {
+            return await __unstable__loadDesignSystem(context.css, { base });
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        throw lastError instanceof Error ? lastError : new Error("Failed to load Tailwind CSS design system for incremental runtime validation.");
+      })();
+    }
+    return designSystemPromise;
+  }
+  function populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates) {
+    const parsedCandidates = [...unknownCandidates].filter((candidate) => designSystem.parseCandidate(candidate).length > 0);
+    const cssByCandidate = parsedCandidates.length > 0 ? designSystem.candidatesToCss(parsedCandidates) : [];
+    const validCandidates = /* @__PURE__ */ new Set();
+    for (let index = 0; index < parsedCandidates.length; index += 1) {
+      const candidate = parsedCandidates[index];
+      const css = cssByCandidate[index];
+      if (candidate && typeof css === "string" && css.trim().length > 0) {
+        validCandidates.add(candidate);
+      }
+    }
+    for (const candidate of unknownCandidates) {
+      candidateValidityCache.set(candidate, validCandidates.has(candidate));
+    }
+  }
+  async function validateUnknownCandidates(patcher, tempRoot, unknownCandidates) {
+    if (unknownCandidates.size === 0) {
+      return;
+    }
+    const context = await resolveValidationContextCached(patcher);
+    if (!customExtractCandidates) {
+      try {
+        const designSystem = await loadDesignSystem(context);
+        populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates);
+        return;
+      } catch (error) {
+        debug("incremental design-system validation failed, fallback to extractValidCandidates: %O", error);
+        designSystemPromise = void 0;
+      }
+    }
+    const source = createCandidateValidationSource(unknownCandidates);
+    const pattern = await writeTempEntryFile(tempRoot, VALIDATION_FILE_NAME, source);
+    const validCandidates = new Set(await extractCandidates(createExtractOptions(context, tempRoot, pattern)));
+    for (const candidate of unknownCandidates) {
+      candidateValidityCache.set(candidate, validCandidates.has(candidate));
+    }
+  }
+  async function extractEntryRawCandidates(entry) {
+    const matches = await extractRawCandidates(entry.source, resolveEntryExtension(entry));
+    const candidates = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      const candidate = match?.rawCandidate;
+      if (typeof candidate === "string" && candidate.length > 0) {
+        candidates.add(candidate);
+      }
+    }
+    return candidates;
+  }
+  async function sync(patcher, snapshot) {
+    const nextSignature = getRuntimeClassSetSignature(patcher) ?? "runtime:missing";
+    const runtimeEntries = createRuntimeEntries(snapshot);
+    const runtimeEntriesByFile = new Map(runtimeEntries.map((entry) => [entry.file, entry]));
+    const currentRuntimeFiles = new Set(runtimeEntriesByFile.keys());
+    const fullRebuild = runtimeSignature !== nextSignature || candidatesByFile.size === 0;
+    if (runtimeSignature !== nextSignature) {
+      debug("runtime signature changed, reset incremental runtime set: %s", nextSignature);
+      await reset();
+    }
+    runtimeSignature = nextSignature;
+    const projectRoot = getProjectRoot(patcher);
+    resolvedTempRoot = options.tempRoot ?? path3.join(
+      projectRoot,
+      "node_modules",
+      ".cache",
+      "weapp-tailwindcss",
+      "vite-runtime-set"
+    );
+    for (const [file, previousCandidates] of candidatesByFile) {
+      if (currentRuntimeFiles.has(file)) {
+        continue;
+      }
+      removeCandidateSet(candidateCountByClass, runtimeSet, previousCandidates);
+      candidatesByFile.delete(file);
+    }
+    const changedRuntimeFiles = fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
+    if (changedRuntimeFiles.length === 0) {
+      return new Set(runtimeSet);
+    }
+    const rawCandidatesByFile = /* @__PURE__ */ new Map();
+    const unknownCandidates = /* @__PURE__ */ new Set();
+    await Promise.all(changedRuntimeFiles.map(async (file) => {
+      const entry = runtimeEntriesByFile.get(file);
+      if (!entry) {
+        return;
+      }
+      const candidates = await extractEntryRawCandidates(entry);
+      rawCandidatesByFile.set(file, candidates);
+      for (const candidate of candidates) {
+        if (!candidateValidityCache.has(candidate)) {
+          unknownCandidates.add(candidate);
+        }
+      }
+    }));
+    await validateUnknownCandidates(patcher, resolvedTempRoot, unknownCandidates);
+    let rawCandidateCount = 0;
+    for (const file of changedRuntimeFiles) {
+      const nextRawCandidates = rawCandidatesByFile.get(file);
+      const previousCandidates = candidatesByFile.get(file);
+      if (previousCandidates) {
+        removeCandidateSet(candidateCountByClass, runtimeSet, previousCandidates);
+      }
+      if (!nextRawCandidates || nextRawCandidates.size === 0) {
+        candidatesByFile.delete(file);
+        continue;
+      }
+      rawCandidateCount += nextRawCandidates.size;
+      const nextCandidates = new Set(
+        [...nextRawCandidates].filter((candidate) => candidateValidityCache.get(candidate) === true)
+      );
+      if (nextCandidates.size === 0) {
+        candidatesByFile.delete(file);
+        continue;
+      }
+      addCandidateSet(candidateCountByClass, runtimeSet, nextCandidates);
+      candidatesByFile.set(file, nextCandidates);
+    }
+    debug(
+      "incremental runtime set synced, changedFiles=%d rawCandidates=%d validateMisses=%d runtimeSize=%d trackedFiles=%d",
+      changedRuntimeFiles.length,
+      rawCandidateCount,
+      unknownCandidates.size,
+      runtimeSet.size,
+      candidatesByFile.size
+    );
+    return new Set(runtimeSet);
+  }
+  return {
+    sync,
+    reset
+  };
+}
+
+// src/bundlers/vite/rewrite-css-imports.ts
+function joinPosixPath(base, subpath) {
+  if (base.endsWith("/")) {
+    return `${base}${subpath}`;
+  }
+  return `${base}/${subpath}`;
+}
+function isCssLikeImporter(importer) {
+  if (!importer) {
+    return false;
+  }
+  const normalized = cleanUrl(importer);
+  return isCSSRequest(normalized);
+}
+function createRewriteCssImportsPlugins(options) {
+  if (!options.shouldRewrite) {
+    return [];
+  }
+  const { appType, weappTailwindcssDirPosix: weappTailwindcssDirPosix2 } = options;
+  return [
+    {
+      name: `${vitePluginName}:rewrite-css-imports`,
+      enforce: "pre",
+      resolveId: {
+        order: "pre",
+        handler(id, importer) {
+          const replacement = resolveTailwindcssImport(id, weappTailwindcssDirPosix2, {
+            join: joinPosixPath,
+            appType
+          });
+          if (!replacement) {
+            return null;
+          }
+          if (importer && !isCssLikeImporter(importer)) {
+            return null;
+          }
+          return replacement;
+        }
+      },
+      transform: {
+        order: "pre",
+        handler(code, id) {
+          if (!isCSSRequest(id)) {
+            return null;
+          }
+          const rewritten = rewriteTailwindcssImportsInCode(code, weappTailwindcssDirPosix2, {
+            join: joinPosixPath,
+            appType
+          });
+          if (!rewritten) {
+            return null;
+          }
+          return {
+            code: rewritten,
+            map: null
+          };
+        }
+      }
+    }
+  ];
+}
+
+// src/bundlers/vite/index.ts
+var debug2 = createDebug();
+var weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
+var weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
+var PACKAGE_JSON_FILE = "package.json";
+function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
+  const resolvedRoot = path4.resolve(root);
+  if (!existsSync(resolvedRoot)) {
+    return resolvedRoot;
+  }
+  const searchRoots = [];
+  let current = resolvedRoot;
+  while (true) {
+    searchRoots.push(current);
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const tailwindConfigPath = findTailwindConfig(searchRoots);
+  if (tailwindConfigPath) {
+    return path4.dirname(tailwindConfigPath);
+  }
+  const packageRoot = findNearestPackageRoot(resolvedRoot);
+  if (packageRoot && existsSync(path4.join(packageRoot, PACKAGE_JSON_FILE))) {
+    return packageRoot;
+  }
+  return resolvedRoot;
+}
+function UnifiedViteWeappTailwindcssPlugin(options = {}) {
+  const rewriteCssImportsSpecified = Object.hasOwn(options, "rewriteCssImports");
+  const hasExplicitTailwindcssBasedir = typeof options.tailwindcssBasedir === "string" && options.tailwindcssBasedir.trim().length > 0;
+  const opts = getCompilerContext(options);
+  const {
+    disabled,
+    customAttributes,
+    onLoad,
+    mainCssChunkMatcher,
+    appType,
+    styleHandler,
+    jsHandler,
+    twPatcher: initialTwPatcher,
+    refreshTailwindcssPatcher,
+    uniAppX,
+    disabledDefaultTemplateHandler
+  } = opts;
+  const disabledOptions = resolveDisabledOptions(disabled);
+  const tailwindcssMajorVersion = initialTwPatcher.majorVersion ?? 0;
+  const shouldRewriteCssImports = opts.rewriteCssImports !== false && !disabledOptions.rewriteCssImports && (rewriteCssImportsSpecified || tailwindcssMajorVersion >= 4);
+  const rewritePlugins = createRewriteCssImportsPlugins({
+    appType,
+    shouldRewrite: shouldRewriteCssImports,
+    weappTailwindcssDirPosix
+  });
+  if (disabledOptions.plugin) {
+    return rewritePlugins.length ? rewritePlugins : void 0;
+  }
+  const customAttributesEntities = toCustomAttributesEntities(customAttributes);
+  const patchRecorderState = setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
+    source: "runtime",
+    cwd: opts.tailwindcssBasedir ?? process4.cwd()
+  });
+  const runtimeState = {
+    twPatcher: initialTwPatcher,
+    patchPromise: patchRecorderState.patchPromise,
+    refreshTailwindcssPatcher,
+    onPatchCompleted: patchRecorderState.onPatchCompleted
+  };
+  let runtimeSet;
+  let runtimeSetPromise;
+  let resolvedConfig;
+  let runtimeRefreshSignature;
+  let runtimeRefreshOptionsKey;
+  const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager();
+  function resolveRuntimeRefreshOptions() {
+    const configPath = runtimeState.twPatcher.options?.tailwind?.config;
+    const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
+    const optionsKey = JSON.stringify({
+      appType,
+      uniAppX: Boolean(uniAppX),
+      customAttributesEntities,
+      disabledDefaultTemplateHandler,
+      configPath,
+      rewriteCssImports: shouldRewriteCssImports
+    });
+    const changed = signature !== runtimeRefreshSignature || optionsKey !== runtimeRefreshOptionsKey;
+    runtimeRefreshSignature = signature;
+    runtimeRefreshOptionsKey = optionsKey;
+    return {
+      changed,
+      signature,
+      optionsKey
+    };
+  }
+  async function refreshRuntimeState(force) {
+    const invalidation = resolveRuntimeRefreshOptions();
+    const shouldRefresh = force || invalidation.changed;
+    const refreshed = await refreshTailwindRuntimeState(runtimeState, {
+      force: shouldRefresh,
+      clearCache: force || invalidation.changed
+    });
+    if (invalidation.changed) {
+      debug2("runtime signature changed, refresh triggered. signature: %s", invalidation.signature);
+    }
+    if (refreshed) {
+      runtimeSet = void 0;
+      runtimeSetPromise = void 0;
+    }
+  }
+  async function ensureRuntimeClassSet(force = false) {
+    const forceRuntimeRefresh = force || process4.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    await refreshRuntimeState(force);
+    await runtimeState.patchPromise;
+    if (!forceRuntimeRefresh && runtimeSet) {
+      return runtimeSet;
+    }
+    if (forceRuntimeRefresh || !runtimeSetPromise) {
+      const invalidation = resolveRuntimeRefreshOptions();
+      const task2 = collectRuntimeClassSet(runtimeState.twPatcher, {
+        force: forceRuntimeRefresh || invalidation.changed,
+        skipRefresh: forceRuntimeRefresh,
+        clearCache: forceRuntimeRefresh || invalidation.changed
+      });
+      runtimeSetPromise = task2;
+    }
+    const task = runtimeSetPromise;
+    try {
+      runtimeSet = await task;
+      return runtimeSet;
+    } finally {
+      if (runtimeSetPromise === task) {
+        runtimeSetPromise = void 0;
+      }
+    }
+  }
+  async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false) {
+    const forceRuntimeRefresh = forceRefresh || process4.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    const invalidation = resolveRuntimeRefreshOptions();
+    const shouldRefreshPatcher = forceRuntimeRefresh || invalidation.changed;
+    const forceCollectBySource = snapshot.runtimeAffectingChangedByType.html.size > 0 || snapshot.runtimeAffectingChangedByType.js.size > 0;
+    await refreshRuntimeState(shouldRefreshPatcher);
+    await runtimeState.patchPromise;
+    if (shouldRefreshPatcher) {
+      runtimeSet = void 0;
+      runtimeSetPromise = void 0;
+      await bundleRuntimeClassSetManager.reset();
+    }
+    if (runtimeState.twPatcher.majorVersion === 4 && !forceRuntimeRefresh) {
+      try {
+        const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+        runtimeSet = nextRuntimeSet;
+        return nextRuntimeSet;
+      } catch (error) {
+        debug2("incremental runtime set sync failed, fallback to full collect: %O", error);
+        await bundleRuntimeClassSetManager.reset();
+      }
+    }
+    if (!forceRuntimeRefresh && !invalidation.changed && !forceCollectBySource && runtimeSet) {
+      return runtimeSet;
+    }
+    const task = collectRuntimeClassSet(runtimeState.twPatcher, {
+      force: forceRuntimeRefresh || invalidation.changed || forceCollectBySource,
+      skipRefresh: forceRuntimeRefresh,
+      clearCache: forceRuntimeRefresh || invalidation.changed
+    });
+    runtimeSetPromise = task;
+    try {
+      runtimeSet = await task;
+      return runtimeSet;
+    } finally {
+      if (runtimeSetPromise === task) {
+        runtimeSetPromise = void 0;
+      }
+    }
+  }
+  onLoad();
+  const getResolvedConfig = () => resolvedConfig;
+  const utsPlatform = resolveUniUtsPlatform();
+  const isIosPlatform = utsPlatform.isAppIos;
+  const uniAppXPlugins = uniAppX ? createUniAppXPlugins({
+    appType,
+    customAttributesEntities,
+    disabledDefaultTemplateHandler,
+    isIosPlatform,
+    mainCssChunkMatcher,
+    runtimeState,
+    styleHandler,
+    jsHandler,
+    ensureRuntimeClassSet,
+    getResolvedConfig
+  }) : void 0;
+  const plugins = [
+    ...rewritePlugins,
+    {
+      name: `${vitePluginName}:post`,
+      enforce: "post",
+      async configResolved(config) {
+        resolvedConfig = config;
+        const resolvedRoot = config.root ? path4.resolve(config.root) : void 0;
+        if (!hasExplicitTailwindcssBasedir && resolvedRoot) {
+          const nextTailwindcssBasedir = resolveImplicitTailwindcssBasedirFromViteRoot(resolvedRoot);
+          if (opts.tailwindcssBasedir !== nextTailwindcssBasedir) {
+            const previousBasedir = opts.tailwindcssBasedir;
+            opts.tailwindcssBasedir = nextTailwindcssBasedir;
+            debug2(
+              "align tailwindcss basedir with vite root: %s -> %s",
+              previousBasedir ?? "undefined",
+              nextTailwindcssBasedir
+            );
+            await refreshRuntimeState(true);
+          }
+        }
+        if (typeof config.css.postcss === "object" && Array.isArray(config.css.postcss.plugins)) {
+          const postcssPlugins = config.css.postcss.plugins;
+          const idx = postcssPlugins.findIndex((x) => (
+            // @ts-ignore
+            x.postcssPlugin === "postcss-html-transform"
+          ));
+          if (idx > -1) {
+            postcssPlugins.splice(idx, 1, postcssHtmlTransform());
+            debug2("remove postcss-html-transform plugin from vite config");
+          }
+        }
+      },
+      generateBundle: createGenerateBundleHook({
+        opts,
+        runtimeState,
+        ensureRuntimeClassSet,
+        ensureBundleRuntimeClassSet,
+        debug: debug2,
+        getResolvedConfig
+      })
+    }
+  ];
+  if (uniAppXPlugins) {
+    plugins.push(...uniAppXPlugins);
+  }
+  return plugins;
+}
+
+export {
+  UnifiedViteWeappTailwindcssPlugin
+};