weapp-tailwindcss 3.7.0 → 3.8.0-alpha.1

package/dist/chunk-MWTUP5KG.mjs

@@ -0,0 +1,1003 @@
+import {
+  getDefaultOptions
+} from "./chunk-FG63RW47.mjs";
+import {
+  defuOverrideArray,
+  isMap
+} from "./chunk-MUJ65IQ3.mjs";
+import {
+  getPlugins
+} from "./chunk-KE7J6XFD.mjs";
+import {
+  replaceWxml
+} from "./chunk-U7O2XXYR.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-AXBFBHS2.mjs";
+
+// src/logger.ts
+import { logger } from "@weapp-tailwindcss/logger";
+
+// src/cache/index.ts
+import { LRUCache } from "lru-cache";
+import md5 from "md5";
+function createCache(options) {
+  const disabled = options === false;
+  const hashMap = /* @__PURE__ */ new Map();
+  const instance = new 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 md5(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/js/ast-grep.ts
+import MagicString from "magic-string";
+
+// src/js/handlers.ts
+import { jsStringEscape } from "@ast-core/escape";
+import { escapeStringRegexp } from "@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/utils/decode.ts
+function decodeUnicode2(input) {
+  try {
+    return JSON.parse(`"${input}"`);
+  } catch (_error) {
+    return input;
+  }
+}
+
+// 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(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 ? jsStringEscape(rawStr) : rawStr;
+      ms.update(start, end, content);
+    }
+  }
+  return rawStr;
+}
+
+// src/js/ast-grep.ts
+function getAstGrep() {
+  return __async(this, null, function* () {
+    try {
+      const mod = yield import("@ast-grep/napi");
+      return mod;
+    } catch (error) {
+      logger.warn("\u8BF7\u5148\u5B89\u88C5 `@ast-grep/napi` , \u5B89\u88C5\u5B8C\u6210\u540E\u518D\u5C1D\u8BD5\u8FD0\u884C\uFF01");
+      throw error;
+    }
+  });
+}
+function isRangeWithinArray(ranges, targetRange) {
+  const { start: targetStart, end: targetEnd } = targetRange;
+  return ranges.some(({ start, end }) => {
+    return start.index <= targetStart.index && end.index >= targetEnd.index;
+  });
+}
+function astGrepUpdateString(ast, options, ms) {
+  return __async(this, null, function* () {
+    var _a;
+    const { Lang, kind } = yield getAstGrep();
+    const callExpressionNodes = ast.findAll(kind(Lang.JavaScript, "call_expression"));
+    let chooseNodeRanges = [];
+    if (Array.isArray(options.ignoreCallExpressionIdentifiers) && options.ignoreCallExpressionIdentifiers.length) {
+      chooseNodeRanges = callExpressionNodes.filter((x) => {
+        var _a2;
+        const id = x.child(0);
+        return (id == null ? void 0 : id.kindToRefine) === "identifier" && ((_a2 = options.ignoreCallExpressionIdentifiers) == null ? void 0 : _a2.includes(id.text()));
+      }).map((x) => x == null ? void 0 : x.range());
+    }
+    const nodes = ast.findAll(kind(Lang.JavaScript, "string"));
+    for (const node of nodes) {
+      const range = node.range();
+      if (isRangeWithinArray(chooseNodeRanges, range)) {
+        continue;
+      }
+      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(kind(Lang.JavaScript, "template_string"));
+    for (const node of templateNodes) {
+      const p = node.parent();
+      if (p && p.kind() === "call_expression") {
+        const c = p.child(0);
+        if (c && c.kind() === "identifier" && ((_a = options.ignoreTaggedTemplateExpressionIdentifiers) == null ? void 0 : _a.includes(c.text()))) {
+          continue;
+        }
+      }
+      const fragments = node.findAll(kind(Lang.JavaScript, "string_fragment"));
+      for (const fragment of fragments) {
+        const range = fragment.range();
+        if (isRangeWithinArray(chooseNodeRanges, range)) {
+          continue;
+        }
+        const text = fragment.text();
+        replaceHandleValue(
+          text,
+          {
+            end: range.end.index,
+            start: range.start.index
+          },
+          __spreadProps(__spreadValues({}, options), {
+            unescapeUnicode: true
+          }),
+          ms,
+          0
+        );
+      }
+    }
+  });
+}
+function jsHandlerAsync(rawSource, options) {
+  return __async(this, null, function* () {
+    const ms = new MagicString(rawSource);
+    const { parseAsync, Lang } = yield getAstGrep();
+    let ast;
+    try {
+      const root = yield parseAsync(Lang.JavaScript, rawSource);
+      ast = root.root();
+    } catch (e) {
+      return {
+        code: rawSource
+      };
+    }
+    yield astGrepUpdateString(ast, options, ms);
+    return {
+      code: ms.toString()
+    };
+  });
+}
+
+// src/js/babel.ts
+import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
+import MagicString2 from "magic-string";
+
+// src/babel/index.ts
+import _babelGenerate from "@babel/generator";
+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 generate = _interopDefaultCompat(_babelGenerate);
+var traverse = _interopDefaultCompat(_babelTraverse);
+
+// src/js/babel.ts
+function isEvalPath(p) {
+  if (p.isCallExpression()) {
+    const calleePath = p.get("callee");
+    return calleePath.isIdentifier() && calleePath.node.name === "eval";
+  }
+  return false;
+}
+var ignoreFlagMap = /* @__PURE__ */ new WeakMap();
+function jsHandler(rawSource, options) {
+  const ms = new MagicString2(rawSource);
+  let ast;
+  try {
+    ast = parse(rawSource, options.babelParserOptions);
+  } catch (error) {
+    return {
+      code: rawSource,
+      error
+    };
+  }
+  let ignoreFlag = false;
+  const traverseOptions = {
+    StringLiteral: {
+      enter(p) {
+        var _a;
+        if (ignoreFlag) {
+          return;
+        }
+        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
+        );
+      }
+    },
+    TemplateElement: {
+      enter(p) {
+        var _a;
+        if (ignoreFlag) {
+          return;
+        }
+        if (p.parentPath.isTemplateLiteral()) {
+          if (p.parentPath.parentPath.isTaggedTemplateExpression() && p.parentPath.parentPath.get("tag").isIdentifier() && ((_a = options.ignoreTaggedTemplateExpressionIdentifiers) == null ? void 0 : _a.includes(p.parentPath.parentPath.get("tag").node.name)) || isEvalPath(p.parentPath.parentPath)) {
+            return;
+          }
+        }
+        const n = p.node;
+        replaceHandleValue(
+          n.value.raw,
+          n,
+          __spreadProps(__spreadValues({}, options), {
+            needEscaped: false
+          }),
+          ms,
+          0
+        );
+      }
+    },
+    CallExpression: {
+      enter(p) {
+        var _a;
+        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, jsStringEscape2(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;
+                    }
+                  }
+                }
+              }
+            }
+          });
+        } else if (p.get("callee").isIdentifier() && ((_a = options.ignoreCallExpressionIdentifiers) == null ? void 0 : _a.includes(p.get("callee").node.name))) {
+          ignoreFlag = true;
+          ignoreFlagMap.set(p, true);
+        }
+      },
+      exit(p) {
+        const flag = ignoreFlagMap.get(p);
+        if (flag) {
+          ignoreFlag = false;
+          ignoreFlagMap.delete(p);
+        }
+      }
+    }
+  };
+  traverse(ast, traverseOptions);
+  return {
+    code: ms.toString(),
+    get map() {
+      return ms.generateMap();
+    }
+  };
+}
+
+// src/js/index.ts
+function createJsHandler(options) {
+  const {
+    mangleContext,
+    arbitraryValues,
+    escapeMap,
+    jsPreserveClass,
+    generateMap,
+    jsAstTool,
+    babelParserOptions,
+    ignoreCallExpressionIdentifiers,
+    ignoreTaggedTemplateExpressionIdentifiers
+  } = options;
+  function _jsHandler(rawSource, set, options2) {
+    const opts = defuOverrideArray(options2, {
+      classNameSet: set,
+      escapeMap,
+      arbitraryValues,
+      mangleContext,
+      jsPreserveClass,
+      generateMap,
+      jsAstTool,
+      babelParserOptions,
+      ignoreCallExpressionIdentifiers,
+      ignoreTaggedTemplateExpressionIdentifiers
+    });
+    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,
+      ignoreCallExpressionIdentifiers,
+      ignoreTaggedTemplateExpressionIdentifiers
+    });
+    return jsHandler(rawSource, opts);
+  }
+  _jsHandler.sync = sync;
+  return _jsHandler;
+}
+
+// src/mangle/index.ts
+import { ClassGenerator, defaultMangleClassFilter } from "@tailwindcss-mangle/shared";
+import { escapeStringRegexp as escapeStringRegexp2 } from "@weapp-core/regex";
+function getSelf(x) {
+  return x;
+}
+var defaultMangleContext = {
+  rawOptions: false,
+  runtimeSet: /* @__PURE__ */ new Set(),
+  classGenerator: new ClassGenerator(),
+  filter: 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(escapeStringRegexp2(x)), ctx.classGenerator.generateClassName(x).name);
+      }
+    }
+    return rawSource;
+  }
+  function initMangle(options) {
+    var _a;
+    ctx.rawOptions = options;
+    if (options) {
+      if (options === true) {
+        options = {
+          classGenerator: {},
+          mangleClassFilter: defaultMangleClassFilter
+        };
+      }
+      ctx.classGenerator = new ClassGenerator(options.classGenerator);
+      ctx.filter = (_a = options.mangleClassFilter) != null ? _a : 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/postcss/index.ts
+import postcss from "postcss";
+function styleHandler(rawSource, options) {
+  var _a, _b;
+  return postcss(getPlugins(options)).process(
+    rawSource,
+    (_b = (_a = options.postcssOptions) == null ? void 0 : _a.options) != null ? _b : {
+      from: void 0
+    }
+  ).async();
+}
+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
+import path from "node:path";
+import process from "node:process";
+import { TailwindcssPatcher } from "tailwindcss-patch";
+function createTailwindcssPatcher(basedir, cacheDir, supportCustomLengthUnitsPatch) {
+  const cache = {};
+  if (cacheDir) {
+    if (path.isAbsolute(cacheDir)) {
+      cache.dir = cacheDir;
+    } else if (basedir) {
+      cache.dir = path.resolve(basedir, cacheDir);
+    } else {
+      cache.dir = path.resolve(process.cwd(), cacheDir);
+    }
+  }
+  return new TailwindcssPatcher({
+    cache,
+    patch: {
+      basedir,
+      applyPatches: {
+        exportContext: true,
+        extendLengthUnits: supportCustomLengthUnitsPatch
+      }
+    }
+  });
+}
+
+// src/wxml/utils.ts
+import * as t from "@babel/types";
+import { Parser } from "htmlparser2";
+import MagicString3 from "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 MagicString3(match);
+      const ast = 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 handleEachClassFragment(ms, tokens, options = {}) {
+  for (const token of tokens) {
+    let p = token.start;
+    if (token.expressions.length > 0) {
+      for (const exp of token.expressions) {
+        if (exp.start > token.start && p < exp.start) {
+          ms.update(p, exp.start, replaceWxml(ms.slice(p, exp.start), {
+            keepEOL: true,
+            escapeMap: options.escapeMap,
+            mangleContext: options.mangleContext,
+            // 首的str才会被转译
+            // example: 2xl:xx 2x{{y}}
+            ignoreHead: p > 0
+          }));
+        }
+        const code = `{{${generateCode(exp.value.slice(2, -2), options)}}}`;
+        ms.update(exp.start, exp.end, code);
+        p = exp.end;
+      }
+      if (token.end > p) {
+        ms.update(p, token.end, replaceWxml(ms.slice(p, token.end), {
+          keepEOL: false,
+          escapeMap: options.escapeMap,
+          mangleContext: options.mangleContext,
+          ignoreHead: true
+        }));
+      }
+    } else {
+      ms.update(token.start, token.end, replaceWxml(token.value, {
+        keepEOL: false,
+        escapeMap: options.escapeMap,
+        mangleContext: options.mangleContext,
+        ignoreHead: false
+      }));
+    }
+  }
+}
+function templateReplacer(original, options = {}) {
+  const ms = new MagicString3(original);
+  const tokenizer = new Tokenizer();
+  const tokens = tokenizer.run(ms.original);
+  handleEachClassFragment(ms, tokens, options);
+  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 MagicString3(rawSource);
+    let tag = "";
+    const wxsArray = [];
+    const parser = new 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/options.ts
+function getOptions(opts) {
+  const result = defuOverrideArray(
+    opts,
+    getDefaultOptions(),
+    {}
+  );
+  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,
+    ignoreCallExpressionIdentifiers,
+    ignoreTaggedTemplateExpressionIdentifiers
+  } = 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,
+    ignoreCallExpressionIdentifiers,
+    ignoreTaggedTemplateExpressionIdentifiers
+  });
+  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 != null ? supportCustomLengthUnitsPatch : true);
+  result.patch = twPatcher.patch;
+  result.setMangleRuntimeSet = setMangleRuntimeSet;
+  result.cache = cache === void 0 || typeof cache === "boolean" ? createCache(cache) : cache;
+  result.twPatcher = twPatcher;
+  return result;
+}
+
+export {
+  logger,
+  getOptions
+};