weapp-tailwindcss 4.12.0 → 5.0.0-next.2

package/dist/chunk-KGTVD4EP.mjs

@@ -1,3930 +0,0 @@
-import {
-  applyV4CssCalcDefaults,
-  createTailwindcssPatcherFromContext,
-  findNearestPackageRoot,
-  getRuntimeClassSetCacheEntry,
-  getRuntimeClassSetSignature,
-  invalidateRuntimeClassSet,
-  isUniAppXEnabled,
-  logger,
-  resolveUniAppXOptions,
-  warnMissingCssEntries
-} from "./chunk-PCDYXXSK.mjs";
-import {
-  getDefaultOptions
-} from "./chunk-XAKAD2CR.mjs";
-import {
-  defuOverrideArray,
-  isMap
-} from "./chunk-OOHJLO5M.mjs";
-
-// src/debug/index.ts
-import _createDebug from "debug";
-var _debug = _createDebug("weapp-tw");
-function createDebug(prefix) {
-  const debug3 = ((formatter, ...args) => {
-    return _debug((prefix ?? "") + formatter, ...args);
-  });
-  Object.defineProperty(debug3, "enabled", {
-    enumerable: false,
-    configurable: false,
-    get() {
-      return _debug.enabled;
-    }
-  });
-  return debug3;
-}
-
-// src/tailwindcss/runtime.ts
-var debug = createDebug("[tailwindcss:runtime] ");
-var refreshTailwindcssPatcherSymbol = /* @__PURE__ */ Symbol.for("weapp-tailwindcss.refreshTailwindcssPatcher");
-function createTailwindPatchPromise(twPatcher, onPatched) {
-  return Promise.resolve(twPatcher.patch()).then(async () => {
-    invalidateRuntimeClassSet(twPatcher);
-    if (onPatched) {
-      try {
-        await onPatched();
-      } catch (error) {
-        debug("failed to persist patch target after patch(): %O", error);
-      }
-    }
-  });
-}
-var runtimeClassSetStateCache = /* @__PURE__ */ new WeakMap();
-function getRuntimeClassSetStateEntry(state) {
-  let entry = runtimeClassSetStateCache.get(state);
-  if (!entry) {
-    entry = {};
-    runtimeClassSetStateCache.set(state, entry);
-  }
-  return entry;
-}
-async function refreshTailwindRuntimeState(state, forceOrOptions) {
-  const normalizedOptions = typeof forceOrOptions === "boolean" ? { force: forceOrOptions } : forceOrOptions;
-  const force = normalizedOptions.force;
-  const clearCache = normalizedOptions.clearCache === true;
-  if (!force) {
-    return false;
-  }
-  debug("refresh runtime state start, clearCache=%s major=%s", clearCache, state.twPatcher.majorVersion ?? "unknown");
-  await state.patchPromise;
-  let refreshed = false;
-  if (typeof state.refreshTailwindcssPatcher === "function") {
-    const next = await state.refreshTailwindcssPatcher({ clearCache });
-    if (next !== state.twPatcher) {
-      state.twPatcher = next;
-    }
-    refreshed = true;
-  }
-  if (refreshed) {
-    state.patchPromise = createTailwindPatchPromise(state.twPatcher, state.onPatchCompleted);
-  }
-  debug("refresh runtime state end, refreshed=%s major=%s", refreshed, state.twPatcher.majorVersion ?? "unknown");
-  return refreshed;
-}
-async function ensureRuntimeClassSet(state, options = {}) {
-  const forceRefresh = options.forceRefresh === true;
-  const forceCollect = options.forceCollect === true;
-  const clearCache = options.clearCache === true;
-  const allowEmpty = options.allowEmpty === true;
-  if (forceRefresh) {
-    await refreshTailwindRuntimeState(state, {
-      force: true,
-      clearCache
-    });
-  }
-  await state.patchPromise;
-  const entry = getRuntimeClassSetStateEntry(state);
-  const signature = getRuntimeClassSetSignature(state.twPatcher);
-  const signatureChanged = entry.signature !== signature;
-  const shouldForceCollect = forceCollect || forceRefresh || signatureChanged;
-  if (!shouldForceCollect) {
-    if (entry.value && (allowEmpty || entry.value.size > 0)) {
-      return entry.value;
-    }
-    if (entry.promise) {
-      return entry.promise;
-    }
-  }
-  const task = (async () => {
-    const collected = await collectRuntimeClassSet(state.twPatcher, {
-      force: shouldForceCollect,
-      skipRefresh: true,
-      clearCache
-    });
-    if (allowEmpty || collected.size > 0) {
-      return collected;
-    }
-    await refreshTailwindRuntimeState(state, {
-      force: true,
-      clearCache: true
-    });
-    await state.patchPromise;
-    return collectRuntimeClassSet(state.twPatcher, {
-      force: true,
-      skipRefresh: true,
-      clearCache: true
-    });
-  })();
-  entry.promise = task;
-  try {
-    const runtimeSet = await task;
-    entry.value = runtimeSet;
-    entry.signature = getRuntimeClassSetSignature(state.twPatcher);
-    return runtimeSet;
-  } finally {
-    if (entry.promise === task) {
-      entry.promise = void 0;
-    }
-  }
-}
-function shouldPreferSync(majorVersion) {
-  if (majorVersion == null) {
-    return true;
-  }
-  if (majorVersion === 3) {
-    return true;
-  }
-  if (majorVersion === 4) {
-    return true;
-  }
-  return false;
-}
-function tryGetRuntimeClassSetSync(twPatcher) {
-  if (typeof twPatcher.getClassSetSync !== "function") {
-    return void 0;
-  }
-  if (!shouldPreferSync(twPatcher.majorVersion)) {
-    return void 0;
-  }
-  try {
-    const set = twPatcher.getClassSetSync();
-    if (set && set.size === 0) {
-      return void 0;
-    }
-    return set;
-  } catch (error) {
-    if (twPatcher.majorVersion === 4) {
-      debug("getClassSetSync() unavailable for tailwindcss v4, fallback to async getClassSet(): %O", error);
-    } else {
-      debug("getClassSetSync() failed, fallback to async getClassSet(): %O", error);
-    }
-    return void 0;
-  }
-}
-async function collectRuntimeClassSet(twPatcher, options = {}) {
-  let activePatcher = twPatcher;
-  if (options.force && !options.skipRefresh) {
-    const refresh = activePatcher[refreshTailwindcssPatcherSymbol];
-    if (typeof refresh === "function") {
-      try {
-        const refreshed = await refresh({ clearCache: options.clearCache === true });
-        if (refreshed) {
-          activePatcher = refreshed;
-        }
-      } catch (error) {
-        debug("refreshTailwindcssPatcher failed, continuing with existing patcher: %O", error);
-      }
-    }
-  }
-  const entry = getRuntimeClassSetCacheEntry(activePatcher);
-  const signature = getRuntimeClassSetSignature(activePatcher);
-  if (!options.force) {
-    if (entry.value && entry.signature === signature) {
-      return entry.value;
-    }
-    if (entry.promise) {
-      return entry.promise;
-    }
-  } else {
-    entry.value = void 0;
-  }
-  const task = (async () => {
-    const preExtractSyncSet = options.force ? tryGetRuntimeClassSetSync(activePatcher) : void 0;
-    if (preExtractSyncSet) {
-      debug("runtime class set snapshot via getClassSetSync() before extract(), size=%d", preExtractSyncSet.size);
-    }
-    const preferExtract = options.force === true;
-    try {
-      const result = await activePatcher.extract({ write: false });
-      if (result?.classSet) {
-        if (result.classSet.size > 0) {
-          debug("runtime class set resolved via extract(), size=%d", result.classSet.size);
-          return result.classSet;
-        }
-        if (preferExtract) {
-          debug("runtime class set from extract() is empty on force collect, fallback to sync/async class set");
-        } else {
-          debug("runtime class set from extract() is empty, fallback to sync/async class set");
-        }
-      }
-    } catch (error) {
-      debug("extract() failed, fallback to getClassSet(): %O", error);
-    }
-    if (preExtractSyncSet) {
-      debug("runtime class set fallback to pre-extract sync snapshot, size=%d", preExtractSyncSet.size);
-      return preExtractSyncSet;
-    }
-    const syncSet = tryGetRuntimeClassSetSync(activePatcher);
-    if (syncSet) {
-      debug("runtime class set resolved via getClassSetSync(), size=%d", syncSet.size);
-      return syncSet;
-    }
-    try {
-      const fallbackSet = await Promise.resolve(activePatcher.getClassSet());
-      if (fallbackSet) {
-        debug("runtime class set resolved via getClassSet(), size=%d", fallbackSet.size);
-        return fallbackSet;
-      }
-    } catch (error) {
-      debug("getClassSet() failed, returning empty set: %O", error);
-    }
-    return /* @__PURE__ */ new Set();
-  })();
-  entry.promise = task;
-  entry.signature = signature;
-  try {
-    const resolved = await task;
-    entry.value = resolved;
-    entry.promise = void 0;
-    entry.signature = signature;
-    return resolved;
-  } catch (error) {
-    entry.promise = void 0;
-    throw error;
-  }
-}
-
-// src/context/index.ts
-import { rm } from "fs/promises";
-import { logger as logger7 } from "@weapp-tailwindcss/logger";
-
-// src/cache/index.ts
-import { LRUCache } from "lru-cache";
-
-// src/cache/md5.ts
-import { md5 } from "@weapp-tailwindcss/shared/node";
-
-// src/cache/index.ts
-function isProcessResult(value) {
-  return typeof value === "object" && value !== null && "result" in value;
-}
-function createCache(options) {
-  const disabled = options === false;
-  const hashMap = /* @__PURE__ */ new Map();
-  const instance = new LRUCache({
-    // 可能会添加和删除一些页面和组件, 先设定 1024 吧
-    max: 1024,
-    ttl: 0,
-    ttlAutopurge: false
-  });
-  const cache = {
-    hashMap,
-    instance,
-    hasHashKey(key) {
-      return hashMap.has(key);
-    },
-    getHashValue(key) {
-      return hashMap.get(key);
-    },
-    setHashValue(key, value) {
-      return hashMap.set(key, value);
-    },
-    get(key) {
-      return instance.get(key);
-    },
-    set(key, value) {
-      return instance.set(key, value);
-    },
-    computeHash(message) {
-      return md5(message);
-    },
-    calcHashValueChanged(key, hash) {
-      const hit = hashMap.get(key);
-      if (hit) {
-        hashMap.set(key, {
-          changed: hash !== hit.hash,
-          hash
-        });
-      } else {
-        hashMap.set(key, {
-          changed: true,
-          hash
-        });
-      }
-      return cache;
-    },
-    has(key) {
-      return instance.has(key);
-    },
-    async process({
-      key,
-      hashKey,
-      rawSource,
-      hash,
-      resolveCache,
-      transform,
-      onCacheHit
-    }) {
-      if (disabled) {
-        const value2 = await transform();
-        return isProcessResult(value2) ? value2.result : value2;
-      }
-      const cacheHashKey = hashKey ?? key;
-      let hasChanged = true;
-      if (hash != null || rawSource != null) {
-        const nextHash = hash ?? cache.computeHash(rawSource);
-        cache.calcHashValueChanged(cacheHashKey, nextHash);
-        const entry = cache.getHashValue(cacheHashKey);
-        hasChanged = entry?.changed ?? true;
-      }
-      const readCache = resolveCache ?? (() => cache.get(key));
-      if (!hasChanged) {
-        const cached = readCache();
-        if (cached !== void 0) {
-          await onCacheHit?.(cached);
-          return cached;
-        }
-      }
-      const value = await transform();
-      const normalized = isProcessResult(value) ? value : { result: value };
-      const stored = normalized.cacheValue ?? normalized.result;
-      cache.set(key, stored);
-      return normalized.result;
-    }
-  };
-  return cache;
-}
-function initializeCache(cacheConfig) {
-  if (typeof cacheConfig === "boolean" || cacheConfig === void 0) {
-    return createCache(cacheConfig);
-  }
-  return cacheConfig;
-}
-
-// src/tailwindcss/runtime-logs.ts
-import process from "process";
-import { logger as logger2, pc } from "@weapp-tailwindcss/logger";
-var runtimeLogDedupeHolder = globalThis;
-var runtimeLogDedupe = runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ ?? (runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ = /* @__PURE__ */ new Set());
-function createRuntimeLogKey(category, baseDir, rootPath, version) {
-  return JSON.stringify([
-    category,
-    baseDir ?? process.cwd(),
-    rootPath ?? "",
-    version ?? ""
-  ]);
-}
-function markRuntimeLog(category, baseDir, rootPath, version) {
-  const key = createRuntimeLogKey(category, baseDir, rootPath, version);
-  if (runtimeLogDedupe.has(key)) {
-    return false;
-  }
-  runtimeLogDedupe.add(key);
-  return true;
-}
-function logRuntimeTailwindcssTarget(baseDir, rootPath, version) {
-  if (!markRuntimeLog("target", baseDir, rootPath, version)) {
-    return;
-  }
-  const versionText = version ? ` (v${version})` : "";
-  logger2.info("%s \u4F7F\u7528 Tailwind CSS%s", "Weapp-tailwindcss", versionText);
-}
-function logRuntimeTailwindcssVersion(baseDir, rootPath, version) {
-  if (version) {
-    if (!markRuntimeLog("version", baseDir, rootPath, version)) {
-      return;
-    }
-    logger2.success(`\u5F53\u524D\u4F7F\u7528 ${pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${pc.underline(pc.bold(pc.green(version)))}`);
-    return;
-  }
-  if (!markRuntimeLog("missing", baseDir, rootPath, version)) {
-    return;
-  }
-  logger2.warn(`${pc.cyanBright("Tailwind CSS")} \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u7248\u672C\u68C0\u6D4B\u4E0E\u8865\u4E01\u5E94\u7528\u3002`);
-}
-
-// src/tailwindcss/targets.ts
-import process4 from "process";
-import { logger as logger4 } from "@weapp-tailwindcss/logger";
-
-// src/tailwindcss/targets/paths.ts
-import { existsSync } from "fs";
-import path from "path";
-var PATCH_INFO_FILENAME = "tailwindcss-target.json";
-var PATCH_INFO_CACHE_RELATIVE_PATH = path.join("node_modules", ".cache", "weapp-tailwindcss", PATCH_INFO_FILENAME);
-var PATCH_INFO_LEGACY_RELATIVE_PATH = path.join(".tw-patch", PATCH_INFO_FILENAME);
-function toDisplayPath(value) {
-  return path.normalize(value).replace(/\\/g, "/");
-}
-function formatRelativeToBase(targetPath, baseDir) {
-  if (!baseDir) {
-    return toDisplayPath(targetPath);
-  }
-  const relative = path.relative(baseDir, targetPath);
-  if (!relative || relative === ".") {
-    return ".";
-  }
-  if (relative.startsWith("..")) {
-    return toDisplayPath(targetPath);
-  }
-  return toDisplayPath(path.join(".", relative));
-}
-function resolveRecordLocation(baseDir) {
-  const normalizedBase = path.normalize(baseDir);
-  const packageRoot = findNearestPackageRoot(normalizedBase) ?? normalizedBase;
-  const packageJsonPath = path.join(packageRoot, "package.json");
-  const hasPackageJson = existsSync(packageJsonPath);
-  const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
-  const recordKey = md5(path.normalize(recordKeySource));
-  const recordDir = path.join(packageRoot, "node_modules", ".cache", "weapp-tailwindcss", recordKey);
-  const recordPath = path.join(recordDir, PATCH_INFO_FILENAME);
-  return {
-    normalizedBase,
-    packageRoot,
-    recordDir,
-    recordKey,
-    recordPath,
-    packageJsonPath: hasPackageJson ? packageJsonPath : void 0
-  };
-}
-function getRecordFileCandidates(baseDir) {
-  const { normalizedBase, packageRoot, recordPath } = resolveRecordLocation(baseDir);
-  const candidates = /* @__PURE__ */ new Set([
-    recordPath,
-    path.join(packageRoot, PATCH_INFO_CACHE_RELATIVE_PATH),
-    path.join(normalizedBase, PATCH_INFO_CACHE_RELATIVE_PATH),
-    path.join(normalizedBase, PATCH_INFO_LEGACY_RELATIVE_PATH)
-  ]);
-  return [...candidates];
-}
-
-// src/tailwindcss/targets/record-io.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import path2 from "path";
-import process2 from "process";
-import { logger as logger3 } from "@weapp-tailwindcss/logger";
-
-// package.json
-var package_default = {
-  name: "weapp-tailwindcss",
-  version: "4.12.0",
-  description: "\u628A tailwindcss \u539F\u5B50\u5316\u6837\u5F0F\u601D\u60F3\uFF0C\u5E26\u7ED9\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u4EEC! bring tailwindcss to miniprogram developers!",
-  author: "ice breaker <1324318532@qq.com>",
-  license: "MIT",
-  homepage: "https://tw.icebreaker.top",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/sonofmagic/weapp-tailwindcss.git",
-    directory: "packages/weapp-tailwindcss"
-  },
-  bugs: {
-    url: "https://github.com/sonofmagic/weapp-tailwindcss/issues"
-  },
-  keywords: [
-    "tailwindcss",
-    "weapp",
-    "wechat",
-    "mini",
-    "miniprogram",
-    "mini app",
-    "weapp-tw",
-    "weapp-tailwindcss",
-    "taro",
-    "uni-app",
-    "remax",
-    "rax",
-    "mpx",
-    "jit",
-    "mp",
-    "android",
-    "ios",
-    "\u5C0F\u7A0B\u5E8F",
-    "vite",
-    "postcss",
-    "webpack",
-    "webpack-plugin",
-    "gulp",
-    "gulp-plugin"
-  ],
-  exports: {
-    ".": {
-      style: "./index.css",
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
-    },
-    "./escape": {
-      types: "./dist/escape.d.ts",
-      import: "./dist/escape.mjs",
-      require: "./dist/escape.js"
-    },
-    "./vite": {
-      types: "./dist/vite.d.ts",
-      import: "./dist/vite.mjs",
-      require: "./dist/vite.js"
-    },
-    "./webpack": {
-      types: "./dist/webpack.d.ts",
-      import: "./dist/webpack.mjs",
-      require: "./dist/webpack.js"
-    },
-    "./webpack4": {
-      types: "./dist/webpack4.d.ts",
-      import: "./dist/webpack4.mjs",
-      require: "./dist/webpack4.js"
-    },
-    "./core": {
-      types: "./dist/core.d.ts",
-      import: "./dist/core.mjs",
-      require: "./dist/core.js"
-    },
-    "./gulp": {
-      types: "./dist/gulp.d.ts",
-      import: "./dist/gulp.mjs",
-      require: "./dist/gulp.js"
-    },
-    "./defaults": {
-      types: "./dist/defaults.d.ts",
-      import: "./dist/defaults.mjs",
-      require: "./dist/defaults.js"
-    },
-    "./presets": {
-      types: "./dist/presets.d.ts",
-      import: "./dist/presets.mjs",
-      require: "./dist/presets.js"
-    },
-    "./reset": {
-      types: "./dist/reset.d.ts",
-      import: "./dist/reset.mjs",
-      require: "./dist/reset.js"
-    },
-    "./css-macro/postcss": {
-      types: "./dist/css-macro/postcss.d.ts",
-      import: "./dist/css-macro/postcss.mjs",
-      require: "./dist/css-macro/postcss.js"
-    },
-    "./css-macro": {
-      types: "./dist/css-macro.d.ts",
-      import: "./dist/css-macro.mjs",
-      require: "./dist/css-macro.js"
-    },
-    "./types": {
-      types: "./dist/types.d.ts",
-      import: "./dist/types.mjs",
-      require: "./dist/types.js"
-    },
-    "./postcss-html-transform": {
-      types: "./dist/postcss-html-transform.d.ts",
-      import: "./dist/postcss-html-transform.mjs",
-      require: "./dist/postcss-html-transform.js"
-    },
-    "./package.json": "./package.json",
-    "./index.css": "./index.css",
-    "./index": "./index.css",
-    "./preflight.css": "./preflight.css",
-    "./preflight": "./preflight.css",
-    "./theme.css": "./theme.css",
-    "./theme": "./theme.css",
-    "./utilities.css": "./utilities.css",
-    "./utilities": "./utilities.css",
-    "./with-layer.css": "./with-layer.css",
-    "./with-layer": "./with-layer.css",
-    "./uni-app-x": "./uni-app-x.css",
-    "./uni-app-x.css": "./uni-app-x.css",
-    "./css": "./css/index.css",
-    "./*": "./*"
-  },
-  main: "./dist/index.js",
-  module: "./dist/index.mjs",
-  types: "./dist/index.d.ts",
-  style: "index.css",
-  typesVersions: {
-    "*": {
-      "*": [
-        "./dist/*",
-        "./dist/index.d.ts"
-      ]
-    }
-  },
-  bin: {
-    "weapp-tailwindcss-webpack-plugin": "bin/weapp-tailwindcss.js",
-    "weapp-tailwindcss": "bin/weapp-tailwindcss.js",
-    "weapp-tw": "bin/weapp-tailwindcss.js"
-  },
-  files: [
-    "bin",
-    "css",
-    "dist",
-    "index.css",
-    "preflight.css",
-    "scripts/postinstall.mjs",
-    "theme.css",
-    "uni-app-x.css",
-    "utilities.css",
-    "with-layer.css"
-  ],
-  engines: {
-    node: "^20.19.0 || >=22.12.0"
-  },
-  scripts: {
-    dev: "tsup --watch --sourcemap",
-    build: "tsup && node scripts/ensure-escape-dts.mjs",
-    "build:tsc": "cross-env NODE_ENV=development tsc --build tsconfig.json",
-    "build:cli": "cd plugins/cli && pnpm run build",
-    "build:css": "tsx scripts/build-css.ts",
-    "build:weapp-theme": "tsx scripts/build-weapp-theme.ts",
-    test: "pnpm run cli:patch && vitest run",
-    "test:dev": "vitest",
-    "test:ui": "vitest --ui",
-    bench: "vitest bench --config ./vitest.config.ts",
-    "bench:vite-perf": "tsx scripts/vite-perf-bench.ts",
-    "bench:vite-perf:summary": "tsx scripts/vite-perf-summary.ts",
-    "bench:js-handlers": "tsx scripts/js-bench.ts",
-    "bench:js-diff": "tsx scripts/js-bench-diff.ts",
-    tsd: "tsd",
-    clean: "tsx scripts/clean.ts",
-    "get-decl": "tsx scripts/get-decl.ts",
-    "ls:pack": "npm pack --dry-run",
-    "cli:patch": "node bin/weapp-tailwindcss.js patch",
-    colors: "tsx scripts/colors.ts",
-    release: "tsx scripts/release.ts",
-    lint: "eslint .",
-    "lint:fix": "eslint ./src --fix",
-    postinstall: "node scripts/postinstall.mjs",
-    "bench:vite-dev-hmr": "tsx scripts/vite-dev-hmr-bench.ts",
-    "test:watch-hmr": "node --import tsx scripts/watch-hmr-regression/index.ts"
-  },
-  publishConfig: {
-    access: "public",
-    registry: "https://registry.npmjs.org"
-  },
-  dependencies: {
-    "@ast-core/escape": "~1.0.1",
-    "@babel/parser": "~7.29.3",
-    "@babel/traverse": "~7.29.0",
-    "@babel/types": "~7.29.0",
-    "@tailwindcss-mangle/config": "^7.0.1",
-    "@vue/compiler-dom": "catalog:vue3",
-    "@vue/compiler-sfc": "catalog:vue3",
-    "@weapp-core/escape": "~7.0.0",
-    "@weapp-core/regex": "~1.0.1",
-    "@weapp-tailwindcss/logger": "workspace:*",
-    "@weapp-tailwindcss/postcss": "workspace:*",
-    "@weapp-tailwindcss/reset": "workspace:*",
-    "@weapp-tailwindcss/shared": "workspace:*",
-    cac: "6.7.14",
-    "comment-json": "^4.6.2",
-    debug: "~4.4.3",
-    "fast-glob": "^3.3.3",
-    htmlparser2: "10.1.0",
-    "loader-utils": "2.0.4",
-    "local-pkg": "^1.1.2",
-    "lru-cache": "10.4.3",
-    "magic-string": "0.30.21",
-    semver: "~7.7.4",
-    "tailwindcss-patch": "catalog:tailwindcssPatch",
-    "webpack-sources": "3.3.4",
-    yaml: "^2.8.4"
-  },
-  devDependencies: {
-    "fast-check": "^4.7.0"
-  }
-};
-
-// src/constants.ts
-var pluginName = "weapp-tailwindcss-webpack-plugin";
-var vitePluginName = "weapp-tailwindcss:adaptor";
-var WEAPP_TW_VERSION = package_default.version;
-var DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS = {
-  "tailwind-merge": "@weapp-tailwindcss/merge",
-  "class-variance-authority": "@weapp-tailwindcss/cva",
-  "tailwind-variants": "@weapp-tailwindcss/variants"
-};
-
-// src/tailwindcss/targets/record-io.ts
-var loggedInvalidPatchRecords = /* @__PURE__ */ new Set();
-function warnInvalidPatchTargetRecord(baseDir, recordPath, reason) {
-  const normalizedPath = path2.normalize(recordPath);
-  if (loggedInvalidPatchRecords.has(normalizedPath)) {
-    return;
-  }
-  loggedInvalidPatchRecords.add(normalizedPath);
-  const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
-  const baseDisplay = formatRelativeToBase(path2.normalize(baseDir), process2.cwd());
-  const reasonMessage = reason ? `\uFF1A${reason}` : "";
-  logger3.warn(
-    `\u68C0\u6D4B\u5230\u635F\u574F\u7684 Tailwind CSS \u76EE\u6807\u8BB0\u5F55 ${fileDisplay}${reasonMessage}\u3002\u8BF7\u5728 ${baseDisplay} \u91CD\u65B0\u6267\u884C "weapp-tw patch --record-target" \u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u518D\u8FD0\u884C\u3002`
-  );
-}
-function readPatchTargetRecord(baseDir) {
-  if (!baseDir) {
-    return void 0;
-  }
-  const normalizedBase = path2.normalize(baseDir);
-  for (const recordPath of getRecordFileCandidates(normalizedBase)) {
-    if (!existsSync2(recordPath)) {
-      continue;
-    }
-    try {
-      const content = readFileSync(recordPath, "utf8");
-      const parsed = JSON.parse(content);
-      if (!parsed || typeof parsed.tailwindPackagePath !== "string") {
-        warnInvalidPatchTargetRecord(normalizedBase, recordPath, "\u7F3A\u5C11 tailwindPackagePath \u5B57\u6BB5");
-        continue;
-      }
-      return {
-        baseDir: normalizedBase,
-        path: recordPath,
-        record: parsed
-      };
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      warnInvalidPatchTargetRecord(normalizedBase, recordPath, reason);
-      continue;
-    }
-  }
-  return void 0;
-}
-async function saveCliPatchTargetRecord(baseDir, patcher, options) {
-  if (!baseDir || !patcher?.packageInfo?.rootPath) {
-    return void 0;
-  }
-  const normalizedBase = path2.normalize(baseDir);
-  const location = resolveRecordLocation(normalizedBase);
-  const recordPath = options?.recordPath ? path2.normalize(options.recordPath) : location.recordPath;
-  const record = {
-    tailwindPackagePath: path2.normalize(patcher.packageInfo.rootPath),
-    packageVersion: patcher.packageInfo.version,
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: options?.source ?? "cli",
-    tailwindcssBasedir: normalizedBase,
-    cwd: options?.cwd ? path2.normalize(options.cwd) : normalizedBase,
-    patchVersion: WEAPP_TW_VERSION,
-    packageJsonPath: options?.packageJsonPath ?? location.packageJsonPath,
-    recordKey: options?.recordKey ?? location.recordKey
-  };
-  try {
-    await mkdir(path2.dirname(recordPath), { recursive: true });
-    await writeFile(recordPath, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-    return recordPath;
-  } catch (error) {
-    const baseDisplay = formatRelativeToBase(normalizedBase, process2.cwd());
-    logger3.warn(
-      '\u81EA\u52A8\u66F4\u65B0 Tailwind CSS \u8865\u4E01\u8BB0\u5F55\u5931\u8D25\uFF0C\u8BF7\u5728 %s \u8FD0\u884C "weapp-tw patch --cwd %s"\u3002',
-      baseDisplay,
-      normalizedBase
-    );
-    logger3.debug("failed to persist patch target record %s: %O", recordPath, error);
-    return void 0;
-  }
-}
-
-// src/tailwindcss/targets/recorder.ts
-import path3 from "path";
-import process3 from "process";
-function findPatchTargetRecord(baseDir) {
-  const visited = /* @__PURE__ */ new Set();
-  const fallback = baseDir ?? process3.cwd();
-  let current = path3.resolve(fallback);
-  while (!visited.has(current)) {
-    const record = readPatchTargetRecord(current);
-    if (record) {
-      return record;
-    }
-    const parent = path3.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    visited.add(current);
-    current = parent;
-  }
-  return void 0;
-}
-function createPatchTargetRecorder(baseDir, patcher, options) {
-  if (!baseDir || !patcher?.packageInfo?.rootPath || options?.recordTarget === false) {
-    return void 0;
-  }
-  const normalizedBase = path3.normalize(baseDir);
-  const recorded = findPatchTargetRecord(normalizedBase);
-  const location = resolveRecordLocation(normalizedBase);
-  const expectedPath = path3.normalize(patcher.packageInfo.rootPath);
-  let reason;
-  if (!recorded) {
-    reason = "missing";
-  } else {
-    const normalizedRecorded = path3.normalize(recorded.record.tailwindPackagePath);
-    if (normalizedRecorded !== expectedPath) {
-      reason = "mismatch";
-    } else if (path3.normalize(recorded.path) !== path3.normalize(location.recordPath) || !recorded.record.recordKey || recorded.record.recordKey !== location.recordKey) {
-      reason = "migrate";
-    } else if (!recorded.record.patchVersion || recorded.record.patchVersion !== WEAPP_TW_VERSION) {
-      reason = "stale";
-    } else if (options?.cwd && recorded.record.cwd && path3.normalize(recorded.record.cwd) !== path3.normalize(options.cwd)) {
-      reason = "metadata";
-    } else if (!recorded.record.cwd && options?.cwd) {
-      reason = "metadata";
-    }
-  }
-  const shouldPersist = options?.alwaysRecord || !recorded || Boolean(reason);
-  if (!shouldPersist) {
-    return void 0;
-  }
-  let message;
-  switch (reason) {
-    case "mismatch":
-      message = "\u68C0\u6D4B\u5230 Tailwind CSS \u76EE\u6807\u8BB0\u5F55\u4E0E\u5F53\u524D\u89E3\u6790\u7ED3\u679C\u4E0D\u4E00\u81F4\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u65B0 patch \u5E76\u5237\u65B0\u7F13\u5B58\u3002";
-      break;
-    case "migrate":
-    case "stale":
-      message = "\u6B63\u5728\u5237\u65B0\u5F53\u524D\u5B50\u5305\u7684 Tailwind CSS \u8865\u4E01\u8BB0\u5F55\uFF0C\u786E\u4FDD\u7F13\u5B58\u9694\u79BB\u3002";
-      break;
-    case "missing":
-      message = "\u672A\u627E\u5230\u5F53\u524D\u5B50\u5305\u7684 Tailwind CSS \u76EE\u6807\u8BB0\u5F55\uFF0C\u6B63\u5728\u751F\u6210\u3002";
-      break;
-    default:
-      break;
-  }
-  const onPatched = async () => saveCliPatchTargetRecord(normalizedBase, patcher, {
-    cwd: options?.cwd ?? normalizedBase,
-    source: options?.source ?? "cli",
-    recordPath: location.recordPath,
-    recordKey: location.recordKey,
-    packageJsonPath: location.packageJsonPath
-  });
-  return {
-    recordPath: location.recordPath,
-    message,
-    reason,
-    onPatched
-  };
-}
-
-// src/tailwindcss/targets.ts
-function logTailwindcssTarget(kind, patcher, baseDir) {
-  const packageInfo = patcher?.packageInfo;
-  const label = kind === "cli" ? "weapp-tw patch" : "Weapp-tailwindcss";
-  if (!packageInfo?.rootPath) {
-    logger4.warn(
-      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
-      label,
-      baseDir ?? process4.cwd()
-    );
-    return;
-  }
-  const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
-  const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
-  if (kind === "runtime") {
-    logRuntimeTailwindcssTarget(baseDir, packageInfo.rootPath, packageInfo.version);
-    return;
-  }
-  logger4.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
-}
-
-// src/context/compiler-context-cache.ts
-import { Buffer } from "buffer";
-import path4 from "path";
-import process5 from "process";
-import { logger as logger5 } from "@weapp-tailwindcss/logger";
-var PAREN_CONTENT_RE = /\(([^)]+)\)/u;
-var AT_LOCATION_RE = /at\s+(\S.*)$/u;
-var TRAILING_LINE_COL_RE = /:\d+(?::\d+)?$/u;
-var globalCacheHolder = globalThis;
-var compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
-var compilerContextKeyCacheByOptions = /* @__PURE__ */ new WeakMap();
-var compilerContextKeyCacheWithoutOptions = /* @__PURE__ */ new Map();
-function withCircularGuard(value, stack, factory) {
-  if (stack.has(value)) {
-    throw new TypeError("Cannot serialize circular structure in compiler context options");
-  }
-  stack.add(value);
-  try {
-    return factory();
-  } finally {
-    stack.delete(value);
-  }
-}
-function encodeTaggedValue(type, value) {
-  const record = { __type: type };
-  if (value !== void 0) {
-    record.value = value;
-  }
-  return record;
-}
-function hasExplicitOptionBasedir(opts) {
-  return typeof opts?.tailwindcssBasedir === "string" && opts.tailwindcssBasedir.length > 0;
-}
-function shouldProbeCallerLocation(opts) {
-  if (hasExplicitOptionBasedir(opts)) {
-    return false;
-  }
-  return !(process5.env.WEAPP_TAILWINDCSS_BASEDIR || process5.env.WEAPP_TAILWINDCSS_BASE_DIR || process5.env.TAILWINDCSS_BASEDIR || process5.env.TAILWINDCSS_BASE_DIR);
-}
-function detectCallerLocation() {
-  const stack = new Error("compiler-context-cache stack probe").stack;
-  if (!stack) {
-    return void 0;
-  }
-  const lines = stack.split("\n");
-  for (const line of lines) {
-    const match = line.match(PAREN_CONTENT_RE) ?? line.match(AT_LOCATION_RE);
-    const location = match?.[1];
-    if (!location) {
-      continue;
-    }
-    const candidatePath = location.replace(TRAILING_LINE_COL_RE, "");
-    if (!candidatePath || !path4.isAbsolute(candidatePath)) {
-      continue;
-    }
-    if (candidatePath.includes(`${path4.sep}weapp-tailwindcss${path4.sep}src${path4.sep}`) || candidatePath.includes(`${path4.sep}weapp-tailwindcss${path4.sep}dist${path4.sep}`) || candidatePath.includes(`${path4.sep}node_modules${path4.sep}weapp-tailwindcss${path4.sep}`)) {
-      continue;
-    }
-    return candidatePath;
-  }
-  return void 0;
-}
-function getRuntimeCacheScope(opts) {
-  if (hasExplicitOptionBasedir(opts)) {
-    return {
-      caller: void 0
-    };
-  }
-  const runtimeScope = {
-    caller: void 0,
-    cwd: process5.cwd(),
-    init_cwd: process5.env.INIT_CWD,
-    npm_config_local_prefix: process5.env.npm_config_local_prefix,
-    npm_package_json: process5.env.npm_package_json,
-    pnpm_package_name: process5.env.PNPM_PACKAGE_NAME,
-    pwd: process5.env.PWD,
-    tailwindcss_base_dir: process5.env.TAILWINDCSS_BASE_DIR,
-    tailwindcss_basedir: process5.env.TAILWINDCSS_BASEDIR,
-    uni_app_input_dir: process5.env.UNI_APP_INPUT_DIR,
-    uni_cli_root: process5.env.UNI_CLI_ROOT,
-    uni_input_dir: process5.env.UNI_INPUT_DIR,
-    uni_input_root: process5.env.UNI_INPUT_ROOT,
-    weapp_tailwindcss_base_dir: process5.env.WEAPP_TAILWINDCSS_BASE_DIR,
-    weapp_tailwindcss_basedir: process5.env.WEAPP_TAILWINDCSS_BASEDIR
-  };
-  if (shouldProbeCallerLocation(opts)) {
-    runtimeScope.caller = detectCallerLocation();
-  }
-  return runtimeScope;
-}
-function serializeNormalizedValue(value) {
-  return JSON.stringify(value);
-}
-function createRuntimeCacheScopeKey(opts) {
-  return serializeNormalizedValue(normalizeOptionsValue(getRuntimeCacheScope(opts)));
-}
-function getCompilerContextKeyCacheStore(opts) {
-  if (!opts) {
-    return compilerContextKeyCacheWithoutOptions;
-  }
-  let store = compilerContextKeyCacheByOptions.get(opts);
-  if (!store) {
-    store = /* @__PURE__ */ new Map();
-    compilerContextKeyCacheByOptions.set(opts, store);
-  }
-  return store;
-}
-function createComparableNormalizedValue(rawValue, stack) {
-  const normalized = normalizeOptionsValue(rawValue, stack);
-  return {
-    normalized,
-    sortKey: serializeNormalizedValue(normalized)
-  };
-}
-function getRuntimeCacheScopeValue(opts) {
-  return {
-    options: opts ?? {},
-    runtime: getRuntimeCacheScope(opts)
-  };
-}
-function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet()) {
-  if (rawValue === null) {
-    return null;
-  }
-  if (rawValue === void 0) {
-    return encodeTaggedValue("Undefined");
-  }
-  const type = typeof rawValue;
-  if (type === "string") {
-    return rawValue;
-  }
-  if (type === "boolean") {
-    return rawValue;
-  }
-  if (type === "number") {
-    const numericValue = rawValue;
-    if (Number.isNaN(numericValue)) {
-      return encodeTaggedValue("Number", "NaN");
-    }
-    if (!Number.isFinite(numericValue)) {
-      return encodeTaggedValue("Number", numericValue > 0 ? "Infinity" : "-Infinity");
-    }
-    if (Object.is(numericValue, -0)) {
-      return encodeTaggedValue("Number", "-0");
-    }
-    return numericValue;
-  }
-  if (type === "bigint") {
-    return encodeTaggedValue("BigInt", rawValue.toString());
-  }
-  if (type === "symbol") {
-    const symbolValue = rawValue;
-    return encodeTaggedValue("Symbol", symbolValue.description ?? String(symbolValue));
-  }
-  if (type === "function") {
-    return encodeTaggedValue("Function", rawValue.toString());
-  }
-  if (Array.isArray(rawValue)) {
-    return withCircularGuard(rawValue, stack, () => rawValue.map((item) => normalizeOptionsValue(item, stack)));
-  }
-  if (rawValue instanceof Date) {
-    return encodeTaggedValue("Date", rawValue.toISOString());
-  }
-  if (rawValue instanceof RegExp) {
-    return {
-      __type: "RegExp",
-      source: rawValue.source,
-      flags: rawValue.flags
-    };
-  }
-  if (typeof Buffer !== "undefined" && Buffer.isBuffer(rawValue)) {
-    return encodeTaggedValue("Buffer", rawValue.toString("base64"));
-  }
-  if (ArrayBuffer.isView(rawValue)) {
-    const view = rawValue;
-    const buffer = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-    return encodeTaggedValue(view.constructor?.name ?? "ArrayBufferView", buffer.toString("base64"));
-  }
-  if (rawValue instanceof ArrayBuffer) {
-    return encodeTaggedValue("ArrayBuffer", Buffer.from(rawValue).toString("base64"));
-  }
-  if (rawValue instanceof Set) {
-    return withCircularGuard(rawValue, stack, () => {
-      const normalizedEntries = Array.from(rawValue, (element) => createComparableNormalizedValue(element, stack));
-      normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
-      return {
-        __type: "Set",
-        value: normalizedEntries.map((entry) => entry.normalized)
-      };
-    });
-  }
-  if (rawValue instanceof Map) {
-    return withCircularGuard(rawValue, stack, () => {
-      const normalizedEntries = Array.from(rawValue.entries(), ([key, entryValue]) => {
-        const normalizedKey = createComparableNormalizedValue(key, stack);
-        return {
-          key: normalizedKey.normalized,
-          sortKey: normalizedKey.sortKey,
-          value: normalizeOptionsValue(entryValue, stack)
-        };
-      });
-      normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
-      return {
-        __type: "Map",
-        value: normalizedEntries.map((entry) => [entry.key, entry.value])
-      };
-    });
-  }
-  if (typeof URL !== "undefined" && rawValue instanceof URL) {
-    return encodeTaggedValue("URL", rawValue.toString());
-  }
-  if (rawValue instanceof Error) {
-    const errorValue = rawValue;
-    return {
-      __type: "Error",
-      name: errorValue.name,
-      message: errorValue.message,
-      stack: errorValue.stack ?? ""
-    };
-  }
-  if (rawValue instanceof Promise) {
-    return encodeTaggedValue("Promise");
-  }
-  if (rawValue instanceof WeakMap) {
-    return encodeTaggedValue("WeakMap");
-  }
-  if (rawValue instanceof WeakSet) {
-    return encodeTaggedValue("WeakSet");
-  }
-  if (rawValue && typeof rawValue === "object") {
-    return withCircularGuard(rawValue, stack, () => {
-      const result = {};
-      const entries = Object.entries(rawValue);
-      entries.sort(([a], [b]) => a.localeCompare(b));
-      for (const [key, entryValue] of entries) {
-        result[key] = normalizeOptionsValue(entryValue, stack);
-      }
-      return result;
-    });
-  }
-  return encodeTaggedValue(typeof rawValue, String(rawValue));
-}
-function createCompilerContextCacheKey(opts) {
-  try {
-    const runtimeCacheScopeKey = createRuntimeCacheScopeKey(opts);
-    const keyStore = getCompilerContextKeyCacheStore(opts);
-    const cached = keyStore.get(runtimeCacheScopeKey);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const normalized = normalizeOptionsValue(getRuntimeCacheScopeValue(opts));
-    const cacheKey = md5(serializeNormalizedValue(normalized));
-    keyStore.set(runtimeCacheScopeKey, cacheKey);
-    return cacheKey;
-  } catch (error) {
-    logger5.debug("skip compiler context cache: %O", error);
-    return void 0;
-  }
-}
-function withCompilerContextCache(opts, factory) {
-  const cacheKey = createCompilerContextCacheKey(opts);
-  if (cacheKey) {
-    const cached = compilerContextCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-  }
-  const ctx = factory();
-  if (cacheKey) {
-    compilerContextCache.set(cacheKey, ctx);
-  }
-  return ctx;
-}
-
-// src/context/custom-attributes.ts
-function toCustomAttributesEntities(customAttributes) {
-  if (!customAttributes) {
-    return [];
-  }
-  if (isMap(customAttributes)) {
-    return [
-      ...customAttributes.entries()
-    ];
-  }
-  return Object.entries(customAttributes);
-}
-
-// src/context/handlers.ts
-import { createStyleHandler } from "@weapp-tailwindcss/postcss";
-
-// src/js/index.ts
-import { LRUCache as LRUCache3 } from "lru-cache";
-
-// src/babel/index.ts
-import _babelTraverse from "@babel/traverse";
-import { parse, parseExpression } from "@babel/parser";
-function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
-}
-var traverse = _interopDefaultCompat(_babelTraverse);
-
-// src/utils/nameMatcher.ts
-import { escapeStringRegexp } from "@weapp-core/regex";
-var NEVER_MATCH_NAME = () => false;
-var GLOBAL_FLAG_REGEXP = /g/g;
-function buildFuzzyMatcher(fuzzyStrings) {
-  if (fuzzyStrings.length === 0) {
-    return void 0;
-  }
-  if (fuzzyStrings.length === 1) {
-    const [needle] = fuzzyStrings;
-    return (value) => value.includes(needle);
-  }
-  const unique = [...new Set(fuzzyStrings)];
-  const pattern = new RegExp(unique.map(escapeStringRegexp).join("|"));
-  return (value) => pattern.test(value);
-}
-function normaliseRegex(regex) {
-  const { source, flags } = regex;
-  if (!flags.includes("g")) {
-    return regex;
-  }
-  return new RegExp(source, flags.replace(GLOBAL_FLAG_REGEXP, ""));
-}
-function createNameMatcher(list, { exact = false } = {}) {
-  if (!list || list.length === 0) {
-    return NEVER_MATCH_NAME;
-  }
-  const exactStrings = exact ? /* @__PURE__ */ new Set() : void 0;
-  const fuzzyStrings = [];
-  const regexList = [];
-  for (const item of list) {
-    if (typeof item === "string") {
-      if (exact) {
-        exactStrings.add(item);
-      } else {
-        fuzzyStrings.push(item);
-      }
-    } else {
-      regexList.push(normaliseRegex(item));
-    }
-  }
-  if (exact) {
-    const exactStringCount = exactStrings?.size ?? 0;
-    if (exactStringCount === 1 && regexList.length === 0) {
-      const [needle] = exactStrings;
-      return (value) => value === needle;
-    }
-    if (regexList.length === 0) {
-      return (value) => exactStrings.has(value);
-    }
-    if (exactStringCount === 0 && regexList.length === 1) {
-      const [regex] = regexList;
-      return (value) => regex.test(value);
-    }
-    return (value) => {
-      if (exactStrings?.has(value)) {
-        return true;
-      }
-      return regexList.some((regex) => regex.test(value));
-    };
-  }
-  const fuzzyMatcher = exact ? void 0 : buildFuzzyMatcher(fuzzyStrings);
-  const hasRegex = regexList.length > 0;
-  if (fuzzyMatcher && !hasRegex) {
-    return fuzzyMatcher;
-  }
-  if (!fuzzyMatcher && regexList.length === 1) {
-    const [regex] = regexList;
-    return (value) => regex.test(value);
-  }
-  return (value) => {
-    if (fuzzyMatcher?.(value)) {
-      return true;
-    }
-    if (!hasRegex) {
-      return false;
-    }
-    return regexList.some((regex) => regex.test(value));
-  };
-}
-
-// src/js/babel/parse.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
-var parseCache = new LRUCache2(
-  {
-    max: 1024
-  }
-);
-function genCacheKey(source, options) {
-  if (typeof options === "string") {
-    return source + options;
-  }
-  return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
-}
-function babelParse(code, opts = {}) {
-  const { cache, cacheKey, ...rest } = opts;
-  const cacheKeyString = genCacheKey(code, cacheKey ?? rest);
-  let result;
-  if (cache) {
-    result = parseCache.get(cacheKeyString);
-  }
-  if (!result) {
-    const { cache: _cache, cacheKey: _cacheKey, ...parseOptions } = opts;
-    result = parse(code, parseOptions);
-    if (cache) {
-      parseCache.set(cacheKeyString, result);
-    }
-  }
-  return result;
-}
-
-// src/js/babel/process.ts
-import MagicString from "magic-string";
-
-// src/js/handlers.ts
-import { jsStringEscape } from "@ast-core/escape";
-import { splitCode } from "@weapp-tailwindcss/shared/extractors";
-
-// src/wxml/shared.ts
-import { escape, MappingChars2String } from "@weapp-core/escape";
-var NEWLINE_RE = /[\n\r]+/g;
-function replaceWxml(original, options = {
-  keepEOL: false,
-  escapeMap: MappingChars2String
-}) {
-  const { keepEOL, escapeMap, ignoreHead } = options;
-  let res = original;
-  if (!keepEOL) {
-    res = res.replaceAll(NEWLINE_RE, "");
-  }
-  res = escape(res, {
-    map: escapeMap,
-    ignoreHead
-  });
-  return res;
-}
-
-// src/shared/classname-transform.ts
-var escapedCandidateCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
-var defaultEscapedCandidateCache = /* @__PURE__ */ new Map();
-var lastEscapedCandidateEscapeMap;
-var lastEscapedCandidateCacheStore;
-function isUrlLikeCandidate(candidate) {
-  return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
-}
-function isArbitraryValueCandidate(candidate) {
-  let hasOpenBracket = false;
-  let hasCloseBracket = false;
-  for (let i = 0; i < candidate.length; i++) {
-    const char = candidate[i];
-    if (char === "[") {
-      hasOpenBracket = true;
-    } else if (char === "]") {
-      hasCloseBracket = true;
-    }
-    if (hasOpenBracket && hasCloseBracket) {
-      break;
-    }
-  }
-  if (!hasOpenBracket || !hasCloseBracket) {
-    return false;
-  }
-  const normalized = candidate.trim();
-  if (isUrlLikeCandidate(normalized)) {
-    return false;
-  }
-  return true;
-}
-function shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) {
-  if (jsArbitraryValueFallback === true) {
-    return true;
-  }
-  if (jsArbitraryValueFallback === false) {
-    return false;
-  }
-  return tailwindcssMajorVersion === 4 && (!classNameSet || classNameSet.size === 0);
-}
-function shouldEnableArbitraryValueFallback({
-  classNameSet,
-  jsArbitraryValueFallback,
-  tailwindcssMajorVersion
-}) {
-  return shouldEnableArbitraryValueFallbackByInputs(
-    classNameSet,
-    jsArbitraryValueFallback,
-    tailwindcssMajorVersion
-  );
-}
-var SKIP_RESULT = { decision: "skip" };
-var DIRECT_RESULT = { decision: "direct" };
-var FALLBACK_RESULT = { decision: "fallback" };
-function getEscapedCandidateCacheStore(escapeMap) {
-  if (!escapeMap) {
-    return defaultEscapedCandidateCache;
-  }
-  if (escapeMap === lastEscapedCandidateEscapeMap && lastEscapedCandidateCacheStore) {
-    return lastEscapedCandidateCacheStore;
-  }
-  let store = escapedCandidateCacheByEscapeMap.get(escapeMap);
-  if (!store) {
-    store = /* @__PURE__ */ new Map();
-    escapedCandidateCacheByEscapeMap.set(escapeMap, store);
-  }
-  lastEscapedCandidateEscapeMap = escapeMap;
-  lastEscapedCandidateCacheStore = store;
-  return store;
-}
-function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCacheStore(escapeMap)) {
-  let cached = store.get(candidate);
-  if (cached === void 0) {
-    cached = replaceWxml(candidate, { escapeMap });
-    store.set(candidate, cached);
-  }
-  return cached;
-}
-function resolveClassNameTransformWithResult(candidate, {
-  alwaysEscape,
-  classNameSet,
-  escapeMap,
-  jsArbitraryValueFallback,
-  jsPreserveClass,
-  tailwindcssMajorVersion,
-  classContext
-}) {
-  if (alwaysEscape) {
-    return DIRECT_RESULT;
-  }
-  if (jsPreserveClass?.(candidate)) {
-    return SKIP_RESULT;
-  }
-  if (classNameSet?.has(candidate)) {
-    return DIRECT_RESULT;
-  }
-  if (classNameSet && classNameSet.size > 0) {
-    const escapedCandidate = getEscapedCandidate(candidate, escapeMap);
-    if (escapedCandidate !== candidate && classNameSet.has(escapedCandidate)) {
-      return { decision: "escaped", escapedValue: escapedCandidate };
-    }
-  }
-  if (classContext && shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) && isArbitraryValueCandidate(candidate)) {
-    return FALLBACK_RESULT;
-  }
-  return SKIP_RESULT;
-}
-
-// src/utils/decode.ts
-var unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
-var unicodeEscapeTestRE = /\\u[\dA-Fa-f]{4}/;
-function decodeUnicode(value) {
-  if (!unicodeEscapeTestRE.test(value)) {
-    return value;
-  }
-  return value.replace(unicodeEscapeRE, (_match, hex) => {
-    const codePoint = Number.parseInt(hex, 16);
-    return Number.isNaN(codePoint) ? _match : String.fromCharCode(codePoint);
-  });
-}
-function decodeUnicode2(input) {
-  if (!unicodeEscapeTestRE.test(input)) {
-    return input;
-  }
-  try {
-    return JSON.parse(`"${input}"`);
-  } catch (_error) {
-    return decodeUnicode(input);
-  }
-}
-
-// src/js/class-context.ts
-var CLASS_LIKE_KEYWORDS = /* @__PURE__ */ new Set([
-  "class",
-  "classname",
-  "hoverclass",
-  "virtualhostclass",
-  "rootclass"
-]);
-var CLASS_HELPER_IDENTIFIERS = /* @__PURE__ */ new Set([
-  "cn",
-  "clsx",
-  "classnames",
-  "twmerge",
-  "cva",
-  "tv",
-  "cx",
-  "r"
-]);
-var DASH_CODE = 45;
-var COLON_CODE = 58;
-var UPPERCASE_A_CODE = 65;
-var UPPERCASE_Z_CODE = 90;
-var UNDERSCORE_CODE = 95;
-var ASCII_MAX_CODE = 127;
-var NORMALIZE_KEYWORD_REGEXP = /[-_:]/g;
-function normalizeKeyword(name) {
-  const length = name.length;
-  let firstNormalizedIndex = -1;
-  for (let i = 0; i < length; i++) {
-    const code = name.charCodeAt(i);
-    if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE || code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
-      firstNormalizedIndex = i;
-      break;
-    }
-    if (code > ASCII_MAX_CODE) {
-      return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
-    }
-  }
-  if (firstNormalizedIndex === -1) {
-    return name;
-  }
-  let normalized = name.slice(0, firstNormalizedIndex);
-  for (let i = firstNormalizedIndex; i < length; i++) {
-    const code = name.charCodeAt(i);
-    if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE) {
-      continue;
-    }
-    if (code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
-      normalized += String.fromCharCode(code + 32);
-      continue;
-    }
-    if (code > ASCII_MAX_CODE) {
-      return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
-    }
-    normalized += name[i];
-  }
-  return normalized;
-}
-function readObjectKeyName(path5) {
-  if (path5.isIdentifier()) {
-    return path5.node.name;
-  }
-  if (path5.isStringLiteral()) {
-    return path5.node.value;
-  }
-  if (path5.isTemplateLiteral() && path5.node.expressions.length === 0) {
-    return path5.node.quasis[0]?.value.cooked ?? path5.node.quasis[0]?.value.raw;
-  }
-  return void 0;
-}
-function isClassLikeObjectProperty(path5, valuePath) {
-  if (!path5.isObjectProperty()) {
-    return false;
-  }
-  if (path5.get("value") !== valuePath) {
-    return false;
-  }
-  const keyName = readObjectKeyName(path5.get("key"));
-  if (!keyName) {
-    return false;
-  }
-  return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(keyName));
-}
-function isClassLikeJsxAttribute(path5) {
-  if (!path5.isJSXAttribute()) {
-    return false;
-  }
-  const namePath = path5.get("name");
-  if (!namePath.isJSXIdentifier()) {
-    return false;
-  }
-  return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(namePath.node.name));
-}
-function readCallHelperName(calleePath) {
-  if (calleePath.isIdentifier()) {
-    return calleePath.node.name;
-  }
-  if (calleePath.isMemberExpression()) {
-    const propertyPath = calleePath.get("property");
-    if (propertyPath.isIdentifier()) {
-      return propertyPath.node.name;
-    }
-    if (propertyPath.isStringLiteral()) {
-      return propertyPath.node.value;
-    }
-  }
-  return void 0;
-}
-function isClassLikeCallExpression(path5, valuePath) {
-  if (!path5.isCallExpression()) {
-    return false;
-  }
-  const helperName = readCallHelperName(path5.get("callee"));
-  if (!helperName || !CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(helperName))) {
-    return false;
-  }
-  return path5.get("arguments").some((argumentPath) => argumentPath.node === valuePath.node);
-}
-function isClassContextLiteralPath(path5) {
-  let current = path5;
-  while (current.parentPath) {
-    const parent = current.parentPath;
-    if (isClassLikeObjectProperty(parent, current)) {
-      return true;
-    }
-    if (isClassLikeJsxAttribute(parent)) {
-      return true;
-    }
-    if (isClassLikeCallExpression(parent, current)) {
-      return true;
-    }
-    current = parent;
-  }
-  return false;
-}
-
-// src/js/handlers.ts
-var debug2 = createDebug("[js:handlers] ");
-var replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
-var defaultReplacementCache = /* @__PURE__ */ new Map();
-var WEAPP_TW_IGNORE_MARKER = "weapp-tw";
-var IGNORE_MARKER = "ignore";
-function getReplacementCacheStore(escapeMap) {
-  if (!escapeMap) {
-    return defaultReplacementCache;
-  }
-  let store = replacementCacheByEscapeMap.get(escapeMap);
-  if (!store) {
-    store = /* @__PURE__ */ new Map();
-    replacementCacheByEscapeMap.set(escapeMap, store);
-  }
-  return store;
-}
-function getReplacement(candidate, escapeMap, store = getReplacementCacheStore(escapeMap)) {
-  let cached = store.get(candidate);
-  if (cached === void 0) {
-    cached = replaceWxml(candidate, { escapeMap });
-    store.set(candidate, cached);
-  }
-  return cached;
-}
-function hasIgnoreComment(node) {
-  const { leadingComments } = node;
-  if (!Array.isArray(leadingComments) || leadingComments.length === 0) {
-    return false;
-  }
-  for (const comment of leadingComments) {
-    const { value } = comment;
-    if (value.includes(WEAPP_TW_IGNORE_MARKER) && value.includes(IGNORE_MARKER)) {
-      return true;
-    }
-  }
-  return false;
-}
-function extractLiteralValue(path5, { unescapeUnicode, arbitraryValues }) {
-  const allowDoubleQuotes = arbitraryValues?.allowDoubleQuotes;
-  const { node } = path5;
-  let offset = 0;
-  let original;
-  if (node.type === "StringLiteral") {
-    offset = 1;
-    original = node.value;
-  } else if (node.type === "TemplateElement") {
-    original = node.value.raw;
-  } else {
-    original = "";
-  }
-  let literal = original;
-  if (unescapeUnicode && original.includes("\\u")) {
-    literal = decodeUnicode2(original);
-  }
-  return {
-    allowDoubleQuotes,
-    literal,
-    offset,
-    original
-  };
-}
-function createCandidatePlanResolver(options, classContext) {
-  const { escapeMap } = options;
-  const replacementCache = getReplacementCacheStore(escapeMap);
-  const transformOptions = classContext ? {
-    ...options,
-    classContext
-  } : options;
-  let firstCandidate = "";
-  let firstPlan;
-  let cache;
-  const buildCandidatePlan = (candidate) => {
-    const result = resolveClassNameTransformWithResult(candidate, transformOptions);
-    if (result.decision === "skip") {
-      return { result };
-    }
-    let replacement;
-    if (result.decision === "escaped" && result.escapedValue) {
-      replacement = result.escapedValue;
-      replacementCache.set(candidate, replacement);
-    } else {
-      replacement = getReplacement(candidate, escapeMap, replacementCache);
-    }
-    return {
-      result,
-      replacement
-    };
-  };
-  return (candidate) => {
-    if (cache) {
-      const cached = cache.get(candidate);
-      if (cached) {
-        return cached;
-      }
-    } else if (firstPlan && candidate === firstCandidate) {
-      return firstPlan;
-    }
-    const plan = buildCandidatePlan(candidate);
-    if (!firstPlan) {
-      firstCandidate = candidate;
-      firstPlan = plan;
-      return plan;
-    }
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      cache.set(firstCandidate, firstPlan);
-    }
-    cache.set(candidate, plan);
-    return plan;
-  };
-}
-function replaceHandleValue(path5, options) {
-  const { needEscaped = false } = options;
-  const { classNameSet, alwaysEscape } = options;
-  const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
-  if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) {
-    return void 0;
-  }
-  if (hasIgnoreComment(path5.node)) {
-    return void 0;
-  }
-  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path5, options);
-  const candidates = splitCode(literal, allowDoubleQuotes);
-  if (candidates.length === 0) {
-    return void 0;
-  }
-  const debugEnabled = debug2.enabled;
-  const classContext = options.wrapExpression || isClassContextLiteralPath(path5);
-  let transformed = literal;
-  let mutated = false;
-  let matchedCandidateCount = 0;
-  let escapedDecisionCount = 0;
-  let fallbackDecisionCount = 0;
-  let escapedSamples;
-  let skippedSamples;
-  const resolveCandidatePlan = createCandidatePlanResolver(options, classContext);
-  for (const candidate of candidates) {
-    const plan = resolveCandidatePlan(candidate);
-    if (plan.result.decision === "skip") {
-      if (debugEnabled) {
-        if (!skippedSamples) {
-          skippedSamples = [];
-        }
-        if (skippedSamples.length < 6) {
-          skippedSamples.push(candidate);
-        }
-      }
-      continue;
-    }
-    if (debugEnabled) {
-      matchedCandidateCount += 1;
-      if (plan.result.decision === "escaped") {
-        escapedDecisionCount += 1;
-        if (!escapedSamples) {
-          escapedSamples = [];
-        }
-        if (escapedSamples.length < 6) {
-          escapedSamples.push(candidate);
-        }
-      }
-      if (plan.result.decision === "fallback") {
-        fallbackDecisionCount += 1;
-      }
-    }
-    const replaced = transformed.replace(candidate, plan.replacement);
-    if (replaced !== transformed) {
-      transformed = replaced;
-      mutated = true;
-    }
-  }
-  const node = path5.node;
-  if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") {
-    return void 0;
-  }
-  if (debugEnabled) {
-    debug2(
-      "runtimeSet size=%d fallbackTriggered=%s candidates=%d matched=%d escapedHits=%d skipped=%d file=%s escapedSamples=%s skippedSamples=%s",
-      classNameSet?.size ?? 0,
-      fallbackDecisionCount > 0,
-      candidates.length,
-      matchedCandidateCount,
-      escapedDecisionCount,
-      skippedSamples?.length ?? 0,
-      options.filename ?? "unknown",
-      escapedSamples?.join(",") || "-",
-      skippedSamples?.join(",") || "-"
-    );
-  }
-  const start = node.start + offset;
-  const end = node.end - offset;
-  if (start >= end || transformed === original) {
-    return void 0;
-  }
-  const value = needEscaped ? jsStringEscape(transformed) : transformed;
-  return {
-    start,
-    end,
-    value,
-    path: path5
-  };
-}
-
-// src/js/sourceAnalysis.ts
-function hasReplacementEntries(replacements) {
-  for (const key in replacements) {
-    if (Object.hasOwn(replacements, key)) {
-      return true;
-    }
-  }
-  return false;
-}
-function createModuleSpecifierReplacementToken(path5, replacement) {
-  const node = path5.node;
-  if (node.value === replacement) {
-    return void 0;
-  }
-  if (typeof node.start !== "number" || typeof node.end !== "number") {
-    return void 0;
-  }
-  const start = node.start + 1;
-  const end = node.end - 1;
-  if (start >= end) {
-    return void 0;
-  }
-  return {
-    start,
-    end,
-    value: replacement,
-    path: path5
-  };
-}
-function collectModuleSpecifierReplacementTokens(analysis, replacements) {
-  if (!hasReplacementEntries(replacements)) {
-    return [];
-  }
-  if (analysis.importDeclarations.size === 0 && analysis.exportDeclarations.size === 0 && analysis.requireCallPaths.length === 0 && analysis.walker.imports.size === 0) {
-    return [];
-  }
-  const tokens = [];
-  const applyReplacement = (path5) => {
-    const replacement = replacements[path5.node.value];
-    if (!replacement) {
-      return;
-    }
-    const token = createModuleSpecifierReplacementToken(path5, replacement);
-    if (token) {
-      tokens.push(token);
-    }
-  };
-  for (const importPath of analysis.importDeclarations) {
-    const source = importPath.get("source");
-    if (source.isStringLiteral()) {
-      applyReplacement(source);
-    }
-  }
-  for (const exportPath of analysis.exportDeclarations) {
-    if (exportPath.isExportNamedDeclaration() || exportPath.isExportAllDeclaration()) {
-      const source = exportPath.get("source");
-      if (source && !Array.isArray(source) && source.isStringLiteral()) {
-        applyReplacement(source);
-      }
-    }
-  }
-  for (const literalPath of analysis.requireCallPaths) {
-    applyReplacement(literalPath);
-  }
-  for (const token of analysis.walker.imports) {
-    const replacement = replacements[token.source];
-    if (replacement) {
-      token.source = replacement;
-    }
-  }
-  return tokens;
-}
-
-// src/js/babel/process.ts
-var optionVariantsCache = /* @__PURE__ */ new WeakMap();
-function getNeedEscapedOptions(options, needEscaped) {
-  if (options.needEscaped === needEscaped) {
-    return options;
-  }
-  let cached = optionVariantsCache.get(options);
-  if (!cached) {
-    cached = {};
-    optionVariantsCache.set(options, cached);
-  }
-  if (needEscaped) {
-    if (!cached.stringLiteralOptions) {
-      cached.stringLiteralOptions = {
-        ...options,
-        needEscaped: true
-      };
-    }
-    return cached.stringLiteralOptions;
-  }
-  if (!cached.templateLiteralOptions) {
-    cached.templateLiteralOptions = {
-      ...options,
-      needEscaped: false
-    };
-  }
-  return cached.templateLiteralOptions;
-}
-function processUpdatedSource(rawSource, options, analysis) {
-  const { targetPaths, jsTokenUpdater, ignoredPaths } = analysis;
-  if (targetPaths.length === 0 && !options.moduleSpecifierReplacements && jsTokenUpdater.length === 0) {
-    return new MagicString(rawSource);
-  }
-  const replacementTokens = [];
-  for (const path5 of targetPaths) {
-    if (ignoredPaths.has(path5)) {
-      continue;
-    }
-    const token = replaceHandleValue(
-      path5,
-      path5.isStringLiteral() ? getNeedEscapedOptions(options, true) : getNeedEscapedOptions(options, false)
-    );
-    if (token) {
-      replacementTokens.push(token);
-    }
-  }
-  if (options.moduleSpecifierReplacements) {
-    replacementTokens.push(
-      ...collectModuleSpecifierReplacementTokens(analysis, options.moduleSpecifierReplacements)
-    );
-  }
-  if (jsTokenUpdater.length + replacementTokens.length === 0) {
-    return new MagicString(rawSource);
-  }
-  const ms = new MagicString(rawSource);
-  jsTokenUpdater.push(...replacementTokens).filter((token) => !ignoredPaths.has(token.path)).updateMagicString(ms);
-  return ms;
-}
-
-// src/js/evalTransforms.ts
-import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
-var evalHandlerOptionsCache = /* @__PURE__ */ new WeakMap();
-var EVAL_SCOPE_ERROR_REGEXP = /pass a scope and parentPath|traversing a Program\/File/i;
-function isEvalPath(path5) {
-  if (path5.isCallExpression()) {
-    const calleePath = path5.get("callee");
-    return calleePath.isIdentifier({ name: "eval" });
-  }
-  return false;
-}
-function createEvalReplacementToken(path5, updated) {
-  const node = path5.node;
-  let offset = 0;
-  let original;
-  if (path5.isStringLiteral()) {
-    offset = 1;
-    original = path5.node.value;
-  } else if (path5.isTemplateElement()) {
-    original = path5.node.value.raw;
-  } else {
-    original = "";
-  }
-  if (typeof node.start !== "number" || typeof node.end !== "number") {
-    return void 0;
-  }
-  const start = node.start + offset;
-  const end = node.end - offset;
-  if (start >= end) {
-    return void 0;
-  }
-  if (original === updated) {
-    return void 0;
-  }
-  const value = path5.isStringLiteral() ? jsStringEscape2(updated) : updated;
-  return {
-    start,
-    end,
-    value,
-    path: path5
-  };
-}
-function handleEvalStringLiteral(path5, handlerOptions, updater, handler) {
-  const { code } = handler(path5.node.value, handlerOptions);
-  if (!code) {
-    return;
-  }
-  const token = createEvalReplacementToken(path5, code);
-  if (token) {
-    updater.addToken(token);
-  }
-}
-function handleEvalTemplateElement(path5, handlerOptions, updater, handler) {
-  const { code } = handler(path5.node.value.raw, handlerOptions);
-  if (!code) {
-    return;
-  }
-  const token = createEvalReplacementToken(path5, code);
-  if (token) {
-    updater.addToken(token);
-  }
-}
-function getEvalStringHandlerOptions(options) {
-  if (options.needEscaped === false && options.generateMap === false) {
-    return options;
-  }
-  let cached = evalHandlerOptionsCache.get(options);
-  if (!cached) {
-    cached = {};
-    evalHandlerOptionsCache.set(options, cached);
-  }
-  if (!cached.stringLiteralOptions) {
-    cached.stringLiteralOptions = {
-      ...options,
-      needEscaped: false,
-      generateMap: false
-    };
-  }
-  return cached.stringLiteralOptions;
-}
-function getEvalTemplateHandlerOptions(options) {
-  if (options.generateMap === false) {
-    return options;
-  }
-  let cached = evalHandlerOptionsCache.get(options);
-  if (!cached) {
-    cached = {};
-    evalHandlerOptionsCache.set(options, cached);
-  }
-  if (!cached.templateLiteralOptions) {
-    cached.templateLiteralOptions = {
-      ...options,
-      generateMap: false
-    };
-  }
-  return cached.templateLiteralOptions;
-}
-function walkEvalExpression(path5, options, updater, handler) {
-  const stringHandlerOptions = getEvalStringHandlerOptions(options);
-  const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
-  const maybeTraverse = path5?.traverse;
-  if (typeof maybeTraverse === "function") {
-    try {
-      return maybeTraverse.call(path5, {
-        StringLiteral(innerPath) {
-          handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler);
-        },
-        TemplateElement(innerPath) {
-          handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler);
-        }
-      });
-    } catch (error) {
-      const msg = error?.message ?? "";
-      const scopeError = EVAL_SCOPE_ERROR_REGEXP.test(msg);
-      if (!scopeError) {
-        throw error;
-      }
-    }
-  }
-  const getArgs = path5?.get?.("arguments");
-  if (Array.isArray(getArgs)) {
-    for (const arg of getArgs) {
-      if (arg?.isStringLiteral?.()) {
-        handleEvalStringLiteral(arg, stringHandlerOptions, updater, handler);
-        continue;
-      }
-      if (arg?.isTemplateLiteral?.()) {
-        for (const quasi of arg.get("quasis")) {
-          handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler);
-        }
-      }
-    }
-    return;
-  }
-  const nodeArgs = path5?.node?.arguments;
-  if (Array.isArray(nodeArgs)) {
-    for (const n of nodeArgs) {
-      if (n?.type === "StringLiteral") {
-        const stub = {
-          node: n,
-          isStringLiteral: () => true
-        };
-        handleEvalStringLiteral(stub, stringHandlerOptions, updater, handler);
-      } else if (n?.type === "TemplateLiteral" && Array.isArray(n.quasis)) {
-        for (const q of n.quasis) {
-          const stub = {
-            node: q,
-            isStringLiteral: () => false,
-            isTemplateElement: () => true
-          };
-          handleEvalTemplateElement(stub, templateHandlerOptions, updater, handler);
-        }
-      }
-    }
-  }
-}
-
-// src/js/JsTokenUpdater.ts
-var JsTokenUpdater = class {
-  constructor({ value } = {}) {
-    this.tokens = value ? [...value] : [];
-  }
-  addToken(token) {
-    if (token) {
-      this.tokens.push(token);
-    }
-  }
-  push(...args) {
-    this.tokens.push(...args);
-    return this;
-  }
-  /**
-   * 待写入的 token 数量。
-   */
-  get length() {
-    return this.tokens.length;
-  }
-  map(callbackfn) {
-    this.tokens = this.tokens.map(callbackfn);
-    return this;
-  }
-  filter(callbackfn) {
-    this.tokens = this.tokens.filter(callbackfn);
-    return this;
-  }
-  updateMagicString(ms) {
-    for (const { start, end, value } of this.tokens) {
-      ms.update(start, end, value);
-    }
-    return ms;
-  }
-};
-
-// src/js/module-graph/ignored-exports.ts
-var IgnoredExportsTracker = class {
-  constructor(options) {
-    this.options = options;
-    this.ignoredExportNames = /* @__PURE__ */ new Map();
-  }
-  addIgnoredExport(filename, exportName) {
-    if (!exportName) {
-      return;
-    }
-    let pending = this.ignoredExportNames.get(filename);
-    if (!pending) {
-      pending = /* @__PURE__ */ new Set();
-      this.ignoredExportNames.set(filename, pending);
-    }
-    if (pending.has(exportName)) {
-      return;
-    }
-    pending.add(exportName);
-    const existing = this.options.modules.get(filename);
-    if (existing) {
-      this.applyIgnoredExportsToAnalysis(filename, existing.analysis);
-    }
-  }
-  registerIgnoredExportsFromTokens(resolved, tokens) {
-    for (const token of tokens) {
-      if (token.type === "ImportSpecifier") {
-        this.addIgnoredExport(resolved, token.imported);
-      } else if (token.type === "ImportDefaultSpecifier") {
-        this.addIgnoredExport(resolved, "default");
-      }
-    }
-  }
-  applyIgnoredExportsToAnalysis(filename, analysis) {
-    const pending = this.ignoredExportNames.get(filename);
-    if (!pending || pending.size === 0) {
-      return;
-    }
-    const names = new Set(pending);
-    pending.clear();
-    const propagate = [];
-    for (const exportPath of analysis.exportDeclarations) {
-      if (names.size === 0) {
-        break;
-      }
-      if (exportPath.isExportDefaultDeclaration()) {
-        if (names.has("default")) {
-          analysis.walker.walkExportDefaultDeclaration(exportPath);
-          names.delete("default");
-        }
-        continue;
-      }
-      if (exportPath.isExportNamedDeclaration()) {
-        const source = exportPath.node.source?.value;
-        if (typeof source === "string") {
-          for (const spec of exportPath.get("specifiers")) {
-            if (!spec.isExportSpecifier()) {
-              continue;
-            }
-            const exported = spec.get("exported");
-            let exportedName;
-            if (exported.isIdentifier()) {
-              exportedName = exported.node.name;
-            } else if (exported.isStringLiteral()) {
-              exportedName = exported.node.value;
-            }
-            if (!exportedName || !names.has(exportedName)) {
-              continue;
-            }
-            const local = spec.get("local");
-            if (local.isIdentifier()) {
-              propagate.push({
-                specifier: source,
-                exportName: local.node.name
-              });
-              names.delete(exportedName);
-            } else if (local.isStringLiteral()) {
-              propagate.push({
-                specifier: source,
-                exportName: local.node.value
-              });
-              names.delete(exportedName);
-            }
-          }
-          continue;
-        }
-        const declaration = exportPath.get("declaration");
-        if (declaration.isVariableDeclaration()) {
-          for (const decl of declaration.get("declarations")) {
-            const id = decl.get("id");
-            if (id.isIdentifier()) {
-              const exportName = id.node.name;
-              if (names.has(exportName)) {
-                analysis.walker.walkVariableDeclarator(decl);
-                names.delete(exportName);
-              }
-            }
-          }
-        }
-        for (const spec of exportPath.get("specifiers")) {
-          if (!spec.isExportSpecifier()) {
-            continue;
-          }
-          const exported = spec.get("exported");
-          let exportedName;
-          if (exported.isIdentifier()) {
-            exportedName = exported.node.name;
-          } else if (exported.isStringLiteral()) {
-            exportedName = exported.node.value;
-          }
-          if (!exportedName || !names.has(exportedName)) {
-            continue;
-          }
-          const local = spec.get("local");
-          analysis.walker.walkNode(local);
-          names.delete(exportedName);
-        }
-        continue;
-      }
-      if (exportPath.isExportAllDeclaration()) {
-        const source = exportPath.node.source?.value;
-        if (typeof source === "string") {
-          for (const exportName of names) {
-            propagate.push({
-              specifier: source,
-              exportName
-            });
-          }
-          names.clear();
-        }
-      }
-    }
-    for (const { specifier, exportName } of propagate) {
-      let resolved;
-      try {
-        resolved = this.options.resolve(specifier, filename);
-      } catch {
-        resolved = void 0;
-      }
-      if (!resolved) {
-        pending.add(exportName);
-        continue;
-      }
-      if (this.options.filter && !this.options.filter(resolved, specifier, filename)) {
-        pending.add(exportName);
-        continue;
-      }
-      this.addIgnoredExport(resolved, exportName);
-    }
-    for (const name of names) {
-      pending.add(name);
-    }
-  }
-};
-
-// src/js/ModuleGraph.ts
-var JsModuleGraph = class {
-  constructor(entry, graphOptions) {
-    this.modules = /* @__PURE__ */ new Map();
-    this.queue = [];
-    this.resolve = graphOptions.resolve;
-    this.load = graphOptions.load;
-    this.filter = graphOptions.filter;
-    this.maxDepth = graphOptions.maxDepth ?? Number.POSITIVE_INFINITY;
-    const { moduleGraph: _moduleGraph, filename: _ignoredFilename, ...rest } = entry.handlerOptions;
-    this.baseOptions = {
-      ...rest,
-      filename: entry.filename
-    };
-    this.parserOptions = entry.handlerOptions.babelParserOptions;
-    this.rootFilename = entry.filename;
-    this.ignoredExports = new IgnoredExportsTracker({
-      resolve: this.resolve,
-      filter: this.filter,
-      modules: this.modules
-    });
-    this.modules.set(entry.filename, {
-      filename: entry.filename,
-      source: entry.source,
-      analysis: entry.analysis
-    });
-    this.queue.push({ filename: entry.filename, depth: 0 });
-  }
-  build() {
-    this.collectDependencies();
-    let linked;
-    for (const [filename, state] of this.modules) {
-      if (filename === this.rootFilename) {
-        continue;
-      }
-      const childOptions = {
-        ...this.baseOptions,
-        filename
-      };
-      const ms = processUpdatedSource(state.source, childOptions, state.analysis);
-      const code = ms.toString();
-      if (code !== state.source) {
-        if (!linked) {
-          linked = {};
-        }
-        linked[filename] = { code };
-      }
-    }
-    return linked;
-  }
-  collectDependencies() {
-    while (this.queue.length > 0) {
-      const { filename, depth } = this.queue.shift();
-      if (depth >= this.maxDepth) {
-        continue;
-      }
-      const state = this.modules.get(filename);
-      if (!state) {
-        continue;
-      }
-      const dependencySpecifiers = /* @__PURE__ */ new Map();
-      for (const token of state.analysis.walker.imports) {
-        if (!dependencySpecifiers.has(token.source)) {
-          dependencySpecifiers.set(token.source, []);
-        }
-        dependencySpecifiers.get(token.source).push(token);
-      }
-      for (const exportPath of state.analysis.exportDeclarations) {
-        if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
-          const source = exportPath.node.source?.value;
-          if (typeof source === "string" && !dependencySpecifiers.has(source)) {
-            dependencySpecifiers.set(source, []);
-          }
-        }
-      }
-      for (const [specifier, tokens] of dependencySpecifiers) {
-        let resolved;
-        try {
-          resolved = this.resolve(specifier, filename);
-        } catch {
-          continue;
-        }
-        if (!resolved) {
-          continue;
-        }
-        if (this.filter && !this.filter(resolved, specifier, filename)) {
-          continue;
-        }
-        if (tokens.length > 0) {
-          this.ignoredExports.registerIgnoredExportsFromTokens(resolved, tokens);
-        }
-        if (this.modules.has(resolved)) {
-          continue;
-        }
-        let source;
-        try {
-          source = this.load(resolved);
-        } catch {
-          continue;
-        }
-        if (typeof source !== "string") {
-          continue;
-        }
-        let analysis;
-        try {
-          const ast = babelParse(source, {
-            ...this.parserOptions,
-            sourceFilename: resolved
-          });
-          analysis = analyzeSource(ast, {
-            ...this.baseOptions,
-            filename: resolved
-          });
-          this.ignoredExports.applyIgnoredExportsToAnalysis(resolved, analysis);
-        } catch {
-          continue;
-        }
-        this.modules.set(resolved, {
-          filename: resolved,
-          source,
-          analysis
-        });
-        this.queue.push({ filename: resolved, depth: depth + 1 });
-      }
-    }
-  }
-};
-
-// src/js/node-path-walker/export-handlers.ts
-function walkExportDeclaration(ctx, path5) {
-  if (path5.isExportDeclaration()) {
-    if (path5.isExportNamedDeclaration()) {
-      walkExportNamedDeclaration(ctx, path5);
-    } else if (path5.isExportDefaultDeclaration()) {
-      walkExportDefaultDeclaration(ctx, path5);
-    } else if (path5.isExportAllDeclaration()) {
-      walkExportAllDeclaration(ctx, path5);
-    }
-  }
-}
-function walkExportNamedDeclaration(ctx, path5) {
-  const declaration = path5.get("declaration");
-  if (declaration.isVariableDeclaration()) {
-    for (const decl of declaration.get("declarations")) {
-      ctx.walkNode(decl);
-    }
-  }
-  const specifiers = path5.get("specifiers");
-  for (const spec of specifiers) {
-    if (spec.isExportSpecifier()) {
-      const local = spec.get("local");
-      if (local.isIdentifier()) {
-        ctx.walkNode(local);
-      }
-    }
-  }
-}
-function walkExportDefaultDeclaration(ctx, path5) {
-  const decl = path5.get("declaration");
-  if (decl.isIdentifier()) {
-    ctx.walkNode(decl);
-  } else {
-    ctx.walkNode(decl);
-  }
-}
-function walkExportAllDeclaration(ctx, path5) {
-  const source = path5.get("source");
-  if (source.isStringLiteral()) {
-    ctx.addImportToken(
-      {
-        declaration: path5,
-        source: source.node.value,
-        type: "ExportAllDeclaration"
-      }
-    );
-  }
-}
-
-// src/js/node-path-walker/import-tokens.ts
-function maybeAddImportToken(imports, arg) {
-  if (!(arg.isImportSpecifier() && arg.node.importKind !== "type" || arg.isImportDefaultSpecifier())) {
-    return false;
-  }
-  const importDeclaration = arg.parentPath;
-  if (!importDeclaration.isImportDeclaration() || importDeclaration.node.importKind === "type") {
-    return false;
-  }
-  if (arg.isImportSpecifier()) {
-    const imported = arg.get("imported");
-    if (imported.isIdentifier()) {
-      imports.add(
-        {
-          declaration: importDeclaration,
-          specifier: arg,
-          imported: imported.node.name,
-          local: arg.node.local.name,
-          source: importDeclaration.node.source.value,
-          type: "ImportSpecifier"
-        }
-      );
-    }
-    return true;
-  }
-  imports.add(
-    {
-      declaration: importDeclaration,
-      specifier: arg,
-      local: arg.node.local.name,
-      source: importDeclaration.node.source.value,
-      type: "ImportDefaultSpecifier"
-    }
-  );
-  return true;
-}
-
-// src/js/NodePathWalker.ts
-var EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS = [];
-var EMPTY_IMPORT_TOKENS = /* @__PURE__ */ new Set();
-function NOOP_STRING_PATH_CALLBACK() {
-}
-var NEVER_MATCH_NAME2 = () => false;
-var NodePathWalker = class {
-  constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
-    this.hasIgnoredCallIdentifiers = Boolean(ignoreCallExpressionIdentifiers && ignoreCallExpressionIdentifiers.length > 0);
-    this.ignoreCallExpressionIdentifiers = ignoreCallExpressionIdentifiers ?? EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS;
-    this.callback = callback ?? NOOP_STRING_PATH_CALLBACK;
-    this.isIgnoredCallIdentifier = this.hasIgnoredCallIdentifiers ? createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true }) : NEVER_MATCH_NAME2;
-  }
-  get imports() {
-    return this.importsStore ?? EMPTY_IMPORT_TOKENS;
-  }
-  getWritableImports() {
-    if (!this.importsStore) {
-      this.importsStore = /* @__PURE__ */ new Set();
-    }
-    return this.importsStore;
-  }
-  addImportToken(token) {
-    this.getWritableImports().add(token);
-  }
-  getVisited() {
-    if (!this.visitedStore) {
-      this.visitedStore = /* @__PURE__ */ new WeakSet();
-    }
-    return this.visitedStore;
-  }
-  walkVariableDeclarator(path5) {
-    const init = path5.get("init");
-    this.walkNode(init);
-  }
-  walkTemplateLiteral(path5) {
-    for (const exp of path5.get("expressions")) {
-      this.walkNode(exp);
-    }
-    for (const quasis of path5.get("quasis")) {
-      this.callback(quasis);
-    }
-  }
-  walkStringLiteral(path5) {
-    this.callback(path5);
-  }
-  walkBinaryExpression(path5) {
-    const left = path5.get("left");
-    this.walkNode(left);
-    const right = path5.get("right");
-    this.walkNode(right);
-  }
-  walkLogicalExpression(path5) {
-    const left = path5.get("left");
-    this.walkNode(left);
-    const right = path5.get("right");
-    this.walkNode(right);
-  }
-  walkObjectExpression(path5) {
-    const props = path5.get("properties");
-    for (const prop of props) {
-      if (prop.isObjectProperty()) {
-        const key = prop.get("key");
-        this.walkNode(key);
-        const value = prop.get("value");
-        this.walkNode(value);
-      }
-    }
-  }
-  walkArrayExpression(path5) {
-    const elements = path5.get("elements");
-    for (const element of elements) {
-      this.walkNode(element);
-    }
-  }
-  walkNode(arg) {
-    const visited = this.getVisited();
-    if (visited.has(arg)) {
-      return;
-    }
-    visited.add(arg);
-    if (arg.isIdentifier()) {
-      const binding = arg?.scope?.getBinding?.(arg.node.name);
-      if (binding) {
-        this.walkNode(binding.path);
-      }
-    } else if (arg.isMemberExpression()) {
-      const objectPath = arg.get("object");
-      if (objectPath.isIdentifier()) {
-        const binding = arg?.scope?.getBinding?.(objectPath.node.name);
-        if (binding) {
-          if (binding.path.isVariableDeclarator()) {
-            this.walkVariableDeclarator(binding.path);
-          }
-        }
-      }
-    } else if (arg.isTemplateLiteral()) {
-      this.walkTemplateLiteral(arg);
-    } else if (arg.isStringLiteral()) {
-      this.walkStringLiteral(arg);
-    } else if (arg.isBinaryExpression()) {
-      this.walkBinaryExpression(arg);
-    } else if (arg.isLogicalExpression()) {
-      this.walkLogicalExpression(arg);
-    } else if (arg.isObjectExpression()) {
-      this.walkObjectExpression(arg);
-    } else if (arg.isArrayExpression()) {
-      this.walkArrayExpression(arg);
-    } else if (arg.isVariableDeclarator()) {
-      this.walkVariableDeclarator(arg);
-    } else if (maybeAddImportToken(this.getWritableImports(), arg)) {
-    }
-  }
-  /**
-   * Walk the arguments of a desired call expression so their bindings can be analysed.
-   */
-  walkCallExpression(path5) {
-    if (!this.hasIgnoredCallIdentifiers) {
-      return;
-    }
-    const calleePath = path5.get("callee");
-    if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) {
-      for (const arg of path5.get("arguments")) {
-        this.walkNode(arg);
-      }
-    }
-  }
-  walkExportDeclaration(path5) {
-    walkExportDeclaration(this, path5);
-  }
-  walkExportNamedDeclaration(path5) {
-    walkExportNamedDeclaration(this, path5);
-  }
-  walkExportDefaultDeclaration(path5) {
-    walkExportDefaultDeclaration(this, path5);
-  }
-  walkExportAllDeclaration(path5) {
-    walkExportAllDeclaration(this, path5);
-  }
-};
-
-// src/js/taggedTemplateIgnore.ts
-function createTaggedTemplateIgnore({ matcher, names }) {
-  const bindingIgnoreCache = /* @__PURE__ */ new Map();
-  const taggedTemplateIgnoreCache = /* @__PURE__ */ new WeakMap();
-  const seenBindings = /* @__PURE__ */ new Set();
-  let singleCanonicalIgnoreName;
-  let canonicalIgnoreNames;
-  for (const item of names ?? []) {
-    if (typeof item !== "string") {
-      continue;
-    }
-    if (singleCanonicalIgnoreName === void 0) {
-      singleCanonicalIgnoreName = item;
-      continue;
-    }
-    if (item === singleCanonicalIgnoreName) {
-      continue;
-    }
-    if (!canonicalIgnoreNames) {
-      canonicalIgnoreNames = /* @__PURE__ */ new Set([singleCanonicalIgnoreName, item]);
-      continue;
-    }
-    canonicalIgnoreNames.add(item);
-  }
-  const hasCanonicalIgnoreNames = singleCanonicalIgnoreName !== void 0;
-  const matchesIgnoreName = (value) => {
-    if (hasCanonicalIgnoreNames) {
-      if (canonicalIgnoreNames) {
-        if (canonicalIgnoreNames.has(value)) {
-          return true;
-        }
-      } else if (value === singleCanonicalIgnoreName) {
-        return true;
-      }
-    }
-    return matcher(value);
-  };
-  const propertyMatches = (propertyPath) => {
-    if (!propertyPath) {
-      return false;
-    }
-    if (propertyPath.isIdentifier()) {
-      return matchesIgnoreName(propertyPath.node.name);
-    }
-    if (propertyPath.isStringLiteral()) {
-      return matchesIgnoreName(propertyPath.node.value);
-    }
-    return false;
-  };
-  const resolvesMemberExpressionToIgnore = (path5, seen) => {
-    const propertyPath = path5.get("property");
-    if (propertyMatches(propertyPath)) {
-      return true;
-    }
-    const objectPath = path5.get("object");
-    if (objectPath.isIdentifier()) {
-      const scope = objectPath?.scope;
-      const binding = scope?.getBinding?.(objectPath.node.name);
-      if (binding) {
-        return resolvesToWeappTwIgnore(binding, seen);
-      }
-    }
-    return false;
-  };
-  const resolvesToWeappTwIgnore = (binding, seen) => {
-    const cached = bindingIgnoreCache.get(binding);
-    if (cached !== void 0) {
-      return cached;
-    }
-    if (seen.has(binding)) {
-      return false;
-    }
-    seen.add(binding);
-    let result = false;
-    const bindingPath = binding.path;
-    if (bindingPath.isImportSpecifier()) {
-      const imported = bindingPath.node.imported;
-      if (imported.type === "Identifier" && matchesIgnoreName(imported.name)) {
-        result = true;
-      } else if (imported.type === "StringLiteral" && matchesIgnoreName(imported.value)) {
-        result = true;
-      }
-    } else if (bindingPath.isVariableDeclarator()) {
-      const init = bindingPath.get("init");
-      if (init && init.node) {
-        if (init.isIdentifier()) {
-          const target = binding?.scope?.getBinding?.(init.node.name);
-          if (target) {
-            result = resolvesToWeappTwIgnore(target, seen);
-          }
-        } else if (init.isMemberExpression()) {
-          result = resolvesMemberExpressionToIgnore(init, seen);
-        }
-      }
-    }
-    bindingIgnoreCache.set(binding, result);
-    seen.delete(binding);
-    return result;
-  };
-  const getEffectiveTagPath = (tagPath) => {
-    let current = tagPath;
-    while (true) {
-      if (current.isParenthesizedExpression?.() || current.node.type === "ParenthesizedExpression") {
-        current = current.get("expression");
-        continue;
-      }
-      if (current.isTSAsExpression() || current.isTSTypeAssertion()) {
-        current = current.get("expression");
-        continue;
-      }
-      if (current.isTSNonNullExpression()) {
-        current = current.get("expression");
-        continue;
-      }
-      if (current.isTypeCastExpression?.()) {
-        current = current.get("expression");
-        continue;
-      }
-      if (current.isSequenceExpression()) {
-        const expressions = current.get("expressions");
-        const last = expressions.at(-1);
-        if (last) {
-          current = last;
-          continue;
-        }
-      }
-      if (current.isCallExpression?.() || current.node.type === "CallExpression") {
-        const callee = current.get("callee");
-        current = callee;
-        continue;
-      }
-      break;
-    }
-    return current;
-  };
-  const evaluateTagPath = (tagPath, seen) => {
-    if (tagPath.isCallExpression?.() || tagPath.node.type === "CallExpression") {
-      const calleePath = tagPath.get("callee");
-      return evaluateTagPath(calleePath, seen);
-    }
-    if (tagPath.isIdentifier()) {
-      if (matchesIgnoreName(tagPath.node.name)) {
-        return true;
-      }
-      const binding = tagPath?.scope?.getBinding?.(tagPath.node.name);
-      if (binding) {
-        return resolvesToWeappTwIgnore(binding, seen);
-      }
-      return false;
-    }
-    if (tagPath.isMemberExpression()) {
-      return resolvesMemberExpressionToIgnore(tagPath, seen);
-    }
-    return false;
-  };
-  const computeIgnore = (tagPath) => {
-    const cached = taggedTemplateIgnoreCache.get(tagPath.node);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const effectiveTagPath = getEffectiveTagPath(tagPath);
-    const effectiveCached = taggedTemplateIgnoreCache.get(effectiveTagPath.node);
-    if (effectiveCached !== void 0) {
-      taggedTemplateIgnoreCache.set(tagPath.node, effectiveCached);
-      return effectiveCached;
-    }
-    seenBindings.clear();
-    const result = evaluateTagPath(effectiveTagPath, seenBindings);
-    taggedTemplateIgnoreCache.set(effectiveTagPath.node, result);
-    taggedTemplateIgnoreCache.set(tagPath.node, result);
-    return result;
-  };
-  return {
-    shouldIgnore(tagPath) {
-      return computeIgnore(tagPath);
-    },
-    getEffectiveTagPath
-  };
-}
-
-// src/js/babel.ts
-var EXPRESSION_WRAPPER_PREFIX = "(\n";
-var EXPRESSION_WRAPPER_SUFFIX = "\n)";
-var EMPTY_IGNORED_PATHS = /* @__PURE__ */ new WeakSet();
-var EMPTY_IMPORT_DECLARATIONS = /* @__PURE__ */ new Set();
-var EMPTY_EXPORT_DECLARATIONS = /* @__PURE__ */ new Set();
-var EMPTY_REQUIRE_CALL_PATHS = [];
-var ignoredTaggedTemplateMatcherCache = /* @__PURE__ */ new WeakMap();
-var defaultEvalHandler;
-function getIgnoredTaggedTemplateMatcher(options) {
-  const cached = ignoredTaggedTemplateMatcherCache.get(options);
-  if (cached) {
-    return cached;
-  }
-  const created = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
-  ignoredTaggedTemplateMatcherCache.set(options, created);
-  return created;
-}
-function getDefaultEvalHandler() {
-  if (!defaultEvalHandler) {
-    throw new Error("Default JS eval handler is not initialized.");
-  }
-  return defaultEvalHandler;
-}
-function analyzeSource(ast, options, handler, collectModuleMetadata = true) {
-  const jsTokenUpdater = new JsTokenUpdater();
-  const needScope = Boolean(options.ignoreCallExpressionIdentifiers && options.ignoreCallExpressionIdentifiers.length > 0);
-  const ignoredPaths = needScope ? /* @__PURE__ */ new WeakSet() : EMPTY_IGNORED_PATHS;
-  const walker = needScope ? new NodePathWalker({
-    ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
-    callback(path5) {
-      ignoredPaths.add(path5);
-    }
-  }) : new NodePathWalker();
-  let taggedTemplateIgnore;
-  const hasTaggedTemplateIgnoreIdentifiers = Boolean(
-    options.ignoreTaggedTemplateExpressionIdentifiers && options.ignoreTaggedTemplateExpressionIdentifiers.length > 0
-  );
-  function getTaggedTemplateIgnore() {
-    if (!taggedTemplateIgnore) {
-      taggedTemplateIgnore = createTaggedTemplateIgnore({
-        matcher: getIgnoredTaggedTemplateMatcher(options),
-        names: options.ignoreTaggedTemplateExpressionIdentifiers
-      });
-    }
-    return taggedTemplateIgnore;
-  }
-  const targetPaths = [];
-  const importDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_IMPORT_DECLARATIONS;
-  const exportDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_EXPORT_DECLARATIONS;
-  const requireCallPaths = collectModuleMetadata ? [] : EMPTY_REQUIRE_CALL_PATHS;
-  const evalHandler = handler ?? getDefaultEvalHandler();
-  const templateElementEnter = hasTaggedTemplateIgnoreIdentifiers ? (p) => {
-    const pp = p.parentPath;
-    if (pp.isTemplateLiteral()) {
-      const ppp = pp.parentPath;
-      if (isEvalPath(ppp)) {
-        return;
-      }
-      if (ppp.isTaggedTemplateExpression()) {
-        const tagPath = ppp.get("tag");
-        if (getTaggedTemplateIgnore().shouldIgnore(tagPath)) {
-          return;
-        }
-      }
-    }
-    targetPaths.push(p);
-  } : (p) => {
-    const pp = p.parentPath;
-    if (pp.isTemplateLiteral()) {
-      const ppp = pp.parentPath;
-      if (isEvalPath(ppp)) {
-        return;
-      }
-    }
-    targetPaths.push(p);
-  };
-  const callExpressionEnter = !collectModuleMetadata && !needScope ? (p) => {
-    if (isEvalPath(p)) {
-      walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
-    }
-  } : (p) => {
-    if (isEvalPath(p)) {
-      walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
-      return;
-    }
-    const calleePath = p.get("callee");
-    if (collectModuleMetadata && calleePath.isIdentifier({ name: "require" }) && !p?.scope?.hasBinding?.("require")) {
-      const args = p.get("arguments");
-      if (Array.isArray(args) && args.length > 0) {
-        const first = args[0];
-        if (first?.isStringLiteral()) {
-          requireCallPaths.push(first);
-        }
-      }
-    }
-    if (needScope) {
-      walker.walkCallExpression(p);
-    }
-  };
-  const traverseOptions = {
-    StringLiteral: {
-      enter(p) {
-        if (isEvalPath(p.parentPath)) {
-          return;
-        }
-        targetPaths.push(p);
-      }
-    },
-    TemplateElement: {
-      enter: templateElementEnter
-    },
-    CallExpression: {
-      enter: callExpressionEnter
-    },
-    ...collectModuleMetadata ? {
-      ImportDeclaration: {
-        enter(p) {
-          importDeclarations.add(p);
-        }
-      },
-      ExportDeclaration: {
-        enter(p) {
-          exportDeclarations.add(p);
-        }
-      }
-    } : {}
-  };
-  traverse(ast, { ...traverseOptions, noScope: !needScope });
-  return {
-    walker,
-    jsTokenUpdater,
-    ast,
-    targetPaths,
-    importDeclarations,
-    exportDeclarations,
-    requireCallPaths,
-    ignoredPaths
-  };
-}
-function jsHandler(rawSource, options) {
-  const shouldWrapExpression = Boolean(options.wrapExpression);
-  const source = shouldWrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
-  let ast;
-  try {
-    ast = babelParse(source, options.babelParserOptions);
-  } catch (error) {
-    return {
-      code: rawSource,
-      error
-    };
-  }
-  const needsModuleMetadata = Boolean(options.moduleSpecifierReplacements || options.moduleGraph && options.filename);
-  const analysis = analyzeSource(ast, options, jsHandler, needsModuleMetadata);
-  const ms = processUpdatedSource(source, options, analysis);
-  if (shouldWrapExpression) {
-    const start = 0;
-    const end = source.length;
-    const prefixLength = EXPRESSION_WRAPPER_PREFIX.length;
-    const suffixLength = EXPRESSION_WRAPPER_SUFFIX.length;
-    ms.remove(start, start + prefixLength);
-    ms.remove(end - suffixLength, end);
-  }
-  const result = {
-    code: ms.toString()
-  };
-  if (options.generateMap) {
-    Object.defineProperty(result, "map", {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return ms.generateMap();
-      }
-    });
-  }
-  if (options.moduleGraph && options.filename) {
-    const graph = new JsModuleGraph(
-      {
-        filename: options.filename,
-        source: rawSource,
-        analysis,
-        handlerOptions: options
-      },
-      options.moduleGraph
-    );
-    const linked = graph.build();
-    if (linked) {
-      result.linked = linked;
-    }
-  }
-  return result;
-}
-defaultEvalHandler = jsHandler;
-
-// src/js/index.ts
-var RESULT_CACHE_MAX = 512;
-var CACHEABLE_SOURCE_MAX_LENGTH = 512;
-var classNameSetIds = /* @__PURE__ */ new WeakMap();
-var nextClassNameSetId = 0;
-function getClassNameSetId(set) {
-  if (!set) {
-    return "none";
-  }
-  const existing = classNameSetIds.get(set);
-  if (existing !== void 0) {
-    return String(existing);
-  }
-  const id = nextClassNameSetId++;
-  classNameSetIds.set(set, id);
-  return String(id);
-}
-var fingerprintCache = /* @__PURE__ */ new WeakMap();
-function getOptionsFingerprint(options) {
-  const cached = fingerprintCache.get(options);
-  if (cached) {
-    return cached;
-  }
-  const parts = [
-    getClassNameSetId(options.classNameSet),
-    JSON.stringify(options.escapeMap ?? null),
-    options.needEscaped ? "1" : "0",
-    options.alwaysEscape ? "1" : "0",
-    options.unescapeUnicode ? "1" : "0",
-    options.generateMap ? "1" : "0",
-    options.uniAppX ? "1" : "0",
-    options.wrapExpression ? "1" : "0",
-    String(options.tailwindcssMajorVersion ?? ""),
-    String(options.staleClassNameFallback ?? ""),
-    String(options.jsArbitraryValueFallback ?? ""),
-    JSON.stringify(options.arbitraryValues ?? null),
-    JSON.stringify(options.ignoreCallExpressionIdentifiers ?? null),
-    JSON.stringify(options.ignoreTaggedTemplateExpressionIdentifiers?.map((v) => v instanceof RegExp ? v.source : v) ?? null),
-    JSON.stringify(options.moduleSpecifierReplacements ?? null),
-    JSON.stringify(options.babelParserOptions ?? null)
-  ];
-  const fingerprint = parts.join("|");
-  fingerprintCache.set(options, fingerprint);
-  return fingerprint;
-}
-function hasDefinedOverrides(options) {
-  if (!options) {
-    return false;
-  }
-  for (const key in options) {
-    if (options[key] !== void 0) {
-      return true;
-    }
-  }
-  return false;
-}
-function shouldCacheJsResult(rawSource, options) {
-  if (rawSource.length === 0 || rawSource.length > CACHEABLE_SOURCE_MAX_LENGTH) {
-    return false;
-  }
-  if (options.moduleGraph || options.filename) {
-    return false;
-  }
-  return true;
-}
-function createJsHandler(options) {
-  const defaults = {
-    escapeMap: options.escapeMap,
-    staleClassNameFallback: options.staleClassNameFallback,
-    jsArbitraryValueFallback: options.jsArbitraryValueFallback,
-    tailwindcssMajorVersion: options.tailwindcssMajorVersion,
-    arbitraryValues: options.arbitraryValues,
-    jsPreserveClass: options.jsPreserveClass,
-    generateMap: options.generateMap,
-    needEscaped: options.needEscaped,
-    alwaysEscape: options.alwaysEscape,
-    unescapeUnicode: options.unescapeUnicode,
-    babelParserOptions: options.babelParserOptions,
-    ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
-    ignoreTaggedTemplateExpressionIdentifiers: options.ignoreTaggedTemplateExpressionIdentifiers,
-    uniAppX: options.uniAppX,
-    moduleSpecifierReplacements: options.moduleSpecifierReplacements
-  };
-  const defaultOptionsCache = /* @__PURE__ */ new WeakMap();
-  let resolvedOptionsWithoutClassNameSet;
-  const overrideOptionsCache = /* @__PURE__ */ new WeakMap();
-  const resultCache = new LRUCache3({ max: RESULT_CACHE_MAX });
-  function resolveDefaultOptions(classNameSet) {
-    if (!classNameSet) {
-      if (!resolvedOptionsWithoutClassNameSet) {
-        resolvedOptionsWithoutClassNameSet = {
-          ...defaults,
-          classNameSet
-        };
-      }
-      return resolvedOptionsWithoutClassNameSet;
-    }
-    const cached = defaultOptionsCache.get(classNameSet);
-    if (cached) {
-      return cached;
-    }
-    const created = {
-      ...defaults,
-      classNameSet
-    };
-    defaultOptionsCache.set(classNameSet, created);
-    return created;
-  }
-  function getCachedJsResult(rawSource, resolvedOptions) {
-    if (!shouldCacheJsResult(rawSource, resolvedOptions)) {
-      return void 0;
-    }
-    const key = `${getOptionsFingerprint(resolvedOptions)}:${md5(rawSource)}`;
-    return resultCache.get(key);
-  }
-  function setCachedJsResult(rawSource, resolvedOptions, result) {
-    if (!shouldCacheJsResult(rawSource, resolvedOptions) || result.error || result.linked) {
-      return result;
-    }
-    const key = `${getOptionsFingerprint(resolvedOptions)}:${md5(rawSource)}`;
-    resultCache.set(key, result);
-    return result;
-  }
-  function resolveOptions(classNameSet, overrideOptions) {
-    if (!hasDefinedOverrides(overrideOptions)) {
-      return resolveDefaultOptions(classNameSet);
-    }
-    let entry = overrideOptionsCache.get(overrideOptions);
-    if (!entry) {
-      entry = { bySet: /* @__PURE__ */ new WeakMap() };
-      overrideOptionsCache.set(overrideOptions, entry);
-    }
-    if (!classNameSet) {
-      if (entry.noSet) {
-        return entry.noSet;
-      }
-      const created2 = defuOverrideArray(
-        {
-          ...overrideOptions,
-          classNameSet
-        },
-        defaults
-      );
-      entry.noSet = created2;
-      return created2;
-    }
-    const cached = entry.bySet.get(classNameSet);
-    if (cached) {
-      return cached;
-    }
-    const created = defuOverrideArray(
-      {
-        ...overrideOptions,
-        classNameSet
-      },
-      defaults
-    );
-    entry.bySet.set(classNameSet, created);
-    return created;
-  }
-  function handler(rawSource, classNameSet, options2) {
-    const resolvedOptions = resolveOptions(classNameSet, options2);
-    const cached = getCachedJsResult(rawSource, resolvedOptions);
-    if (cached) {
-      return cached;
-    }
-    return setCachedJsResult(rawSource, resolvedOptions, jsHandler(rawSource, resolvedOptions));
-  }
-  return handler;
-}
-
-// src/wxml/custom-attributes.ts
-function regTest(reg, str) {
-  reg.lastIndex = 0;
-  return reg.test(str);
-}
-function isPropsMatch(props, attr) {
-  if (Array.isArray(props)) {
-    let lowerAttr;
-    for (const prop of props) {
-      if (typeof prop === "string") {
-        lowerAttr ?? (lowerAttr = attr.toLowerCase());
-        if (prop.toLowerCase() === lowerAttr) {
-          return true;
-        }
-      } else if (regTest(prop, attr)) {
-        return true;
-      }
-    }
-    return false;
-  } else if (typeof props === "string") {
-    return props === attr;
-  } else {
-    return regTest(props, attr);
-  }
-}
-function createAttributeMatcher(entities) {
-  if (!entities || entities.length === 0) {
-    return void 0;
-  }
-  const wildcardAttributeRules = [];
-  const tagAttributeRuleMap = /* @__PURE__ */ new Map();
-  const regexpAttributeRules = [];
-  for (const [selector, props] of entities) {
-    if (selector === "*") {
-      wildcardAttributeRules.push(props);
-    } else if (typeof selector === "string") {
-      const list = tagAttributeRuleMap.get(selector);
-      if (list) {
-        list.push(props);
-      } else {
-        tagAttributeRuleMap.set(selector, [props]);
-      }
-    } else {
-      regexpAttributeRules.push([selector, props]);
-    }
-  }
-  return (tag, attr) => {
-    for (const props of wildcardAttributeRules) {
-      if (isPropsMatch(props, attr)) {
-        return true;
-      }
-    }
-    const tagRules = tagAttributeRuleMap.get(tag);
-    if (tagRules) {
-      for (const props of tagRules) {
-        if (isPropsMatch(props, attr)) {
-          return true;
-        }
-      }
-    }
-    for (const [selector, props] of regexpAttributeRules) {
-      if (regTest(selector, tag) && isPropsMatch(props, attr)) {
-        return true;
-      }
-    }
-    return false;
-  };
-}
-
-// src/wxml/utils/codegen/legacy-rewriter.ts
-import MagicString2 from "magic-string";
-
-// src/wxml/utils/codegen/legacy-visitor.ts
-import * as t from "@babel/types";
-function shouldSkipLegacyStringLiteral(path5) {
-  if (t.isMemberExpression(path5.parent)) {
-    return true;
-  }
-  return Boolean(
-    t.isBinaryExpression(path5.parent) && (t.isConditionalExpression(path5.parentPath?.parent) || t.isLogicalExpression(path5.parentPath?.parent))
-  );
-}
-function createLegacyTraverseOptions(options, jsTokenUpdater) {
-  const legacyReplaceOptions = {
-    escapeMap: options.escapeMap,
-    classNameSet: options.runtimeSet,
-    needEscaped: true,
-    alwaysEscape: true
-  };
-  return {
-    StringLiteral(path5) {
-      if (shouldSkipLegacyStringLiteral(path5)) {
-        return;
-      }
-      jsTokenUpdater.addToken(
-        replaceHandleValue(
-          path5,
-          legacyReplaceOptions
-        )
-      );
-    },
-    noScope: true
-  };
-}
-
-// src/wxml/utils/codegen/legacy-rewriter.ts
-function rewriteLegacyExpression(match, options) {
-  const ast = parseExpression(match);
-  const jsTokenUpdater = new JsTokenUpdater();
-  traverse(ast, createLegacyTraverseOptions(options, jsTokenUpdater));
-  if (jsTokenUpdater.length === 0) {
-    return match;
-  }
-  const ms = new MagicString2(match);
-  jsTokenUpdater.updateMagicString(ms);
-  return ms.toString();
-}
-
-// src/wxml/utils/codegen.ts
-var WRAP_EXPRESSION_HANDLER_OPTIONS = Object.freeze({
-  wrapExpression: true
-});
-function generateCode(match, options = {}) {
-  try {
-    const { jsHandler: jsHandler2, runtimeSet, wrapExpression } = options;
-    if (jsHandler2 && runtimeSet) {
-      const initial = jsHandler2(
-        match,
-        runtimeSet,
-        wrapExpression ? WRAP_EXPRESSION_HANDLER_OPTIONS : void 0
-      );
-      if (!initial.error || wrapExpression) {
-        return initial.code;
-      }
-      const fallback = jsHandler2(match, runtimeSet, WRAP_EXPRESSION_HANDLER_OPTIONS);
-      return fallback.code;
-    } else {
-      return rewriteLegacyExpression(match, options);
-    }
-  } catch {
-    return match;
-  }
-}
-
-// src/wxml/utils/custom-template.ts
-import { Parser } from "htmlparser2";
-import MagicString4 from "magic-string";
-
-// src/wxml/utils/template-fragments.ts
-import MagicString3 from "magic-string";
-
-// src/wxml/whitespace.ts
-var WHITESPACE_CODES = /* @__PURE__ */ new Set([
-  9,
-  // 制表符 \t
-  10,
-  // 换行符 \n
-  11,
-  // 垂直制表符 \v
-  12,
-  // 换页符 \f
-  13,
-  // 回车符 \r
-  32,
-  // 空格
-  160,
-  // 不间断空格 \u00A0
-  65279
-  // 零宽无断行空格 \uFEFF
-]);
-function isWhitespace(char) {
-  if (char.length === 0) {
-    return false;
-  }
-  return WHITESPACE_CODES.has(char.charCodeAt(0));
-}
-function isAllWhitespace(value) {
-  for (let i = 0; i < value.length; i++) {
-    if (!WHITESPACE_CODES.has(value.charCodeAt(i))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// src/wxml/Tokenizer.ts
-var Tokenizer = class {
-  constructor() {
-    this.reset();
-  }
-  processChar(char, index) {
-    switch (this.state) {
-      case 0 /* START */:
-        if (isWhitespace(char)) {
-        } else if (char === "{") {
-          this.state = 2 /* OPEN_BRACE */;
-          this.bufferStartIndex = index;
-          this.buffer += char;
-          this.expressionBuffer = char;
-          this.expressionStartIndex = index;
-        } else {
-          this.state = 1 /* TEXT */;
-          this.bufferStartIndex = index;
-          this.buffer += char;
-        }
-        break;
-      case 1 /* TEXT */:
-        if (isWhitespace(char)) {
-          this.tokens.push({ start: this.bufferStartIndex, end: index, value: this.buffer, expressions: this.expressions });
-          this.buffer = "";
-          this.expressions = [];
-          this.state = 0 /* START */;
-        } else if (char === "{") {
-          this.buffer += char;
-          this.expressionBuffer = char;
-          this.expressionStartIndex = index;
-          this.state = 2 /* OPEN_BRACE */;
-        } else {
-          this.buffer += char;
-        }
-        break;
-      case 2 /* OPEN_BRACE */:
-        if (char === "}") {
-          this.buffer += char;
-          this.expressionBuffer += char;
-          this.state = 3 /* POTENTIAL_CLOSE */;
-        } else {
-          this.buffer += char;
-          this.expressionBuffer += char;
-        }
-        break;
-      case 3 /* POTENTIAL_CLOSE */:
-        if (char === "}") {
-          this.buffer += char;
-          this.expressionBuffer += char;
-          this.expressions.push({
-            start: this.expressionStartIndex,
-            end: index + 1,
-            value: this.expressionBuffer
-          });
-          this.expressionBuffer = "";
-          this.state = 4 /* BRACES_COMPLETE */;
-        } else {
-          this.buffer += char;
-          this.expressionBuffer += char;
-          this.state = 2 /* OPEN_BRACE */;
-        }
-        break;
-      case 4 /* BRACES_COMPLETE */:
-        if (isWhitespace(char)) {
-          this.tokens.push({
-            start: this.bufferStartIndex,
-            end: index,
-            value: this.buffer,
-            expressions: this.expressions
-          });
-          this.buffer = "";
-          this.expressions = [];
-          this.state = 0 /* START */;
-        } else if (char === "{") {
-          this.expressionStartIndex = index;
-          this.expressionBuffer = char;
-          this.buffer += char;
-          this.state = 2 /* OPEN_BRACE */;
-        } else {
-          this.buffer += char;
-          this.state = 1 /* TEXT */;
-        }
-        break;
-      default:
-        throw new Error("Unexpected state");
-    }
-  }
-  run(input) {
-    this.reset();
-    for (let i = 0; i < input.length; i++) {
-      const char = input[i];
-      this.processChar(char, i);
-    }
-    if (this.buffer.length > 0) {
-      this.tokens.push({
-        start: this.bufferStartIndex,
-        end: input.length,
-        value: this.buffer,
-        expressions: this.expressions
-      });
-    }
-    const tokens = this.tokens;
-    this.reset();
-    return tokens;
-  }
-  reset() {
-    this.state = 0 /* START */;
-    this.buffer = "";
-    this.tokens = [];
-    this.bufferStartIndex = 0;
-    this.expressionBuffer = "";
-    this.expressionStartIndex = 0;
-    this.expressions = [];
-  }
-};
-
-// src/wxml/utils/fragment-helpers.ts
-function updateWhitespaceGap(ms, start, end, options) {
-  const gap = ms.slice(start, end);
-  if (isAllWhitespace(gap)) {
-    ms.update(start, end, replaceWxml(gap, {
-      keepEOL: false,
-      escapeMap: options.escapeMap,
-      ignoreHead: true
-    }));
-  }
-}
-function updateWxmlSegment(ms, start, end, options, keepEOL, ignoreHead) {
-  ms.update(start, end, replaceWxml(ms.slice(start, end), {
-    keepEOL,
-    escapeMap: options.escapeMap,
-    ignoreHead
-  }));
-}
-function updateExpressionSegment(ms, exp, options) {
-  const code = `{{${generateCode(exp.value.slice(2, -2), options)}}}`;
-  ms.update(exp.start, exp.end, code);
-}
-
-// src/wxml/utils/fragment-updater.ts
-function handleEachClassFragment(ms, tokens, options = {}) {
-  let previousEnd = 0;
-  for (const token of tokens) {
-    if (token.start > previousEnd) {
-      updateWhitespaceGap(ms, previousEnd, token.start, options);
-    }
-    let p = token.start;
-    if (token.expressions.length > 0) {
-      for (const exp of token.expressions) {
-        if (exp.start > token.start && p < exp.start) {
-          updateWxmlSegment(ms, p, exp.start, options, true, p > 0);
-        }
-        updateExpressionSegment(ms, exp, options);
-        p = exp.end;
-      }
-      if (token.end > p) {
-        updateWxmlSegment(ms, p, token.end, options, false, true);
-      }
-    } else {
-      updateWxmlSegment(ms, token.start, token.end, options, false, false);
-    }
-    previousEnd = token.end;
-  }
-  if (tokens.length > 0) {
-    const lastToken = tokens[tokens.length - 1];
-    if (lastToken.end < ms.original.length) {
-      updateWhitespaceGap(ms, lastToken.end, ms.original.length, options);
-    }
-  }
-}
-
-// src/wxml/utils/template-fragments.ts
-var sharedTokenizer = new Tokenizer();
-function templateReplacer(original, options = {}, tokenizer) {
-  const ms = new MagicString3(original);
-  const tok = tokenizer ?? sharedTokenizer;
-  const tokens = tok.run(ms.original);
-  handleEachClassFragment(ms, tokens, options);
-  return ms.toString();
-}
-
-// src/wxml/utils/custom-template.ts
-async function customTemplateHandler(rawSource, options, cachedMatcher) {
-  const {
-    customAttributesEntities = [],
-    disabledDefaultTemplateHandler,
-    inlineWxs,
-    runtimeSet,
-    jsHandler: jsHandler2
-  } = options ?? {};
-  const matchCustomAttribute = cachedMatcher ?? createAttributeMatcher(customAttributesEntities);
-  const defaultTemplateHandlerEnabled = !disabledDefaultTemplateHandler;
-  let replaceOptions;
-  let cachedQuote;
-  let s;
-  let tag = "";
-  let wxsArray;
-  function getMagicString() {
-    if (!s) {
-      s = new MagicString4(rawSource);
-    }
-    return s;
-  }
-  function getReplaceOptions(quote) {
-    if (!replaceOptions) {
-      replaceOptions = {
-        ...options,
-        quote
-      };
-      cachedQuote = quote;
-      return replaceOptions;
-    }
-    if (cachedQuote !== quote) {
-      replaceOptions.quote = quote;
-      cachedQuote = quote;
-    }
-    return replaceOptions;
-  }
-  function isDefaultTemplateAttribute(name) {
-    if (name === "class" || name === "hover-class" || name === "virtualhostclass") {
-      return true;
-    }
-    const lowerName = name.toLowerCase();
-    return lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass";
-  }
-  const parser = new Parser(
-    {
-      onopentagname(name) {
-        tag = name;
-      },
-      onattribute(name, value, quote) {
-        if (!value) {
-          return;
-        }
-        const shouldHandleDefault = defaultTemplateHandlerEnabled && isDefaultTemplateAttribute(name);
-        const shouldHandleCustom = matchCustomAttribute?.(tag, name) ?? false;
-        if (!shouldHandleDefault && !shouldHandleCustom) {
-          return;
-        }
-        getMagicString().update(
-          parser.startIndex + name.length + 2,
-          // !important
-          // htmlparser2 9.0.0: parser.endIndex
-          // htmlparser2 9.1.0: parser.endIndex - 1
-          // https://github.com/sonofmagic/weapp-tailwindcss/issues/269
-          parser.endIndex - 1,
-          templateReplacer(value, getReplaceOptions(quote))
-        );
-      },
-      ontext(data) {
-        if (inlineWxs && tag === "wxs") {
-          ;
-          (wxsArray ?? (wxsArray = [])).push({
-            data,
-            endIndex: parser.endIndex + 1,
-            startIndex: parser.startIndex
-          });
-        }
-      },
-      onclosetag() {
-        tag = "";
-      }
-    },
-    {
-      xmlMode: true
-    }
-  );
-  parser.write(rawSource);
-  parser.end();
-  for (const { data, endIndex, startIndex } of wxsArray ?? []) {
-    const { code } = await jsHandler2(data, runtimeSet);
-    if (code !== data) {
-      getMagicString().update(startIndex, endIndex, code);
-    }
-  }
-  return s?.toString() ?? rawSource;
-}
-
-// src/wxml/utils.ts
-function createTemplateHandler(options = {}) {
-  const cachedMatcher = createAttributeMatcher(
-    options.customAttributesEntities
-  );
-  const defaultOptions = options;
-  let cachedRuntimeSet;
-  let cachedOptionsWithRuntimeSet;
-  return (rawSource, opt) => {
-    const runtimeSet = opt?.runtimeSet;
-    if (runtimeSet === void 0) {
-      return customTemplateHandler(rawSource, defaultOptions, cachedMatcher);
-    }
-    if (cachedRuntimeSet !== runtimeSet || !cachedOptionsWithRuntimeSet) {
-      cachedRuntimeSet = runtimeSet;
-      cachedOptionsWithRuntimeSet = {
-        ...defaultOptions,
-        runtimeSet
-      };
-    }
-    return customTemplateHandler(rawSource, cachedOptionsWithRuntimeSet, cachedMatcher);
-  };
-}
-
-// src/context/handlers.ts
-function resolveRuntimePackageReplacements(option) {
-  if (!option) {
-    return void 0;
-  }
-  const mapping = option === true ? DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS : option;
-  const normalized = {};
-  for (const [from, to] of Object.entries(mapping)) {
-    if (!from || typeof to !== "string" || to.length === 0) {
-      continue;
-    }
-    normalized[from] = to;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions, tailwindcssMajorVersion) {
-  const {
-    cssPreflight,
-    cssPreflightRange,
-    escapeMap,
-    cssChildCombinatorReplaceValue,
-    injectAdditionalCssVarScope,
-    cssSelectorReplacement,
-    rem2rpx,
-    postcssOptions,
-    cssRemoveProperty,
-    cssRemoveHoverPseudoClass,
-    cssPresetEnv,
-    autoprefixer,
-    uniAppX,
-    px2rpx,
-    unitsToPx,
-    arbitraryValues,
-    jsPreserveClass,
-    staleClassNameFallback,
-    jsArbitraryValueFallback,
-    babelParserOptions,
-    ignoreCallExpressionIdentifiers,
-    ignoreTaggedTemplateExpressionIdentifiers,
-    inlineWxs,
-    disabledDefaultTemplateHandler,
-    replaceRuntimePackages
-  } = ctx;
-  const uniAppXEnabled = isUniAppXEnabled(uniAppX);
-  const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
-  const moduleSpecifierReplacements = resolveRuntimePackageReplacements(replaceRuntimePackages);
-  const styleHandler = createStyleHandler({
-    cssPreflight,
-    cssPreflightRange,
-    escapeMap,
-    cssChildCombinatorReplaceValue,
-    injectAdditionalCssVarScope,
-    cssSelectorReplacement,
-    rem2rpx,
-    postcssOptions,
-    cssRemoveProperty,
-    cssRemoveHoverPseudoClass,
-    cssPresetEnv,
-    autoprefixer,
-    uniAppX: uniAppXEnabled,
-    uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
-    cssCalc: cssCalcOptions,
-    px2rpx,
-    unitsToPx,
-    majorVersion: tailwindcssMajorVersion
-  });
-  const jsHandler2 = createJsHandler({
-    escapeMap,
-    arbitraryValues,
-    jsPreserveClass,
-    staleClassNameFallback,
-    jsArbitraryValueFallback: jsArbitraryValueFallback ?? "auto",
-    tailwindcssMajorVersion,
-    generateMap: true,
-    babelParserOptions,
-    ignoreCallExpressionIdentifiers,
-    ignoreTaggedTemplateExpressionIdentifiers,
-    uniAppX: uniAppXEnabled,
-    moduleSpecifierReplacements
-  });
-  const templateHandler = createTemplateHandler({
-    customAttributesEntities,
-    escapeMap,
-    inlineWxs,
-    jsHandler: jsHandler2,
-    disabledDefaultTemplateHandler
-  });
-  return {
-    styleHandler,
-    jsHandler: jsHandler2,
-    templateHandler
-  };
-}
-
-// src/context/logger.ts
-import { logger as logger6 } from "@weapp-tailwindcss/logger";
-var loggerLevelMap = {
-  error: 0,
-  warn: 1,
-  info: 3,
-  silent: -999
-};
-function applyLoggerLevel(logLevel) {
-  logger6.level = loggerLevelMap[logLevel ?? "info"] ?? loggerLevelMap.info;
-}
-
-// src/context/index.ts
-async function clearTailwindcssPatcherCache(patcher, options) {
-  if (!patcher) {
-    return;
-  }
-  const cacheOptions = patcher.options?.cache;
-  if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
-    return;
-  }
-  if (typeof patcher.clearCache === "function") {
-    try {
-      await patcher.clearCache({ scope: "all" });
-    } catch (error) {
-      logger7.debug("failed to clear tailwindcss patcher cache via clearCache(): %O", error);
-    }
-  }
-  if (!options?.removeDirectory) {
-    return;
-  }
-  const cachePaths = /* @__PURE__ */ new Map();
-  const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
-  if (normalizedCacheOptions?.path) {
-    cachePaths.set(normalizedCacheOptions.path, false);
-  }
-  const privateCachePath = patcher?.cacheStore?.options?.path;
-  if (privateCachePath) {
-    cachePaths.set(privateCachePath, false);
-  }
-  if (options?.removeDirectory && normalizedCacheOptions?.dir) {
-    cachePaths.set(normalizedCacheOptions.dir, true);
-  }
-  if (!cachePaths.size) {
-    return;
-  }
-  for (const [cachePath, recursive] of cachePaths.entries()) {
-    try {
-      await rm(cachePath, { force: true, recursive });
-    } catch (error) {
-      const err = error;
-      if (err?.code === "ENOENT") {
-        continue;
-      }
-      logger7.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
-    }
-  }
-}
-function createInternalCompilerContext(opts) {
-  const ctx = defuOverrideArray(
-    opts,
-    getDefaultOptions(),
-    {}
-  );
-  ctx.escapeMap = ctx.customReplaceDictionary;
-  applyLoggerLevel(ctx.logLevel);
-  const twPatcher = createTailwindcssPatcherFromContext(ctx);
-  logTailwindcssTarget("runtime", twPatcher, ctx.tailwindcssBasedir);
-  logRuntimeTailwindcssVersion(
-    ctx.tailwindcssBasedir,
-    twPatcher.packageInfo?.rootPath,
-    twPatcher.packageInfo?.version
-  );
-  warnMissingCssEntries(ctx, twPatcher);
-  const cssCalcOptions = applyV4CssCalcDefaults(ctx.cssCalc, twPatcher);
-  ctx.cssCalc = cssCalcOptions;
-  const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
-  const { styleHandler, jsHandler: jsHandler2, templateHandler } = createHandlersFromContext(
-    ctx,
-    customAttributesEntities,
-    cssCalcOptions,
-    twPatcher.majorVersion
-  );
-  ctx.styleHandler = styleHandler;
-  ctx.jsHandler = jsHandler2;
-  ctx.templateHandler = templateHandler;
-  ctx.cache = initializeCache(ctx.cache);
-  ctx.twPatcher = twPatcher;
-  const refreshTailwindcssPatcher = async (options) => {
-    const previousPatcher = ctx.twPatcher;
-    if (options?.clearCache !== false) {
-      await clearTailwindcssPatcherCache(previousPatcher);
-    }
-    invalidateRuntimeClassSet(previousPatcher);
-    const nextPatcher = createTailwindcssPatcherFromContext(ctx);
-    Object.assign(previousPatcher, nextPatcher);
-    ctx.twPatcher = previousPatcher;
-    return previousPatcher;
-  };
-  ctx.refreshTailwindcssPatcher = refreshTailwindcssPatcher;
-  Object.defineProperty(ctx.twPatcher, refreshTailwindcssPatcherSymbol, {
-    value: refreshTailwindcssPatcher,
-    configurable: true
-  });
-  return ctx;
-}
-function getCompilerContext(opts) {
-  return withCompilerContextCache(opts, () => createInternalCompilerContext(opts));
-}
-
-// src/js/precheck.ts
-import process6 from "process";
-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 shouldSkipJsTransform(rawSource, options) {
-  if (process6.env.WEAPP_TW_DISABLE_JS_PRECHECK === "1") {
-    return false;
-  }
-  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/tailwindcss/recorder.ts
-function setupPatchRecorder(patcher, baseDir, options) {
-  const recorder = createPatchTargetRecorder(baseDir, patcher, options);
-  if (recorder?.message && options?.logMessage !== false) {
-    const prefix = options?.messagePrefix ? `${options.messagePrefix} ` : "";
-    logger.info("%s%s", prefix, recorder.message);
-  }
-  const onPatchCompleted = recorder?.onPatched ? async () => {
-    await recorder.onPatched();
-  } : void 0;
-  const patchPromise = patcher ? createTailwindPatchPromise(patcher, onPatchCompleted) : Promise.resolve();
-  return {
-    recorder,
-    patchPromise,
-    onPatchCompleted
-  };
-}
-
-export {
-  createDebug,
-  refreshTailwindRuntimeState,
-  ensureRuntimeClassSet,
-  collectRuntimeClassSet,
-  pluginName,
-  vitePluginName,
-  toCustomAttributesEntities,
-  traverse,
-  babelParse,
-  replaceWxml,
-  isClassContextLiteralPath,
-  JsTokenUpdater,
-  analyzeSource,
-  createAttributeMatcher,
-  generateCode,
-  getCompilerContext,
-  shouldSkipJsTransform,
-  setupPatchRecorder
-};