weapp-tailwindcss 4.12.0 → 5.0.0-next.2

package/dist/chunk-5ZYHNDEK.mjs

@@ -1,2439 +0,0 @@
-import {
-  normalizeOutputPathKey,
-  pushConcurrentTaskFactories,
-  resolveDisabledOptions,
-  resolveOutputSpecifier,
-  resolvePackageDir,
-  resolveTailwindcssImport,
-  rewriteTailwindcssImportsInCode,
-  toAbsoluteOutputPath
-} from "./chunk-3VQKDHGP.mjs";
-import {
-  processCachedTask
-} from "./chunk-76S2EME4.mjs";
-import {
-  JsTokenUpdater,
-  analyzeSource,
-  babelParse,
-  collectRuntimeClassSet,
-  createAttributeMatcher,
-  createDebug,
-  generateCode,
-  getCompilerContext,
-  isClassContextLiteralPath,
-  refreshTailwindRuntimeState,
-  replaceWxml,
-  setupPatchRecorder,
-  shouldSkipJsTransform,
-  toCustomAttributesEntities,
-  traverse,
-  vitePluginName
-} from "./chunk-KGTVD4EP.mjs";
-import {
-  findNearestPackageRoot,
-  findTailwindConfig,
-  getRuntimeClassSetSignature,
-  isUniAppXEnabled,
-  logger,
-  resolveTailwindcssOptions,
-  resolveUniAppXOptions
-} from "./chunk-PCDYXXSK.mjs";
-import {
-  resolveUniUtsPlatform
-} from "./chunk-OOHJLO5M.mjs";
-
-// src/bundlers/vite/index.ts
-import { existsSync as existsSync2 } from "fs";
-import path6 from "path";
-import process4 from "process";
-import { logger as logger3 } from "@weapp-tailwindcss/logger";
-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 MagicString2 from "magic-string";
-
-// src/uni-app-x/component-local-style.ts
-import { splitCode } from "@weapp-tailwindcss/shared/extractors";
-import MagicString from "magic-string";
-var EXPRESSION_WRAPPER_PREFIX = "(\n";
-var EXPRESSION_WRAPPER_SUFFIX = "\n)";
-var COMPONENT_RE = /(?:^|[/\\])components(?:[/\\].+)?\.(?:uvue|nvue)$/;
-function createStableHash(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-function extractLiteralValue(path7) {
-  const allowDoubleQuotes = path7.isTemplateElement();
-  if (path7.isStringLiteral()) {
-    return {
-      allowDoubleQuotes,
-      literal: path7.node.value,
-      offset: 1
-    };
-  }
-  return {
-    allowDoubleQuotes,
-    literal: typeof path7.node.value === "string" ? path7.node.value : path7.node.value.raw,
-    offset: 0
-  };
-}
-function createAlias(fileId, utility, index) {
-  return `wtu-${createStableHash(`${fileId}:${utility}`)}-${index.toString(36)}`;
-}
-function isRuntimeCandidate(candidate, runtimeSet) {
-  if (!runtimeSet || runtimeSet.size === 0) {
-    return false;
-  }
-  return runtimeSet.has(candidate) || runtimeSet.has(replaceWxml(candidate));
-}
-function shouldEnableComponentLocalStyle(id) {
-  return COMPONENT_RE.test(id);
-}
-var UniAppXComponentLocalStyleCollector = class {
-  constructor(fileId, runtimeSet) {
-    this.fileId = fileId;
-    this.runtimeSet = runtimeSet;
-    this.aliasByUtility = /* @__PURE__ */ new Map();
-    this.aliasByLookup = /* @__PURE__ */ new Map();
-  }
-  ensureAlias(utility) {
-    const cached = this.aliasByUtility.get(utility);
-    if (cached) {
-      return cached;
-    }
-    const alias = createAlias(this.fileId, utility, this.aliasByUtility.size);
-    this.aliasByUtility.set(utility, alias);
-    this.aliasByLookup.set(utility, alias);
-    this.aliasByLookup.set(replaceWxml(utility), alias);
-    return alias;
-  }
-  rewriteLiteral(literal, shouldInclude) {
-    const candidates = splitCode(literal);
-    if (candidates.length === 0) {
-      return literal;
-    }
-    let rewritten = literal;
-    for (const candidate of candidates) {
-      if (!shouldInclude(candidate)) {
-        continue;
-      }
-      rewritten = rewritten.replace(candidate, this.ensureAlias(candidate));
-    }
-    return rewritten;
-  }
-  collectAndRewriteStaticClass(literal) {
-    return this.rewriteLiteral(literal, (candidate) => isRuntimeCandidate(candidate, this.runtimeSet));
-  }
-  collectRuntimeClasses(rawSource, options = {}) {
-    const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
-    try {
-      const ast = babelParse(wrapped, {
-        plugins: ["typescript"],
-        sourceType: options.wrapExpression ? "module" : "unambiguous"
-      });
-      const analysis = analyzeSource(ast, {}, void 0, false);
-      for (const path7 of analysis.targetPaths) {
-        const { literal, allowDoubleQuotes } = extractLiteralValue(path7);
-        const candidates = splitCode(literal, allowDoubleQuotes);
-        const classContext = options.wrapExpression || isClassContextLiteralPath(path7);
-        for (const candidate of candidates) {
-          if (!candidate || !classContext && !isRuntimeCandidate(candidate, this.runtimeSet)) {
-            continue;
-          }
-          if (isRuntimeCandidate(candidate, this.runtimeSet)) {
-            this.ensureAlias(candidate);
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  rewriteTransformedCode(rawSource, options = {}) {
-    if (this.aliasByLookup.size === 0) {
-      return rawSource;
-    }
-    const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
-    try {
-      const ast = babelParse(wrapped, {
-        plugins: ["typescript"],
-        sourceType: options.wrapExpression ? "module" : "unambiguous"
-      });
-      const analysis = analyzeSource(ast, {}, void 0, false);
-      if (analysis.targetPaths.length === 0) {
-        return rawSource;
-      }
-      const updater = new JsTokenUpdater();
-      for (const path7 of analysis.targetPaths) {
-        const { literal, allowDoubleQuotes, offset } = extractLiteralValue(path7);
-        const candidates = splitCode(literal, allowDoubleQuotes);
-        if (candidates.length === 0) {
-          continue;
-        }
-        let rewritten = literal;
-        let mutated = false;
-        for (const candidate of candidates) {
-          const alias = this.aliasByLookup.get(candidate);
-          if (!alias) {
-            continue;
-          }
-          const replaced = rewritten.replace(candidate, alias);
-          if (replaced !== rewritten) {
-            rewritten = replaced;
-            mutated = true;
-          }
-        }
-        if (!mutated || typeof path7.node.start !== "number" || typeof path7.node.end !== "number") {
-          continue;
-        }
-        updater.addToken({
-          start: path7.node.start + offset,
-          end: path7.node.end - offset,
-          value: rewritten,
-          path: path7
-        });
-      }
-      if (updater.length === 0) {
-        return rawSource;
-      }
-      const ms = new MagicString(wrapped);
-      updater.updateMagicString(ms);
-      if (options.wrapExpression) {
-        ms.remove(0, EXPRESSION_WRAPPER_PREFIX.length);
-        ms.remove(wrapped.length - EXPRESSION_WRAPPER_SUFFIX.length, wrapped.length);
-      }
-      return ms.toString();
-    } catch {
-      return rawSource;
-    }
-  }
-  hasStyles() {
-    return this.aliasByUtility.size > 0;
-  }
-  toStyleBlock() {
-    if (!this.hasStyles()) {
-      return "";
-    }
-    const lines = ["<style scoped>"];
-    for (const [utility, alias] of this.aliasByUtility) {
-      lines.push(`.${alias} {`);
-      lines.push(`  @apply ${utility};`);
-      lines.push("}");
-    }
-    lines.push("</style>");
-    return `${lines.join("\n")}
-`;
-  }
-};
-
-// src/uni-app-x/transform.ts
-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, content = prop.value?.content) {
-  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(content ?? ""));
-  }
-}
-function updateStaticAttributeWithLocalStyle(ms, prop, collector, content = prop.value?.content) {
-  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, collector.collectAndRewriteStaticClass(content ?? ""));
-  }
-}
-function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
-  if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) {
-    return;
-  }
-  const expression = prop.exp.content;
-  const start = prop.exp.loc.start.offset;
-  const end = prop.exp.loc.end.offset;
-  if (start >= end) {
-    return;
-  }
-  const generated = generateCode(expression, {
-    jsHandler,
-    runtimeSet,
-    wrapExpression: true
-  });
-  ms.update(start, end, generated);
-}
-function updateDirectiveExpressionWithLocalStyle(ms, prop, jsHandler, collector, runtimeSet) {
-  if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) {
-    return;
-  }
-  const expression = prop.exp.content;
-  const start = prop.exp.loc.start.offset;
-  const end = prop.exp.loc.end.offset;
-  if (start >= end) {
-    return;
-  }
-  collector.collectRuntimeClasses(expression, {
-    wrapExpression: true
-  });
-  const generated = generateCode(expression, {
-    jsHandler,
-    runtimeSet,
-    wrapExpression: true
-  });
-  ms.update(start, end, collector.rewriteTransformedCode(generated, { wrapExpression: true }));
-}
-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 MagicString2(code);
-  const { descriptor, errors } = parse(code);
-  const localStyleCollector = options.enableComponentLocalStyle && shouldEnableComponentLocalStyle(id) ? new UniAppXComponentLocalStyleCollector(id, runtimeSet) : void 0;
-  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;
-            }
-            if (shouldHandleDefault && localStyleCollector) {
-              updateStaticAttributeWithLocalStyle(ms, prop, localStyleCollector);
-            } else {
-              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;
-            }
-            if (attrName.toLowerCase() === "class" && localStyleCollector) {
-              updateDirectiveExpressionWithLocalStyle(
-                ms,
-                prop,
-                jsHandler,
-                localStyleCollector,
-                runtimeSet
-              );
-            } else {
-              updateDirectiveExpression(ms, prop, jsHandler, runtimeSet);
-            }
-          }
-        }
-      });
-    }
-    if (descriptor.script) {
-      localStyleCollector?.collectRuntimeClasses(descriptor.script.content);
-      const { code: code2 } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
-      ms.update(
-        descriptor.script.loc.start.offset,
-        descriptor.script.loc.end.offset,
-        localStyleCollector ? localStyleCollector.rewriteTransformedCode(code2) : code2
-      );
-    }
-    if (descriptor.scriptSetup) {
-      localStyleCollector?.collectRuntimeClasses(descriptor.scriptSetup.content);
-      const { code: code2 } = jsHandler(descriptor.scriptSetup.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
-      ms.update(
-        descriptor.scriptSetup.loc.start.offset,
-        descriptor.scriptSetup.loc.end.offset,
-        localStyleCollector ? localStyleCollector.rewriteTransformedCode(code2) : code2
-      );
-    }
-    if (localStyleCollector?.hasStyles()) {
-      ms.append(`
-${localStyleCollector.toStyleBlock()}`);
-    }
-  }
-  const result = {
-    code: ms.toString(),
-    map: null
-  };
-  Object.defineProperty(result, "map", {
-    configurable: true,
-    enumerable: true,
-    get() {
-      return ms.generateMap();
-    }
-  });
-  return result;
-}
-
-// 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/style-isolation.ts
-import fs from "fs";
-import path2 from "path";
-import { parse as parse2 } from "comment-json";
-var manifestCache = /* @__PURE__ */ new Map();
-function resolveUniAppXStyleIsolationEnabled(root) {
-  if (!root) {
-    return false;
-  }
-  const normalizedRoot = path2.resolve(root);
-  const cached = manifestCache.get(normalizedRoot);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const manifestPath = path2.join(normalizedRoot, "manifest.json");
-  let enabled = false;
-  try {
-    const raw = fs.readFileSync(manifestPath, "utf8");
-    const manifest = parse2(raw);
-    enabled = `${manifest["uni-app-x"]?.styleIsolationVersion ?? ""}` === "2";
-  } catch {
-    enabled = false;
-  }
-  manifestCache.set(normalizedRoot, enabled);
-  return enabled;
-}
-
-// 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 resolveUniAppXCssTarget(id) {
-  return UVUE_NVUE_RE2.test(cleanUrl(id)) ? "uvue" : void 0;
-}
-function resolveUniAppXJsTransformEnabled(uniAppX) {
-  return uniAppX === void 0 ? true : isUniAppXEnabled(uniAppX);
-}
-function createUniAppXPlugins(options) {
-  const {
-    appType,
-    customAttributesEntities,
-    disabledDefaultTemplateHandler,
-    isIosPlatform: providedIosPlatform,
-    mainCssChunkMatcher,
-    runtimeState,
-    styleHandler,
-    jsHandler,
-    ensureRuntimeClassSet,
-    getResolvedConfig,
-    uniAppX
-  } = options;
-  const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
-  const isIosPlatform = providedIosPlatform ?? resolveUniUtsPlatform().isAppIos;
-  const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
-  let componentLocalStyleEnabled;
-  function shouldEnableComponentLocalStyle2() {
-    if (!resolvedUniAppXOptions.componentLocalStyles.enabled) {
-      componentLocalStyleEnabled = false;
-      return false;
-    }
-    if (!resolvedUniAppXOptions.componentLocalStyles.onlyWhenStyleIsolationVersion2) {
-      componentLocalStyleEnabled = true;
-      return true;
-    }
-    if (componentLocalStyleEnabled !== void 0) {
-      return componentLocalStyleEnabled;
-    }
-    const root = getResolvedConfig()?.root;
-    componentLocalStyleEnabled = resolveUniAppXStyleIsolationEnabled(root);
-    return componentLocalStyleEnabled;
-  }
-  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),
-          uniAppXCssTarget: resolveUniAppXCssTarget(id),
-          uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
-          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 warnings = typeof postcssResult.warnings === "function" ? postcssResult.warnings() : [];
-      for (const warning of warnings) {
-        logger.warn(warning.toString());
-      }
-      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,
-        enableComponentLocalStyle: shouldEnableComponentLocalStyle2()
-      } : void 0;
-      if (extraOptions) {
-        return transformUVue(code, id, jsHandler, currentRuntimeSet, extraOptions);
-      }
-      if (shouldEnableComponentLocalStyle2()) {
-        return transformUVue(code, id, jsHandler, currentRuntimeSet, {
-          enableComponentLocalStyle: true
-        });
-      }
-      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: resolveUniAppXJsTransformEnabled(options.uniAppX),
-          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 path3 from "path";
-import process2 from "process";
-import { logger as logger2 } from "@weapp-tailwindcss/logger";
-import { splitCode as splitCode2 } from "@weapp-tailwindcss/shared/extractors";
-
-// 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) {
-  const normalizedEntries = /* @__PURE__ */ new Map();
-  for (const [id, entry] of entries) {
-    normalizedEntries.set(normalizeOutputPathKey(id), entry);
-  }
-  const getEntry = (id) => entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
-  return {
-    resolve(specifier, importer) {
-      return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => Boolean(getEntry(candidate)));
-    },
-    load(id) {
-      const entry = getEntry(id);
-      if (!entry) {
-        return void 0;
-      }
-      return readOutputEntry(entry);
-    },
-    filter(id) {
-      return Boolean(getEntry(id));
-    }
-  };
-}
-function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
-  if (!linked) {
-    return;
-  }
-  const normalizedEntries = /* @__PURE__ */ new Map();
-  for (const [entryId, entry] of entries) {
-    normalizedEntries.set(normalizeOutputPathKey(entryId), entry);
-  }
-  for (const [id, { code }] of Object.entries(linked)) {
-    const entry = entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(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(path7) {
-        parts.push(`s:${path7.node.value}`);
-      },
-      TemplateElement(path7) {
-        parts.push(`t:${path7.node.value.raw}`);
-      },
-      JSXText(path7) {
-        const value = path7.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(),
-    runtimeAffectingSignatureByFile: /* @__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 previousHash = state.sourceHashByFile.get(file);
-    const changed = previousHash == null || previousHash !== hash;
-    const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
-    const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
-    const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
-    const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
-    const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
-    runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
-    runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
-    if (changed) {
-      changedByType[type].add(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 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, options = {}) {
-  const incremental = options.incremental === true;
-  state.iteration += 1;
-  state.sourceHashByFile = incremental ? new Map([
-    ...state.sourceHashByFile,
-    ...snapshot.sourceHashByFile
-  ]) : snapshot.sourceHashByFile;
-  state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
-  state.runtimeAffectingHashByFile = incremental ? new Map([
-    ...state.runtimeAffectingHashByFile,
-    ...snapshot.runtimeAffectingHashByFile
-  ]) : snapshot.runtimeAffectingHashByFile;
-  state.linkedByEntry = incremental ? new Map([
-    ...state.linkedByEntry,
-    ...linkedByEntry
-  ]) : linkedByEntry;
-  state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
-}
-
-// 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 resolveUniAppXJsTransformEnabled2(uniAppX) {
-  return uniAppX === void 0 ? true : isUniAppXEnabled(uniAppX);
-}
-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 getSnapshotHash(snapshotMap, file, fallback) {
-  return snapshotMap.get(file) ?? fallback;
-}
-function hasRuntimeAffectingSourceChanges(changedByType) {
-  return changedByType.html.size > 0 || changedByType.js.size > 0;
-}
-var CSS_URL_FUNCTION_RE = /url\((?:"([^"]*)"|'([^']*)'|([^)]*))\)/gi;
-var CSS_PATH_INDEPENDENT_URL_RE = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/|#)/i;
-var CSS_IMPORT_RE = /@import\b/i;
-function isPathIndependentCssUrl(value) {
-  const normalized = value.trim();
-  return normalized.length > 0 && CSS_PATH_INDEPENDENT_URL_RE.test(normalized);
-}
-function hasPathDependentCssUrl(rawSource) {
-  CSS_URL_FUNCTION_RE.lastIndex = 0;
-  let match = CSS_URL_FUNCTION_RE.exec(rawSource);
-  while (match !== null) {
-    const value = match[1] ?? match[2] ?? match[3] ?? "";
-    if (!isPathIndependentCssUrl(value)) {
-      return true;
-    }
-    match = CSS_URL_FUNCTION_RE.exec(rawSource);
-  }
-  return false;
-}
-function createCssTransformShareScope(file, rawSource) {
-  if (CSS_IMPORT_RE.test(rawSource) || hasPathDependentCssUrl(rawSource)) {
-    return `dir:${normalizeOutputPathKey(path3.dirname(file))}`;
-  }
-  return "global";
-}
-function hasOmittedKnownBundleFiles(currentBundleFiles, previousBundleFiles) {
-  const currentFileSet = new Set(currentBundleFiles);
-  for (const file of previousBundleFiles) {
-    if (!currentFileSet.has(file)) {
-      return true;
-    }
-  }
-  return false;
-}
-var MUSTACHE_EXPRESSION_RE = /\{\{[\s\S]*?\}\}/g;
-var QUOTED_LITERAL_RE = /'([^']*)'|"([^"]*)"|`([^`]*)`/g;
-function isArbitraryValueCandidate(candidate) {
-  return candidate.includes("[") && candidate.includes("]");
-}
-function collectUnescapedDynamicCandidates(source) {
-  const matches = /* @__PURE__ */ new Set();
-  for (const expression of source.match(MUSTACHE_EXPRESSION_RE) ?? []) {
-    QUOTED_LITERAL_RE.lastIndex = 0;
-    let quoted = QUOTED_LITERAL_RE.exec(expression);
-    while (quoted !== null) {
-      const literal = quoted[1] ?? quoted[2] ?? quoted[3] ?? "";
-      for (const candidate of splitCode2(literal, true)) {
-        const normalized = candidate.trim();
-        if (!normalized || !isArbitraryValueCandidate(normalized)) {
-          continue;
-        }
-        matches.add(normalized);
-      }
-      quoted = QUOTED_LITERAL_RE.exec(expression);
-    }
-  }
-  return [...matches];
-}
-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 bundleFiles = Object.keys(bundle);
-    const buildCommand = resolvedConfig?.command === "build";
-    const useIncrementalMode = !buildCommand || hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
-    const rootDir = resolvedConfig?.root ? path3.resolve(resolvedConfig.root) : process2.cwd();
-    const outDir = resolvedConfig?.build?.outDir ? path3.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
-    const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization || !useIncrementalMode);
-    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 normalizedJsEntries = /* @__PURE__ */ new Map();
-    for (const [id, entry] of jsEntries) {
-      normalizedJsEntries.set(normalizeOutputPathKey(id), entry);
-    }
-    const getJsEntry = (id) => jsEntries.get(id) ?? normalizedJsEntries.get(normalizeOutputPathKey(id));
-    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,
-            hashKey: `${file}:html:${runtimeSignature}`,
-            hash: getSnapshotHash(snapshot.sourceHashByFile, file, rawSource),
-            applyResult(source) {
-              originalSource.source = source;
-            },
-            onCacheHit() {
-              metrics.html.cacheHits++;
-              debug3("html cache hit: %s", file);
-            },
-            async transform() {
-              const start = performance.now();
-              let transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
-              let unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
-              if (unresolvedDynamicCandidates.length > 0) {
-                logger2.warn(
-                  "\u68C0\u6D4B\u5230 WXML \u52A8\u6001\u7C7B\u540D\u672A\u5B8C\u6210\u8F6C\u8BD1\uFF0C\u5DF2\u56DE\u9000\u5230\u5B8C\u6574 runtimeSet \u91CD\u8BD5: %s -> %O",
-                  file,
-                  unresolvedDynamicCandidates
-                );
-                const fullRuntimeSet = await context.ensureRuntimeClassSet(true);
-                transformed = await templateHandler(rawSource, {
-                  runtimeSet: fullRuntimeSet
-                });
-                unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
-                if (unresolvedDynamicCandidates.length > 0) {
-                  logger2.warn(
-                    "WXML \u52A8\u6001\u7C7B\u540D\u5728\u5B8C\u6574 runtimeSet \u91CD\u8BD5\u540E\u4ECD\u672A\u5B8C\u6210\u8F6C\u8BD1: %s -> %O",
-                    file,
-                    unresolvedDynamicCandidates
-                  );
-                }
-              }
-              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 cssShareScope = createCssTransformShareScope(file, rawSource);
-        const cssHandlerOptions = getCssHandlerOptions(file);
-        const cssSharedCacheKey = `${cssShareScope}:${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}`;
-        tasks.push(
-          processCachedTask({
-            cache,
-            cacheKey: file,
-            hashKey: `${file}:css:${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
-            hash: getSnapshotHash(snapshot.runtimeAffectingHashByFile, file, 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 = path3.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`,
-            hash: `${getSnapshotHash(snapshot.sourceHashByFile, file, 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 && shouldSkipJsTransform(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 = getJsEntry(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 = getJsEntry(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 = path3.resolve(outDir, file);
-          const precheckOptions = createHandlerOptions(absoluteFile, {
-            uniAppX: resolveUniAppXJsTransformEnabled2(uniAppX),
-            babelParserOptions: {
-              plugins: ["typescript"],
-              sourceType: "unambiguous"
-            }
-          });
-          if (!disableJsPrecheck && shouldSkipJsTransform(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();
-    }
-    updateBundleBuildState(
-      state,
-      snapshot,
-      useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(),
-      { incremental: useIncrementalMode }
-    );
-    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 path4 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 = resolveTailwindcssOptions(patcher.options);
-  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: [path4.dirname(tailwindcssPatchEntry)]
-        });
-        return await import(resolved);
-      }
-    })();
-  }
-  return tailwindNodeModulePromise;
-}
-function resolveMaybeAbsolute(base, value) {
-  if (!value) {
-    return void 0;
-  }
-  return path4.isAbsolute(value) ? value : path4.resolve(base, value);
-}
-async function resolveTailwindCssSource(patcher) {
-  const projectRoot = getProjectRoot(patcher);
-  const tailwindOptions = resolveTailwindcssOptions(patcher.options);
-  const configuredBase = resolveMaybeAbsolute(projectRoot, tailwindOptions?.v4?.base);
-  const configDir = tailwindOptions?.config ? path4.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(path4.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 = path4.join(tempRoot, file);
-  await mkdir(path4.dirname(absoluteFile), { recursive: true });
-  await writeFile(absoluteFile, source, "utf8");
-  return file;
-}
-function resolveEntryExtension(entry) {
-  const ext = path4.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 ?? path4.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/resolve-app-type.ts
-import { existsSync, readFileSync } from "fs";
-import path5 from "path";
-var PACKAGE_JSON_FILE = "package.json";
-var MPX_SCRIPT_RE = /\bmpx(?:-cli-service)?\b/u;
-var TARO_SCRIPT_RE = /\btaro\b/u;
-var TAILWINDCSS_VITE_MARKERS = [
-  ["src/app.mpx", "mpx"],
-  ["app.mpx", "mpx"]
-];
-function resolveDependencyNames(pkg) {
-  return /* @__PURE__ */ new Set([
-    ...Object.keys(pkg.dependencies ?? {}),
-    ...Object.keys(pkg.devDependencies ?? {}),
-    ...Object.keys(pkg.peerDependencies ?? {}),
-    ...Object.keys(pkg.optionalDependencies ?? {})
-  ]);
-}
-function hasScriptMatch(pkg, pattern) {
-  return Object.values(pkg.scripts ?? {}).some((script) => pattern.test(script));
-}
-function resolveAppTypeFromPackageJson(pkg) {
-  const dependencyNames = resolveDependencyNames(pkg);
-  if (dependencyNames.has("weapp-vite") || [...dependencyNames].some((name) => name.startsWith("@weapp-vite/"))) {
-    return "weapp-vite";
-  }
-  if ([...dependencyNames].some((name) => name.startsWith("@mpxjs/")) || hasScriptMatch(pkg, MPX_SCRIPT_RE)) {
-    return "mpx";
-  }
-  if ([...dependencyNames].some((name) => name.startsWith("@tarojs/")) || hasScriptMatch(pkg, TARO_SCRIPT_RE)) {
-    return "taro";
-  }
-  if (dependencyNames.has("@dcloudio/vite-plugin-uni")) {
-    return "uni-app-vite";
-  }
-  if (dependencyNames.has("@dcloudio/vue-cli-plugin-uni") || dependencyNames.has("@dcloudio/uni-app") || Object.hasOwn(pkg, "uni-app")) {
-    return "uni-app";
-  }
-}
-function tryReadUniAppManifest(root) {
-  const manifestPath = path5.join(root, "manifest.json");
-  if (!existsSync(manifestPath)) {
-    return;
-  }
-  try {
-    return JSON.parse(readFileSync(manifestPath, "utf8"));
-  } catch {
-  }
-}
-function tryReadPackageJson(root) {
-  const packageJsonPath = path5.join(root, PACKAGE_JSON_FILE);
-  if (!existsSync(packageJsonPath)) {
-    return;
-  }
-  try {
-    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  } catch {
-  }
-}
-function resolveAppTypeFromMarkers(root) {
-  for (const [relativePath, appType] of TAILWINDCSS_VITE_MARKERS) {
-    if (existsSync(path5.join(root, relativePath))) {
-      return appType;
-    }
-  }
-}
-function resolveImplicitAppTypeFromViteRoot(root) {
-  const resolvedRoot = path5.resolve(root);
-  if (!existsSync(resolvedRoot)) {
-    return;
-  }
-  const markerDetected = resolveAppTypeFromMarkers(resolvedRoot);
-  if (markerDetected) {
-    return markerDetected;
-  }
-  let current = resolvedRoot;
-  while (true) {
-    const manifest = tryReadUniAppManifest(current);
-    if (manifest && Object.hasOwn(manifest, "uni-app-x")) {
-      return "uni-app-x";
-    }
-    const pkg = tryReadPackageJson(current);
-    if (pkg) {
-      const detected = resolveAppTypeFromPackageJson(pkg);
-      if (detected) {
-        return detected;
-      }
-    }
-    const parent = path5.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-}
-
-// 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, getAppType, weappTailwindcssDirPosix: weappTailwindcssDirPosix2 } = options;
-  const resolveAppType = () => getAppType?.() ?? appType;
-  return [
-    {
-      name: `${vitePluginName}:rewrite-css-imports`,
-      enforce: "pre",
-      resolveId: {
-        order: "pre",
-        handler(id, importer) {
-          const replacement = resolveTailwindcssImport(id, weappTailwindcssDirPosix2, {
-            join: joinPosixPath,
-            appType: resolveAppType()
-          });
-          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: resolveAppType()
-          });
-          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_FILE2 = "package.json";
-function getPostcssPluginName(plugin) {
-  if (!plugin || typeof plugin !== "object" || !("postcssPlugin" in plugin)) {
-    return;
-  }
-  const { postcssPlugin } = plugin;
-  return typeof postcssPlugin === "string" ? postcssPlugin : void 0;
-}
-function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
-  const resolvedRoot = path6.resolve(root);
-  if (!existsSync2(resolvedRoot)) {
-    return resolvedRoot;
-  }
-  const searchRoots = [];
-  let current = resolvedRoot;
-  while (true) {
-    searchRoots.push(current);
-    const parent = path6.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  const tailwindConfigPath = findTailwindConfig(searchRoots);
-  if (tailwindConfigPath) {
-    return path6.dirname(tailwindConfigPath);
-  }
-  const packageRoot = findNearestPackageRoot(resolvedRoot);
-  if (packageRoot && existsSync2(path6.join(packageRoot, PACKAGE_JSON_FILE2))) {
-    return packageRoot;
-  }
-  return resolvedRoot;
-}
-function UnifiedViteWeappTailwindcssPlugin(options = {}) {
-  const hasExplicitAppType = typeof options.appType === "string" && options.appType.trim().length > 0;
-  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,
-    styleHandler,
-    jsHandler,
-    twPatcher: initialTwPatcher,
-    refreshTailwindcssPatcher,
-    uniAppX,
-    disabledDefaultTemplateHandler
-  } = opts;
-  const uniAppXEnabled = isUniAppXEnabled(uniAppX);
-  const disabledOptions = resolveDisabledOptions(disabled);
-  const tailwindcssMajorVersion = initialTwPatcher.majorVersion ?? 0;
-  const shouldRewriteCssImports = opts.rewriteCssImports !== false && !disabledOptions.rewriteCssImports && (rewriteCssImportsSpecified || tailwindcssMajorVersion >= 4);
-  const rewritePlugins = createRewriteCssImportsPlugins({
-    getAppType: () => opts.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 = resolveTailwindcssOptions(runtimeState.twPatcher.options)?.config;
-    const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
-    const optionsKey = JSON.stringify({
-      appType: opts.appType,
-      uniAppX: uniAppXEnabled,
-      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 = uniAppXEnabled ? createUniAppXPlugins({
-    appType: opts.appType ?? "uni-app-x",
-    customAttributesEntities,
-    disabledDefaultTemplateHandler,
-    isIosPlatform,
-    mainCssChunkMatcher,
-    runtimeState,
-    styleHandler,
-    jsHandler,
-    ensureRuntimeClassSet,
-    getResolvedConfig,
-    uniAppX
-  }) : void 0;
-  const plugins = [
-    ...rewritePlugins,
-    {
-      name: `${vitePluginName}:post`,
-      enforce: "post",
-      async configResolved(config) {
-        resolvedConfig = config;
-        const resolvedRoot = config.root ? path6.resolve(config.root) : void 0;
-        let shouldRefreshRuntime = false;
-        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
-            );
-            shouldRefreshRuntime = true;
-          }
-        }
-        if (!hasExplicitAppType && resolvedRoot) {
-          const nextAppType = resolveImplicitAppTypeFromViteRoot(resolvedRoot);
-          if (nextAppType && opts.appType !== nextAppType) {
-            const previousAppType = opts.appType;
-            opts.appType = nextAppType;
-            logger3.info("\u6839\u636E Vite \u9879\u76EE\u6839\u76EE\u5F55\u81EA\u52A8\u63A8\u65AD appType -> %s", nextAppType);
-            debug2(
-              "align appType with vite root: %s -> %s",
-              previousAppType ?? "undefined",
-              nextAppType
-            );
-            shouldRefreshRuntime = true;
-          }
-        }
-        if (shouldRefreshRuntime) {
-          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) => getPostcssPluginName(x) === "postcss-html-transform");
-          if (idx > -1) {
-            postcssPlugins.splice(idx, 1, postcssHtmlTransform());
-            debug2("remove postcss-html-transform plugin from vite config");
-          }
-        }
-      },
-      generateBundle: {
-        order: "post",
-        handler: createGenerateBundleHook({
-          opts,
-          runtimeState,
-          ensureRuntimeClassSet,
-          ensureBundleRuntimeClassSet,
-          debug: debug2,
-          getResolvedConfig
-        })
-      }
-    }
-  ];
-  if (uniAppXPlugins) {
-    plugins.push(...uniAppXPlugins);
-  }
-  return plugins;
-}
-
-export {
-  UnifiedViteWeappTailwindcssPlugin
-};