weapp-tailwindcss 3.3.7 → 3.4.0-alpha.0

package/dist/core.js

@@ -1,69 +1,1782 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var options = require('./options-DAp5AdGz.js');
-require('magic-string');
-require('./replace.js');
-require('@weapp-core/escape');
-require('@ast-core/escape');
-require('./shared-hzYeE1wX.js');
-require('@weapp-core/regex');
-require('@babel/generator');
-require('@babel/traverse');
-require('@babel/parser');
-require('./defaults-syv_N3uk.js');
-require('./defu-Cdz2PomB.js');
-require('@babel/types');
-require('htmlparser2');
-require('postcss');
-require('./index-DwZHOkK3.js');
-require('@csstools/postcss-is-pseudo-class');
-require('postcss-rem-to-responsive-pixel');
-require('postcss-selector-parser');
-require('node:path');
-require('node:fs');
-require('node:process');
-require('semver');
-require('tailwindcss-patch');
-require('@tailwindcss-mangle/shared');
-require('lru-cache');
-require('md5');
-
-function createContext(options$1 = {}) {
-    const opts = options.getOptions(options$1);
-    const { templateHandler, styleHandler, patch, jsHandler, twPatcher } = opts;
-    let runtimeSet = new Set();
-    patch === null || patch === void 0 ? void 0 : patch();
-    function transformWxss(rawCss, options$1) {
-        return options.__awaiter(this, void 0, void 0, function* () {
-            const code = yield styleHandler(rawCss, Object.assign({
-                isMainChunk: true,
-            }, options$1));
-            return code;
-        });
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
     }
-    function transformJs(rawJs_1) {
-        return options.__awaiter(this, arguments, void 0, function* (rawJs, options = {}) {
-            runtimeSet
-                = options && options.runtimeSet
-                    ? options.runtimeSet
-                    : twPatcher.getClassSet();
-            const { code } = yield jsHandler(rawJs, runtimeSet, options);
-            return code;
-        });
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  createContext: () => createContext2
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/js/index.ts
+var import_magic_string = __toESM(require("magic-string"));
+
+// src/escape.ts
+var escape_exports = {};
+__export(escape_exports, {
+  decodeUnicode: () => decodeUnicode,
+  decodeUnicode2: () => decodeUnicode2,
+  jsStringEscape: () => import_escape.jsStringEscape
+});
+__reExport(escape_exports, require("@weapp-core/escape"));
+var import_escape = require("@ast-core/escape");
+function decodeUnicode(s) {
+  return unescape(s.replaceAll(/\\(u[\dA-Fa-f]{4})/g, "%$1"));
+}
+function decodeUnicode2(input) {
+  try {
+    return JSON.parse(`"${input}"`);
+  } catch (_error) {
+    return input;
+  }
+}
+
+// src/wxml/shared.ts
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: escape_exports.SimpleMappingChars2String
+}) {
+  const { keepEOL, escapeMap, mangleContext, ignoreHead } = options;
+  let res = original;
+  if (!keepEOL) {
+    res = res.replaceAll(/[\n\r]+/g, "");
+  }
+  if (mangleContext) {
+    res = mangleContext.wxmlHandler(res);
+  }
+  res = (0, escape_exports.escape)(res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
+}
+
+// src/reg.ts
+var reg_exports = {};
+__reExport(reg_exports, require("@weapp-core/regex"));
+
+// src/extractors/split.ts
+var validateFilterRE = /[\w\u00A0-\uFFFF%-?]/;
+function isValidSelector(selector = "") {
+  return validateFilterRE.test(selector);
+}
+function splitCode(code, allowDoubleQuotes = false) {
+  const splitter = allowDoubleQuotes ? /\s+/ : /\s+|"/;
+  return code.split(splitter).filter((element) => isValidSelector(element));
+}
+
+// src/js/handlers.ts
+function replaceHandleValue(str, node, options, ms, offset = 0) {
+  const {
+    classNameSet: set,
+    escapeMap,
+    mangleContext: ctx,
+    needEscaped = false,
+    jsPreserveClass,
+    arbitraryValues,
+    always,
+    unescapeUnicode
+  } = options;
+  const allowDoubleQuotes = arbitraryValues == null ? void 0 : arbitraryValues.allowDoubleQuotes;
+  let rawStr = str;
+  let needUpdate = false;
+  if (unescapeUnicode && rawStr.includes("\\u")) {
+    rawStr = decodeUnicode2(rawStr);
+  }
+  const arr = splitCode(rawStr, allowDoubleQuotes);
+  for (const v of arr) {
+    if (always || set && set.has(v) && !(jsPreserveClass == null ? void 0 : jsPreserveClass(v))) {
+      let ignoreFlag = false;
+      if (Array.isArray(node.leadingComments)) {
+        ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes("weapp-tw") && x.value.includes("ignore")) > -1;
+      }
+      if (!ignoreFlag) {
+        if (ctx) {
+          rawStr = ctx.jsHandler(rawStr);
+        }
+        rawStr = rawStr.replace(
+          new RegExp((0, reg_exports.escapeStringRegexp)(v)),
+          replaceWxml(v, {
+            escapeMap
+          })
+        );
+        needUpdate = true;
+      }
+    }
+  }
+  if (needUpdate && typeof node.start === "number" && typeof node.end === "number") {
+    const start = node.start + offset;
+    const end = node.end - offset;
+    if (start < end && str !== rawStr) {
+      const content = needEscaped ? (0, import_escape.jsStringEscape)(rawStr) : rawStr;
+      ms.update(start, end, content);
     }
-    function transformWxml(rawWxml, options) {
-        const code = templateHandler(rawWxml, Object.assign({
-            runtimeSet,
-        }, options));
-        return code;
+  }
+  return rawStr;
+}
+
+// src/babel/index.ts
+var import_generator = __toESM(require("@babel/generator"));
+var import_traverse = __toESM(require("@babel/traverse"));
+var import_parser = require("@babel/parser");
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var generate = _interopDefaultCompat(import_generator.default);
+var traverse = _interopDefaultCompat(import_traverse.default);
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
     }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// src/utils.ts
+function isMap(value) {
+  return Object.prototype.toString.call(value) === "[object Map]";
+}
+function noop() {
+}
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+
+// src/js/index.ts
+function isEvalPath(p) {
+  if (p.isCallExpression()) {
+    const calleePath = p.get("callee");
+    return calleePath.isIdentifier() && calleePath.node.name === "eval";
+  }
+  return false;
+}
+function getAstGrep() {
+  return __async(this, null, function* () {
+    try {
+      const { js } = yield import("@ast-grep/napi");
+      return js;
+    } catch (error) {
+      console.warn("\u8BF7\u5148\u5B89\u88C5 `@ast-grep/napi` , \u5B89\u88C5\u5B8C\u6210\u540E\u518D\u5C1D\u8BD5\u8FD0\u884C\uFF01");
+      throw error;
+    }
+  });
+}
+function astGrepUpdateString(ast, options, ms) {
+  return __async(this, null, function* () {
+    const js = yield getAstGrep();
+    const nodes = ast.findAll(js.kind("string"));
+    for (const node of nodes) {
+      const range = node.range();
+      const text = node.text();
+      replaceHandleValue(
+        text.slice(1, -1),
+        {
+          end: range.end.index - 1,
+          start: range.start.index + 1
+        },
+        __spreadProps(__spreadValues({}, options), {
+          unescapeUnicode: true
+        }),
+        ms,
+        0
+      );
+    }
+    const templateNodes = ast.findAll(js.kind("template_string"));
+    for (const node of templateNodes) {
+      const fragments = node.findAll(js.kind("string_fragment"));
+      for (const fragment of fragments) {
+        const range = fragment.range();
+        const text = fragment.text();
+        replaceHandleValue(
+          text,
+          {
+            end: range.end.index,
+            start: range.start.index
+          },
+          __spreadProps(__spreadValues({}, options), {
+            unescapeUnicode: true
+          }),
+          ms,
+          0
+        );
+      }
+    }
+  });
+}
+function jsHandler(rawSource, options) {
+  const ms = new import_magic_string.default(rawSource);
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(rawSource, options.babelParserOptions);
+  } catch (error) {
     return {
-        transformWxss,
-        transformWxml,
-        transformJs,
+      code: rawSource,
+      error
+    };
+  }
+  const traverseOptions = {
+    StringLiteral: {
+      enter(p) {
+        var _a;
+        if (isEvalPath(p.parentPath)) {
+          return;
+        }
+        const n = p.node;
+        replaceHandleValue(
+          n.value,
+          n,
+          __spreadProps(__spreadValues({}, options), {
+            needEscaped: (_a = options.needEscaped) != null ? _a : true
+          }),
+          ms,
+          1
+        );
+      }
+      // exit(p) {}
+    },
+    TemplateElement: {
+      enter(p) {
+        if (p.parentPath.isTemplateLiteral() && isEvalPath(p.parentPath.parentPath)) {
+          return;
+        }
+        const n = p.node;
+        replaceHandleValue(
+          n.value.raw,
+          n,
+          __spreadProps(__spreadValues({}, options), {
+            needEscaped: false
+          }),
+          ms,
+          0
+        );
+      }
+    },
+    CallExpression: {
+      enter(p) {
+        if (isEvalPath(p)) {
+          p.traverse({
+            StringLiteral: {
+              enter(s) {
+                const res = jsHandler(s.node.value, __spreadProps(__spreadValues({}, options), {
+                  needEscaped: false,
+                  generateMap: false
+                }));
+                if (res.code) {
+                  const node = s.node;
+                  if (typeof node.start === "number" && typeof node.end === "number") {
+                    const start = node.start + 1;
+                    const end = node.end - 1;
+                    if (start < end && s.node.value !== res.code) {
+                      ms.update(start, end, (0, import_escape.jsStringEscape)(res.code));
+                      node.value = res.code;
+                    }
+                  }
+                }
+              }
+            },
+            TemplateElement: {
+              enter(s) {
+                const res = jsHandler(s.node.value.raw, __spreadProps(__spreadValues({}, options), {
+                  generateMap: false
+                }));
+                if (res.code) {
+                  const node = s.node;
+                  if (typeof node.start === "number" && typeof node.end === "number") {
+                    const start = node.start;
+                    const end = node.end;
+                    if (start < end && s.node.value.raw !== res.code) {
+                      ms.update(start, end, res.code);
+                      s.node.value.raw = res.code;
+                    }
+                  }
+                }
+              }
+            }
+          });
+        }
+      }
+    }
+  };
+  traverse(ast, traverseOptions);
+  return {
+    code: ms.toString()
+  };
+}
+function jsHandlerAsync(rawSource, options) {
+  return __async(this, null, function* () {
+    const ms = new import_magic_string.default(rawSource);
+    const js = yield getAstGrep();
+    let ast;
+    try {
+      const root = yield js.parseAsync(rawSource);
+      ast = root.root();
+    } catch (e) {
+      return {
+        code: rawSource
+      };
+    }
+    yield astGrepUpdateString(ast, options, ms);
+    return {
+      code: ms.toString()
+    };
+  });
+}
+function createJsHandler(options) {
+  const { mangleContext, arbitraryValues, escapeMap, jsPreserveClass, generateMap, jsAstTool, babelParserOptions } = options;
+  function _jsHandler(rawSource, set, options2) {
+    const opts = defuOverrideArray(options2, {
+      classNameSet: set,
+      escapeMap,
+      arbitraryValues,
+      mangleContext,
+      jsPreserveClass,
+      generateMap,
+      jsAstTool,
+      babelParserOptions
+    });
+    if (opts.jsAstTool === "ast-grep") {
+      return jsHandlerAsync(rawSource, opts);
+    }
+    return jsHandler(rawSource, opts);
+  }
+  function sync(rawSource, set, options2) {
+    const opts = defuOverrideArray(options2, {
+      classNameSet: set,
+      escapeMap,
+      arbitraryValues,
+      mangleContext,
+      jsPreserveClass,
+      generateMap,
+      jsAstTool,
+      babelParserOptions
+    });
+    return jsHandler(rawSource, opts);
+  }
+  _jsHandler.sync = sync;
+  return _jsHandler;
+}
+
+// src/defaults.ts
+var defaultOptions = {
+  cssMatcher: (file) => /.+\.(?:wx|ac|jx|tt|q|c|ty)ss$/.test(file),
+  htmlMatcher: (file) => /.+\.(?:(?:wx|ax|jx|ks|tt|q|ty)ml|swan)$/.test(file),
+  jsMatcher: (file) => {
+    if (file.includes("node_modules")) {
+      return false;
+    }
+    return /.+\.[cm]?js?$/.test(file);
+  },
+  mainCssChunkMatcher: (file, appType) => {
+    switch (appType) {
+      case "uni-app": {
+        return /^common\/main/.test(file);
+      }
+      case "uni-app-vite": {
+        return file.startsWith("app") || /^common\/main/.test(file);
+      }
+      case "mpx": {
+        return file.startsWith("app");
+      }
+      case "taro": {
+        return file.startsWith("app");
+      }
+      case "remax": {
+        return file.startsWith("app");
+      }
+      case "rax": {
+        return file.startsWith("bundle");
+      }
+      case "native": {
+        return file.startsWith("app");
+      }
+      case "kbone": {
+        return /^(?:common\/)?miniprogram-app/.test(file);
+      }
+      default: {
+        return true;
+      }
+    }
+  },
+  wxsMatcher: () => {
+    return false;
+  },
+  // https://tailwindcss.com/docs/preflight#border-styles-are-reset-globally
+  cssPreflight: {
+    "box-sizing": "border-box",
+    "border-width": "0",
+    "border-style": "solid",
+    "border-color": "currentColor"
+  },
+  disabled: false,
+  customRuleCallback: noop,
+  onLoad: noop,
+  onStart: noop,
+  onEnd: noop,
+  onUpdate: noop,
+  customAttributes: {},
+  customReplaceDictionary: escape_exports.SimpleMappingChars2String,
+  appType: void 0,
+  arbitraryValues: {
+    allowDoubleQuotes: false
+  },
+  cssChildCombinatorReplaceValue: ["view"],
+  inlineWxs: false,
+  injectAdditionalCssVarScope: false,
+  jsPreserveClass: (keyword) => {
+    if (keyword === "*") {
+      return true;
+    }
+    return false;
+  },
+  disabledDefaultTemplateHandler: false,
+  cssSelectorReplacement: {
+    root: "page",
+    universal: ["view", "text"]
+  },
+  babelParserOptions: {
+    sourceType: "unambiguous"
+  },
+  postcssOptions: {},
+  cssRemoveHoverPseudoClass: true
+  // jsAstTool: 'ast-grep'
+};
+
+// src/wxml/utils.ts
+var t = __toESM(require("@babel/types"));
+var import_htmlparser2 = require("htmlparser2");
+var import_magic_string2 = __toESM(require("magic-string"));
+
+// src/wxml/Tokenizer.ts
+var Tokenizer = class {
+  constructor() {
+    this.reset();
+  }
+  processChar(char, index) {
+    switch (this.state) {
+      case 0 /* START */:
+        if (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 (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 (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) {
+    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
+      });
+    }
+    return this.tokens;
+  }
+  reset() {
+    this.state = 0 /* START */;
+    this.buffer = "";
+    this.tokens = [];
+    this.bufferStartIndex = 0;
+    this.expressionBuffer = "";
+    this.expressionStartIndex = 0;
+    this.expressions = [];
+  }
+};
+
+// src/wxml/utils.ts
+function generateCode(match, options = {}) {
+  try {
+    const { jsHandler: jsHandler2, runtimeSet } = options;
+    if (jsHandler2 && jsHandler2.sync && runtimeSet) {
+      const { code } = jsHandler2.sync(match, runtimeSet);
+      return code;
+    } else {
+      const ms = new import_magic_string2.default(match);
+      const ast = (0, import_parser.parseExpression)(match);
+      traverse(ast, {
+        StringLiteral(path2) {
+          var _a, _b;
+          if (t.isMemberExpression(path2.parent)) {
+            return;
+          }
+          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression((_a = path2.parentPath) == null ? void 0 : _a.parent) || t.isLogicalExpression((_b = path2.parentPath) == null ? void 0 : _b.parent))) {
+            return;
+          }
+          const n = path2.node;
+          replaceHandleValue(
+            n.value,
+            n,
+            {
+              mangleContext: options.mangleContext,
+              escapeMap: options.escapeMap,
+              classNameSet: options.runtimeSet,
+              needEscaped: true,
+              always: true
+            },
+            ms,
+            1
+          );
+        },
+        noScope: true
+      });
+      return ms.toString();
+    }
+  } catch (e) {
+    return match;
+  }
+}
+function extract(original, reg) {
+  let match = reg.exec(original);
+  const sources = [];
+  while (match !== null) {
+    const start = match.index;
+    const end = reg.lastIndex;
+    sources.push({
+      start,
+      end,
+      raw: match[1]
+    });
+    match = reg.exec(original);
+  }
+  return sources;
+}
+function extractSource(original) {
+  return extract(original, reg_exports.variableRegExp);
+}
+function handleEachClassFragment(original, options = {}) {
+  const sources = extractSource(original);
+  if (sources.length > 0) {
+    const resultArray = [];
+    let p = 0;
+    for (let i = 0; i < sources.length; i++) {
+      const m = sources[i];
+      const before = original.slice(p, m.start);
+      resultArray.push(
+        replaceWxml(before, {
+          keepEOL: true,
+          escapeMap: options.escapeMap,
+          mangleContext: options.mangleContext,
+          // 首的str才会被转译
+          // example: 2xl:xx 2x{{y}}
+          ignoreHead: p > 0
+        })
+      );
+      p = m.start;
+      if (m.raw.trim().length > 0) {
+        const code = generateCode(m.raw, options);
+        const source = `{{${code}}}`;
+        m.source = source;
+      } else {
+        m.source = "";
+      }
+      resultArray.push(m.source);
+      p = m.end;
+      if (i === sources.length - 1) {
+        const after = original.slice(m.end);
+        resultArray.push(
+          replaceWxml(after, {
+            keepEOL: true,
+            escapeMap: options.escapeMap,
+            mangleContext: options.mangleContext,
+            ignoreHead: true
+          })
+        );
+      }
+    }
+    return resultArray.filter(Boolean).join("").trim();
+  } else {
+    return replaceWxml(original, {
+      keepEOL: false,
+      escapeMap: options.escapeMap,
+      mangleContext: options.mangleContext,
+      ignoreHead: false
+    });
+  }
+}
+function templateReplacer(original, options = {}) {
+  const ms = new import_magic_string2.default(original);
+  const tokenizer = new Tokenizer();
+  const tokens = tokenizer.run(ms.original);
+  for (const token of tokens) {
+    const target = handleEachClassFragment(token.value, options);
+    ms.update(token.start, token.end, target);
+  }
+  return ms.toString();
+}
+function regTest(reg, str) {
+  reg.lastIndex = 0;
+  return reg.test(str);
+}
+function isPropsMatch(props, attr) {
+  if (Array.isArray(props)) {
+    for (const prop of props) {
+      const res = typeof prop === "string" ? prop.toLowerCase() === attr.toLowerCase() : regTest(prop, attr);
+      if (res) {
+        return res;
+      }
+    }
+    return false;
+  } else if (typeof props === "string") {
+    return props === attr;
+  } else {
+    return regTest(props, attr);
+  }
+}
+function customTemplateHandler(rawSource, options) {
+  return __async(this, null, function* () {
+    const {
+      customAttributesEntities = [],
+      disabledDefaultTemplateHandler,
+      inlineWxs,
+      runtimeSet,
+      jsHandler: jsHandler2
+    } = options != null ? options : {};
+    const s = new import_magic_string2.default(rawSource);
+    let tag = "";
+    const wxsArray = [];
+    const parser = new import_htmlparser2.Parser(
+      {
+        onopentagname(name) {
+          tag = name;
+        },
+        onattribute(name, value, quote) {
+          if (value) {
+            let update2 = function() {
+              s.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, __spreadProps(__spreadValues({}, options), {
+                  quote
+                }))
+              );
+            };
+            var update = update2;
+            if (!disabledDefaultTemplateHandler && (name === "class" || name === "hover-class" || name === "virtualHostClass" || name === "virtualhostclass")) {
+              update2();
+            }
+            for (const [t2, props] of customAttributesEntities) {
+              if (t2 === "*") {
+                if (isPropsMatch(props, name)) {
+                  update2();
+                }
+              } else if (typeof t2 === "string") {
+                if (t2 === tag && isPropsMatch(props, name)) {
+                  update2();
+                }
+              } else if (regTest(t2, tag) && isPropsMatch(props, name)) {
+                update2();
+              }
+            }
+          }
+        },
+        ontext(data) {
+          if (inlineWxs && tag === "wxs") {
+            wxsArray.push({
+              data,
+              endIndex: parser.endIndex + 1,
+              startIndex: parser.startIndex
+            });
+          }
+        },
+        onclosetag() {
+          tag = "";
+        }
+      },
+      {
+        xmlMode: true
+      }
+    );
+    parser.write(s.original);
+    parser.end();
+    for (const { data, endIndex, startIndex } of wxsArray) {
+      const { code } = yield jsHandler2(data, runtimeSet);
+      s.update(startIndex, endIndex, code);
+    }
+    return s.toString();
+  });
+}
+function createTemplateHandler(options = {}) {
+  return (rawSource, opt = {}) => {
+    return customTemplateHandler(rawSource, defuOverrideArray(opt, options));
+  };
+}
+
+// src/postcss/index.ts
+var import_postcss2 = __toESM(require("postcss"));
+
+// src/postcss/plugins/index.ts
+var import_postcss_is_pseudo_class = __toESM(require("@csstools/postcss-is-pseudo-class"));
+var import_postcss_rem_to_responsive_pixel = __toESM(require("postcss-rem-to-responsive-pixel"));
+
+// src/postcss/selectorParser.ts
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"));
+
+// src/postcss/shared.ts
+function internalCssSelectorReplacer(selectors, options = {
+  escapeMap: escape_exports.SimpleMappingChars2String
+}) {
+  const { mangleContext, escapeMap } = options;
+  if (mangleContext) {
+    selectors = mangleContext.cssHandler(selectors);
+  }
+  return (0, escape_exports.escape)(selectors, {
+    map: escapeMap
+  });
+}
+function composeIsPseudo(strs) {
+  if (typeof strs === "string") {
+    return strs;
+  }
+  if (strs.length > 1) {
+    return `:is(${strs.join(",")})`;
+  }
+  return strs.join("");
+}
+
+// src/postcss/selectorParser.ts
+function createRuleTransform(rule, options) {
+  const { escapeMap, mangleContext, cssSelectorReplacement, cssRemoveHoverPseudoClass } = options;
+  const transform = (selectors) => {
+    selectors.walk((selector) => {
+      if (selector.type === "universal" && cssSelectorReplacement && cssSelectorReplacement.universal) {
+        selector.value = composeIsPseudo(cssSelectorReplacement.universal);
+      }
+      if (cssRemoveHoverPseudoClass && selector.type === "selector") {
+        const node = selector.nodes.find((x) => x.type === "pseudo" && x.value === ":hover");
+        node && selector.remove();
+      }
+      if (selector.type === "pseudo" && selector.value === ":root" && cssSelectorReplacement && cssSelectorReplacement.root) {
+        selector.value = composeIsPseudo(cssSelectorReplacement.root);
+      }
+      if (selector.type === "class") {
+        selector.value = internalCssSelectorReplacer(selector.value, {
+          escapeMap,
+          mangleContext
+        });
+      }
+    });
+    if (selectors.length === 0) {
+      rule.remove();
+    }
+  };
+  return transform;
+}
+function getRuleTransformer(rule, options) {
+  return (0, import_postcss_selector_parser.default)(createRuleTransform(rule, options));
+}
+function ruleTransformSync(rule, options) {
+  const transformer = getRuleTransformer(rule, options);
+  return transformer.transformSync(rule, {
+    lossless: false,
+    updateSelector: true
+  });
+}
+function isOnlyBeforeAndAfterPseudoElement(node) {
+  let b = false;
+  let a = false;
+  (0, import_postcss_selector_parser.default)((selectors) => {
+    selectors.walkPseudos((s) => {
+      var _a;
+      if (((_a = s.parent) == null ? void 0 : _a.length) === 1) {
+        if (/^:?:before$/.test(s.value)) {
+          b = true;
+        }
+        if (/^:?:after$/.test(s.value)) {
+          a = true;
+        }
+      }
+    });
+  }).astSync(node);
+  return b && a;
+}
+var fallbackRemove = (0, import_postcss_selector_parser.default)((selectors) => {
+  selectors.walk((selector) => {
+    var _a, _b;
+    if (selector.type === "universal") {
+      (_a = selector.parent) == null ? void 0 : _a.remove();
+    }
+    if (selector.type === "pseudo" && selector.value === ":is") {
+      (_b = selector.parent) == null ? void 0 : _b.remove();
+    }
+  });
+});
+
+// src/postcss/mp.ts
+var import_postcss = require("postcss");
+
+// src/postcss/cssVars.ts
+var cssVars_default = [
+  {
+    prop: "--tw-border-spacing-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-border-spacing-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-translate-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-translate-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-rotate",
+    value: "0"
+  },
+  {
+    prop: "--tw-skew-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-skew-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-scale-x",
+    value: "1"
+  },
+  {
+    prop: "--tw-scale-y",
+    value: "1"
+  },
+  {
+    prop: "--tw-pan-x",
+    value: " "
+  },
+  {
+    prop: "--tw-pan-y",
+    value: " "
+  },
+  {
+    prop: "--tw-pinch-zoom",
+    value: " "
+  },
+  {
+    prop: "--tw-scroll-snap-strictness",
+    value: "proximity"
+  },
+  {
+    prop: "--tw-gradient-from-position",
+    value: " "
+  },
+  {
+    prop: "--tw-gradient-via-position",
+    value: " "
+  },
+  {
+    prop: "--tw-gradient-to-position",
+    value: " "
+  },
+  {
+    prop: "--tw-ordinal",
+    value: " "
+  },
+  {
+    prop: "--tw-slashed-zero",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-figure",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-spacing",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-fraction",
+    value: " "
+  },
+  {
+    prop: "--tw-ring-inset",
+    value: " "
+  },
+  {
+    prop: "--tw-ring-offset-width",
+    value: "0px"
+  },
+  {
+    prop: "--tw-ring-offset-color",
+    value: "#fff"
+  },
+  {
+    prop: "--tw-ring-color",
+    value: "rgb(59 130 246 / 0.5)"
+  },
+  {
+    prop: "--tw-ring-offset-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-ring-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-shadow-colored",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-blur",
+    value: " "
+  },
+  {
+    prop: "--tw-brightness",
+    value: " "
+  },
+  {
+    prop: "--tw-contrast",
+    value: " "
+  },
+  {
+    prop: "--tw-grayscale",
+    value: " "
+  },
+  {
+    prop: "--tw-hue-rotate",
+    value: " "
+  },
+  {
+    prop: "--tw-invert",
+    value: " "
+  },
+  {
+    prop: "--tw-saturate",
+    value: " "
+  },
+  {
+    prop: "--tw-sepia",
+    value: " "
+  },
+  {
+    prop: "--tw-drop-shadow",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-blur",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-brightness",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-contrast",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-grayscale",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-hue-rotate",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-invert",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-opacity",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-saturate",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-sepia",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-size",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-layout",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-paint",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-style",
+    value: " "
+  }
+];
+
+// src/postcss/mp.ts
+var initialNodes = cssVars_default.map((x) => {
+  return new import_postcss.Declaration({
+    prop: x.prop,
+    value: x.value
+  });
+});
+var PATTERNS = [
+  /:not\(template\)\s*[~+]\s*:not\(template\)/.source,
+  /:not\(\[hidden\]\)\s*[~+]\s*:not\(\[hidden\]\)/.source
+].join("|");
+var BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, "g");
+function testIfVariablesScope(node, count = 2) {
+  if (isOnlyBeforeAndAfterPseudoElement(node)) {
+    const nodes = node.nodes;
+    let c = 0;
+    for (const tryTestDecl of nodes) {
+      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
+        c++;
+      }
+      if (c >= count) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return false;
+}
+function testIfTwBackdrop(node, count = 2) {
+  if (node.type === "rule" && node.selector === "::backdrop") {
+    const nodes = node.nodes;
+    let c = 0;
+    for (const tryTestDecl of nodes) {
+      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
+        c++;
+      }
+      if (c >= count) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return false;
+}
+function makePseudoVarRule() {
+  const pseudoVarRule = new import_postcss.Rule({
+    // selectors: ['::before', '::after'],
+    selector: "::before,::after"
+  });
+  pseudoVarRule.append(
+    new import_postcss.Declaration({
+      prop: "--tw-content",
+      value: '""'
+    })
+  );
+  return pseudoVarRule;
+}
+function remakeCssVarSelector(selectors, options) {
+  const { cssPreflightRange, cssSelectorReplacement } = options;
+  if (cssPreflightRange === "all" && !selectors.includes(":not(not)")) {
+    selectors.push(":not(not)");
+  }
+  if (cssSelectorReplacement) {
+    if (Array.isArray(cssSelectorReplacement.universal)) {
+      if (!cssSelectorReplacement.universal.every((x) => {
+        return selectors.includes(x);
+      }) && !selectors.includes("*")) {
+        selectors.unshift("*");
+      }
+    } else if (typeof cssSelectorReplacement.universal === "string" && !selectors.includes(cssSelectorReplacement.universal) && !selectors.includes("*")) {
+      selectors.unshift("*");
+    }
+  }
+  return selectors;
+}
+function remakeCombinatorSelector(selector, cssChildCombinatorReplaceValue) {
+  let childCombinatorReplaceValue = "view + view";
+  if (Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
+    const x = composeIsPseudo(cssChildCombinatorReplaceValue);
+    childCombinatorReplaceValue = `${x} + ${x}`;
+  } else if (typeof cssChildCombinatorReplaceValue === "string") {
+    childCombinatorReplaceValue = cssChildCombinatorReplaceValue;
+  }
+  return selector.replaceAll(BROAD_MATCH_GLOBAL_REGEXP, childCombinatorReplaceValue);
+}
+function commonChunkPreflight(node, options) {
+  const { ctx, cssChildCombinatorReplaceValue, cssInjectPreflight, injectAdditionalCssVarScope } = options;
+  node.selector = remakeCombinatorSelector(node.selector, cssChildCombinatorReplaceValue);
+  if (testIfVariablesScope(node)) {
+    ctx == null ? void 0 : ctx.markVariablesScope(node);
+    node.selectors = remakeCssVarSelector(node.selectors, options);
+    node.before(makePseudoVarRule());
+    if (typeof cssInjectPreflight === "function") {
+      node.append(...cssInjectPreflight());
+    }
+  }
+  if (injectAdditionalCssVarScope && testIfTwBackdrop(node)) {
+    const syntheticRule = new import_postcss.Rule({
+      selectors: ["*", "::after", "::before"],
+      nodes: initialNodes
+    });
+    syntheticRule.selectors = remakeCssVarSelector(syntheticRule.selectors, options);
+    node.before(syntheticRule);
+    node.before(makePseudoVarRule());
+    if (typeof cssInjectPreflight === "function") {
+      syntheticRule.append(...cssInjectPreflight());
+    }
+  }
+}
+
+// src/constants.ts
+var postcssPlugin = "postcss-weapp-tailwindcss-rename-plugin";
+
+// src/postcss/plugins/pre.ts
+function isAtMediaHover(atRule) {
+  return /media\(\s*hover\s*:\s*hover\s*\)/.test(atRule.name) || atRule.name === "media" && /\(\s*hover\s*:\s*hover\s*\)/.test(atRule.params);
+}
+var postcssWeappTailwindcssPrePlugin = (options = {
+  isMainChunk: true
+}) => {
+  const { isMainChunk } = options;
+  const p = {
+    postcssPlugin,
+    Rule(rule) {
+      ruleTransformSync(rule, options);
+    },
+    AtRule(atRule) {
+      if (isAtMediaHover(atRule)) {
+        if (atRule.nodes) {
+          atRule.replaceWith(atRule.nodes);
+        } else {
+          atRule.remove();
+        }
+      }
+    }
+  };
+  if (isMainChunk) {
+    p.Once = (root) => {
+      root.walkRules((rule) => {
+        commonChunkPreflight(rule, options);
+      });
+    };
+  }
+  return p;
+};
+postcssWeappTailwindcssPrePlugin.postcss = true;
+
+// src/postcss/plugins/post.ts
+var postcssWeappTailwindcssPostPlugin = (options = {
+  isMainChunk: true
+}) => {
+  const { customRuleCallback, isMainChunk, ctx } = options;
+  const p = {
+    postcssPlugin
+  };
+  if (isMainChunk) {
+    p.OnceExit = (root) => {
+      root.walkRules((rule) => {
+        if (ctx) {
+          if (ctx.isVariablesScope(rule)) {
+            fallbackRemove.transformSync(rule, {
+              updateSelector: true,
+              lossless: false
+            });
+          }
+        } else if (testIfVariablesScope(rule)) {
+          fallbackRemove.transformSync(rule, {
+            updateSelector: true,
+            lossless: false
+          });
+        }
+      });
     };
+  }
+  if (typeof customRuleCallback === "function") {
+    p.Rule = (rule) => {
+      customRuleCallback(rule, options);
+    };
+  }
+  return p;
+};
+postcssWeappTailwindcssPostPlugin.postcss = true;
+
+// src/postcss/symbols.ts
+var VariablesScopeSymbol = Symbol("VariablesScope");
+
+// src/postcss/plugins/ctx.ts
+function createContext() {
+  const variablesScopeWeakMap = /* @__PURE__ */ new WeakMap();
+  function isVariablesScope(rule) {
+    return variablesScopeWeakMap.get(rule) === VariablesScopeSymbol;
+  }
+  function markVariablesScope(rule) {
+    variablesScopeWeakMap.set(rule, VariablesScopeSymbol);
+  }
+  return {
+    variablesScopeWeakMap,
+    isVariablesScope,
+    markVariablesScope
+  };
+}
+
+// src/postcss/plugins/index.ts
+var import_postcss_is_pseudo_class2 = __toESM(require("@csstools/postcss-is-pseudo-class"));
+var import_postcss_rem_to_responsive_pixel2 = __toESM(require("postcss-rem-to-responsive-pixel"));
+function getPlugins(options) {
+  var _a, _b;
+  const ctx = createContext();
+  options.ctx = ctx;
+  const plugins = [
+    ...(_b = (_a = options.postcssOptions) == null ? void 0 : _a.plugins) != null ? _b : [],
+    postcssWeappTailwindcssPrePlugin(options),
+    (0, import_postcss_is_pseudo_class.default)({
+      specificityMatchingName: "weapp-tw-ig"
+    })
+  ];
+  if (options.rem2rpx) {
+    plugins.push(
+      (0, import_postcss_rem_to_responsive_pixel.default)(
+        typeof options.rem2rpx === "object" ? options.rem2rpx : {
+          rootValue: 32,
+          propList: ["*"],
+          transformUnit: "rpx"
+        }
+      )
+    );
+  }
+  plugins.push(postcssWeappTailwindcssPostPlugin(options));
+  return plugins;
 }
 
-exports.createContext = createContext;
+// src/postcss/index.ts
+function styleHandler(rawSource, options) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    return (yield (0, import_postcss2.default)(getPlugins(options)).process(
+      rawSource,
+      (_b = (_a = options.postcssOptions) == null ? void 0 : _a.options) != null ? _b : {
+        from: void 0
+      }
+    ).async()).css;
+  });
+}
+function createStyleHandler(options) {
+  return (rawSource, opt) => {
+    return styleHandler(
+      rawSource,
+      defuOverrideArray(opt, options)
+    );
+  };
+}
+
+// src/postcss/preflight.ts
+function createInjectPreflight(options) {
+  const result = [];
+  if (options && typeof options === "object") {
+    const entries = Object.entries(options);
+    for (const [prop, value] of entries) {
+      if (value !== false) {
+        result.push({
+          prop,
+          value: value.toString()
+        });
+      }
+    }
+  }
+  return () => {
+    return result;
+  };
+}
+
+// src/tailwindcss/patcher.ts
+var import_node_path = __toESM(require("path"));
+var import_node_process = __toESM(require("process"));
+var import_tailwindcss_patch = require("tailwindcss-patch");
+function createTailwindcssPatcher(basedir, cacheDir, supportCustomLengthUnitsPatch) {
+  const cache = {};
+  if (cacheDir) {
+    if (import_node_path.default.isAbsolute(cacheDir)) {
+      cache.dir = cacheDir;
+    } else if (basedir) {
+      cache.dir = import_node_path.default.resolve(basedir, cacheDir);
+    } else {
+      cache.dir = import_node_path.default.resolve(import_node_process.default.cwd(), cacheDir);
+    }
+  }
+  return new import_tailwindcss_patch.TailwindcssPatcher({
+    cache,
+    patch: {
+      basedir,
+      applyPatches: {
+        exportContext: true,
+        extendLengthUnits: supportCustomLengthUnitsPatch
+      }
+    }
+  });
+}
+
+// src/mangle/index.ts
+var import_shared5 = require("@tailwindcss-mangle/shared");
+function getSelf(x) {
+  return x;
+}
+var defaultMangleContext = {
+  rawOptions: false,
+  runtimeSet: /* @__PURE__ */ new Set(),
+  classGenerator: new import_shared5.ClassGenerator(),
+  filter: import_shared5.defaultMangleClassFilter,
+  cssHandler: getSelf,
+  jsHandler: getSelf,
+  wxmlHandler: getSelf
+};
+function useMangleStore() {
+  const ctx = Object.assign({}, defaultMangleContext);
+  function resetMangle() {
+    return Object.assign(ctx, defaultMangleContext);
+  }
+  function handleValue(rawSource) {
+    const arr = splitCode(rawSource);
+    for (const x of arr) {
+      if (ctx.runtimeSet.has(x)) {
+        rawSource = rawSource.replace(new RegExp((0, reg_exports.escapeStringRegexp)(x)), ctx.classGenerator.generateClassName(x).name);
+      }
+    }
+    return rawSource;
+  }
+  function initMangle(options) {
+    var _a;
+    ctx.rawOptions = options;
+    if (options) {
+      if (options === true) {
+        options = {
+          classGenerator: {},
+          mangleClassFilter: import_shared5.defaultMangleClassFilter
+        };
+      }
+      ctx.classGenerator = new import_shared5.ClassGenerator(options.classGenerator);
+      ctx.filter = (_a = options.mangleClassFilter) != null ? _a : import_shared5.defaultMangleClassFilter;
+      ctx.jsHandler = (rawSource) => {
+        return handleValue(rawSource);
+      };
+      ctx.cssHandler = (rawSource) => {
+        return handleValue(rawSource);
+      };
+      ctx.wxmlHandler = (rawSource) => {
+        return handleValue(rawSource);
+      };
+    }
+  }
+  function setMangleRuntimeSet(runtimeSet) {
+    const newSet = /* @__PURE__ */ new Set();
+    for (const c of runtimeSet) {
+      if (ctx.filter(c)) {
+        newSet.add(c);
+      }
+    }
+    ctx.runtimeSet = newSet;
+  }
+  return {
+    mangleContext: ctx,
+    resetMangle,
+    initMangle,
+    setMangleRuntimeSet
+  };
+}
+
+// src/cache/index.ts
+var import_lru_cache = require("lru-cache");
+var import_md5 = __toESM(require("md5"));
+function createCache(options) {
+  const disabled = options === false;
+  const hashMap = /* @__PURE__ */ new Map();
+  const instance = new import_lru_cache.LRUCache({
+    // 可能会添加和删除一些页面和组件, 先设定 1024 吧
+    max: 1024,
+    ttl: 0,
+    ttlAutopurge: false
+  });
+  return {
+    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 (0, import_md5.default)(message);
+    },
+    calcHashValueChanged(key, hash) {
+      const hit = this.getHashValue(key);
+      if (hit) {
+        this.setHashValue(key, {
+          // new file should be changed
+          changed: hash !== hit.hash,
+          // new hash
+          hash
+        });
+      } else {
+        this.setHashValue(key, {
+          // new file should be changed
+          changed: true,
+          hash
+        });
+      }
+      return this;
+    },
+    has(key) {
+      return instance.has(key);
+    },
+    process(key, callback, fallback) {
+      return __async(this, null, function* () {
+        if (disabled) {
+          const res = yield fallback();
+          if (res) {
+            this.set(res.key, res.source);
+          }
+        } else {
+          const hit = this.getHashValue(key);
+          if (hit && !hit.changed) {
+            const returnFlag = yield callback();
+            if (returnFlag !== false) {
+              return;
+            }
+          }
+          const res = yield fallback();
+          if (res) {
+            this.set(res.key, res.source);
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/options.ts
+function getOptions(opts) {
+  const result = defuOverrideArray(
+    opts,
+    defaultOptions,
+    {}
+  );
+  result.escapeMap = result.customReplaceDictionary;
+  const {
+    cssPreflight,
+    customRuleCallback,
+    cssPreflightRange,
+    customAttributes,
+    supportCustomLengthUnitsPatch,
+    arbitraryValues,
+    cssChildCombinatorReplaceValue,
+    inlineWxs,
+    injectAdditionalCssVarScope,
+    jsPreserveClass,
+    disabledDefaultTemplateHandler,
+    cssSelectorReplacement,
+    rem2rpx,
+    cache,
+    jsAstTool,
+    babelParserOptions,
+    postcssOptions,
+    cssRemoveHoverPseudoClass,
+    escapeMap,
+    mangle,
+    tailwindcssBasedir,
+    appType
+  } = result;
+  const cssInjectPreflight = createInjectPreflight(cssPreflight);
+  const customAttributesEntities = isMap(customAttributes) ? [...customAttributes.entries()] : Object.entries(customAttributes);
+  const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();
+  initMangle(mangle);
+  const styleHandler2 = createStyleHandler({
+    cssInjectPreflight,
+    customRuleCallback,
+    cssPreflightRange,
+    escapeMap,
+    mangleContext,
+    cssChildCombinatorReplaceValue,
+    injectAdditionalCssVarScope,
+    cssSelectorReplacement,
+    rem2rpx,
+    postcssOptions,
+    cssRemoveHoverPseudoClass
+  });
+  const jsHandler2 = createJsHandler({
+    escapeMap,
+    mangleContext,
+    arbitraryValues,
+    jsPreserveClass,
+    generateMap: true,
+    jsAstTool,
+    babelParserOptions
+  });
+  const templateHandler = createTemplateHandler({
+    customAttributesEntities,
+    escapeMap,
+    mangleContext,
+    inlineWxs,
+    jsHandler: jsHandler2,
+    disabledDefaultTemplateHandler
+  });
+  result.styleHandler = styleHandler2;
+  result.jsHandler = jsHandler2;
+  result.templateHandler = templateHandler;
+  const twPatcher = createTailwindcssPatcher(tailwindcssBasedir, appType === "mpx" ? "node_modules/tailwindcss-patch/.cache" : void 0, supportCustomLengthUnitsPatch);
+  result.patch = twPatcher.patch;
+  result.setMangleRuntimeSet = setMangleRuntimeSet;
+  result.cache = cache === void 0 || typeof cache === "boolean" ? createCache(cache) : cache;
+  result.twPatcher = twPatcher;
+  return result;
+}
+
+// src/core.ts
+function createContext2(options = {}) {
+  const opts = getOptions(options);
+  const { templateHandler, styleHandler: styleHandler2, patch, jsHandler: jsHandler2, twPatcher } = opts;
+  let runtimeSet = /* @__PURE__ */ new Set();
+  patch == null ? void 0 : patch();
+  function transformWxss(rawCss, options2) {
+    return __async(this, null, function* () {
+      const code = yield styleHandler2(rawCss, Object.assign({
+        isMainChunk: true
+      }, options2));
+      return code;
+    });
+  }
+  function transformJs(_0) {
+    return __async(this, arguments, function* (rawJs, options2 = {}) {
+      runtimeSet = options2 && options2.runtimeSet ? options2.runtimeSet : twPatcher.getClassSet();
+      const { code } = yield jsHandler2(rawJs, runtimeSet, options2);
+      return code;
+    });
+  }
+  function transformWxml(rawWxml, options2) {
+    const code = templateHandler(rawWxml, Object.assign({
+      runtimeSet
+    }, options2));
+    return code;
+  }
+  return {
+    transformWxss,
+    transformWxml,
+    transformJs
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext
+});