weapp-tailwindcss 2.6.2 → 2.7.0

package/dist/{options-c5e1d1b4.js → options-7a4ffa6a.js}

@@ -1,172 +1,53 @@
 'use strict';
 
 var micromatch = require('micromatch');
-var t = require('@babel/types');
+var MagicString = require('magic-string');
+var replace = require('./replace.js');
+var regex = require('@weapp-core/regex');
 var generate = require('@babel/generator');
 var parser = require('@babel/parser');
 var traverse = require('@babel/traverse');
-var replace = require('./replace.js');
-var defaults = require('./defaults-d79e9245.js');
+var defaults = require('./defaults-344ba6d9.js');
+var t = require('@babel/types');
 var postcss = require('postcss');
-var postcss$1 = require('./postcss-4c88cd6d.js');
+var postcss$1 = require('./postcss-4e99a8e8.js');
 var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
-var dic = require('./dic-05980807.js');
+var escape = require('@weapp-core/escape');
 var path = require('node:path');
 var fs = require('node:fs');
 var semver = require('semver');
 var tailwindcssPatch = require('tailwindcss-patch');
-var tailwindcssMangleShared = require('tailwindcss-mangle-shared');
+var shared = require('@tailwindcss-mangle/shared');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
         });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
+    }
+    n["default"] = e;
+    return Object.freeze(n);
 }
 
-var t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+var MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 var generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
 var traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
+var t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
 var postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
 var postcssIsPseudoClass__default = /*#__PURE__*/_interopDefaultCompat(postcssIsPseudoClass);
 var path__default = /*#__PURE__*/_interopDefaultCompat(path);
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
-function isObject(value) {
-  return value !== null && typeof value === "object";
-}
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isObject(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 (isObject(value) && isObject(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), {})
-  );
-}
-const defu = createDefu();
-
-function escapeStringRegexp(str) {
-    if (typeof str !== 'string') {
-        throw new TypeError('Expected a string');
-    }
-    return str.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&').replaceAll('-', '\\x2d');
-}
-const templateClassExactRegexp = /(?<=^|\s)(?:hover-)?class=(?:["']\W+\s*\w+\()?["']([^"]+)["']/gs;
-const tagWithEitherClassAndHoverClassRegexp = /<[a-z][a-z-]*[a-z]*\s+[^>]*?(?:hover-)?class="[^"]*"[^>]*?\/?>/g;
-function handleRegexp(reg) {
-    return `(?:${reg.source})`;
-}
-function getSourceString(input) {
-    let result;
-    if (typeof input === 'string') {
-        result = input;
-    }
-    else if (defaults.isRegexp(input)) {
-        result = input.source;
-    }
-    else {
-        result = input.toString();
-    }
-    return result;
-}
-function makePattern(arr) {
-    let pattern = '';
-    if (Array.isArray(arr)) {
-        pattern = arr
-            .reduce((acc, cur) => {
-            if (typeof cur === 'string') {
-                acc.push(cur);
-            }
-            else if (defaults.isRegexp(cur)) {
-                acc.push(handleRegexp(cur));
-            }
-            return acc;
-        }, [])
-            .join('|');
-    }
-    else if (typeof arr === 'string') {
-        pattern = arr;
-    }
-    else if (defaults.isRegexp(arr)) {
-        pattern = handleRegexp(arr);
-    }
-    return pattern;
-}
-function createTemplateHandlerMatchRegexp(tag, attrs, options = {}) {
-    const { exact = true } = options;
-    const prefix = exact ? '(?<=^|\\s)' : '';
-    const pattern = makePattern(attrs);
-    let tagPattern = getSourceString(tag);
-    if (tagPattern === '*') {
-        tagPattern = '[a-z][-a-z]*[a-z]*';
-    }
-    const source = `<(${tagPattern})\\s+[^>]*?(?:${prefix}(${pattern})="(?:[^"]*)")[^>]*?\\/?>`;
-    return new RegExp(source, 'g');
-}
-function createTemplateClassRegexp(attrs, options = {}) {
-    const { exact = true } = options;
-    const prefix = exact ? '(?<=^|\\s)' : '';
-    const pattern = makePattern(attrs);
-    const source = `(?:${prefix}${pattern})=(?:["']\\W+\\s*(?:\\w+)\\()?["']([^"]+)['"]`;
-    return new RegExp(source, 'gs');
-}
-function makeCustomAttributes(entries) {
-    if (Array.isArray(entries)) {
-        return entries.map(([k, v]) => {
-            return {
-                tagRegexp: createTemplateHandlerMatchRegexp(k, v),
-                attrRegexp: createTemplateClassRegexp(v),
-                tag: getSourceString(k),
-                attrs: v
-            };
-        });
-    }
-}
-const variableRegExp = /{{(.*?)}}/gs;
-const wxsTagRegexp = /<wxs\s*(?:[a-z][a-z-]*[a-z]*(?:\s*=\s*".*?")?)*\s*>(.*?)<\/wxs>/gs;
-
 const validateFilterRE = /[\w%-?\u00A0-\uFFFF-]/;
 function isValidSelector(selector = '') {
     return validateFilterRE.test(selector);
@@ -176,9 +57,7 @@ const splitCode = (code, allowDoubleQuotes = false) => {
     return code.split(splitter).filter((element) => isValidSelector(element));
 };
 
-const isProd = () => process.env.NODE_ENV === 'production';
-
-function handleValue(str, node, options) {
+function regenerateHandleValue(str, node, options) {
     var _a;
     const set = options.classNameSet;
     const escapeMap = options.escapeMap;
@@ -197,7 +76,7 @@ function handleValue(str, node, options) {
                 if (ctx) {
                     rawStr = ctx.jsHandler(rawStr);
                 }
-                rawStr = rawStr.replaceAll(new RegExp(escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
+                rawStr = rawStr.replaceAll(new RegExp(regex.escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
                     escapeMap
                 }));
             }
@@ -205,44 +84,126 @@ function handleValue(str, node, options) {
     }
     return rawStr;
 }
+function replaceHandleValue(str, node, options, ms, offset = 1) {
+    var _a;
+    const set = options.classNameSet;
+    const escapeMap = options.escapeMap;
+    const allowDoubleQuotes = (_a = options.arbitraryValues) === null || _a === void 0 ? void 0 : _a.allowDoubleQuotes;
+    const ctx = options.mangleContext;
+    const jsPreserveClass = options.jsPreserveClass;
+    const arr = splitCode(str, allowDoubleQuotes);
+    let rawStr = str;
+    for (const v of arr) {
+        if (set.has(v) && !(jsPreserveClass === null || jsPreserveClass === void 0 ? 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.replaceAll(new RegExp(regex.escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
+                    escapeMap
+                }));
+            }
+        }
+    }
+    if (typeof node.start === 'number' && typeof node.end === 'number') {
+        const start = node.start + offset;
+        const end = node.end - offset;
+        if (start < end) {
+            ms.update(node.start + offset, node.end - offset, rawStr);
+        }
+    }
+    return rawStr;
+}
+
+const isProd = () => process.env.NODE_ENV === 'production';
+
 function jsHandler(rawSource, options) {
     var _a;
     const ast = parser.parse(rawSource, {
         sourceType: 'unambiguous'
     });
-    const topt = {
-        StringLiteral: {
-            enter(p) {
-                const n = p.node;
-                n.value = handleValue(n.value, n, options);
-            }
-        },
-        TemplateElement: {
-            enter(p) {
-                const n = p.node;
-                n.value.raw = handleValue(n.value.raw, n, options);
+    if (options.strategy === 'replace') {
+        const ms = new MagicString__default["default"](rawSource);
+        const ropt = {
+            StringLiteral: {
+                enter(p) {
+                    const n = p.node;
+                    replaceHandleValue(n.value, n, options, ms);
+                }
+            },
+            TemplateElement: {
+                enter(p) {
+                    const n = p.node;
+                    replaceHandleValue(n.value.raw, n, options, ms, 0);
+                }
+            },
+            CallExpression: {
+                enter(p) {
+                    const calleePath = p.get('callee');
+                    if (calleePath.isIdentifier() && calleePath.node.name === 'eval') {
+                        p.traverse({
+                            StringLiteral: {
+                                enter(s) {
+                                    const res = jsHandler(s.node.value, options);
+                                    if (res.code) {
+                                        s.node.value = res.code;
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
             }
-        },
-        CallExpression: {
-            enter(p) {
-                const n = p.node;
-                if (t__namespace.isIdentifier(n.callee) && n.callee.name === 'eval' && t__namespace.isStringLiteral(n.arguments[0])) {
-                    const res = jsHandler(n.arguments[0].value, options);
-                    if (res.code) {
-                        n.arguments[0].value = res.code;
+        };
+        traverse__default["default"](ast, ropt);
+        return {
+            code: ms.toString()
+        };
+    }
+    else {
+        const gopt = {
+            StringLiteral: {
+                enter(p) {
+                    const n = p.node;
+                    n.value = regenerateHandleValue(n.value, n, options);
+                }
+            },
+            TemplateElement: {
+                enter(p) {
+                    const n = p.node;
+                    n.value.raw = regenerateHandleValue(n.value.raw, n, options);
+                }
+            },
+            CallExpression: {
+                enter(p) {
+                    const calleePath = p.get('callee');
+                    if (calleePath.isIdentifier() && calleePath.node.name === 'eval') {
+                        p.traverse({
+                            StringLiteral: {
+                                enter(s) {
+                                    const res = jsHandler(s.node.value, options);
+                                    if (res.code) {
+                                        s.node.value = res.code;
+                                    }
+                                }
+                            }
+                        });
                     }
                 }
             }
-        },
-        noScope: true
-    };
-    traverse__default["default"](ast, topt);
-    return generate__default["default"](ast, {
-        minified: (_a = options.minifiedJs) !== null && _a !== void 0 ? _a : isProd()
-    });
+        };
+        traverse__default["default"](ast, gopt);
+        return generate__default["default"](ast, {
+            minified: (_a = options.minifiedJs) !== null && _a !== void 0 ? _a : isProd()
+        });
+    }
 }
 function createjsHandler(options) {
-    const { mangleContext, arbitraryValues, minifiedJs, escapeMap, jsPreserveClass } = options;
+    const { mangleContext, arbitraryValues, minifiedJs, escapeMap, jsPreserveClass, strategy } = options;
     return (rawSource, set) => {
         return jsHandler(rawSource, {
             classNameSet: set,
@@ -250,11 +211,54 @@ function createjsHandler(options) {
             escapeMap,
             arbitraryValues,
             mangleContext,
-            jsPreserveClass
+            jsPreserveClass,
+            strategy
         });
     };
 }
 
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(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 (isObject(value) && isObject(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), {})
+  );
+}
+const defu = createDefu();
+
 function generateCode(match, options = {}) {
     const ast = parser.parseExpression(match);
     traverse__default["default"](ast, {
@@ -296,7 +300,7 @@ function extract(original, reg) {
     return sources;
 }
 function extractSource(original) {
-    return extract(original, variableRegExp);
+    return extract(original, regex.variableRegExp);
 }
 function templateReplacer(original, options = {}) {
     const sources = extractSource(original);
@@ -345,8 +349,8 @@ function templateHandler(rawSource, options = {}) {
     if (options.disabledDefaultTemplateHandler) {
         return rawSource;
     }
-    return rawSource.replace(tagWithEitherClassAndHoverClassRegexp, (m0) => {
-        return m0.replace(templateClassExactRegexp, (m1, className) => {
+    return rawSource.replace(regex.tagWithEitherClassAndHoverClassRegexp, (m0) => {
+        return m0.replace(regex.templateClassExactRegexp, (m1, className) => {
             return m1.replace(className, templateReplacer(className, options));
         });
     });
@@ -354,7 +358,7 @@ function templateHandler(rawSource, options = {}) {
 function customTemplateHandler(rawSource, options) {
     const { customAttributesEntities, inlineWxs, runtimeSet, jsHandler } = options;
     let source = templateHandler(rawSource, options);
-    const regexps = makeCustomAttributes(customAttributesEntities);
+    const regexps = regex.makeCustomAttributes(customAttributesEntities);
     if (regexps && Array.isArray(regexps)) {
         for (const regexp of regexps) {
             source = source.replace(regexp.tagRegexp, (m0) => {
@@ -365,7 +369,7 @@ function customTemplateHandler(rawSource, options) {
         }
     }
     if (inlineWxs) {
-        const wxsTags = extract(source, wxsTagRegexp);
+        const wxsTags = extract(source, regex.wxsTagRegexp);
         for (const x of wxsTags) {
             const code = jsHandler(x.raw, runtimeSet).code;
             source = source.replaceAll(x.raw, code);
@@ -529,8 +533,8 @@ function getSelf(x) {
 const defaultMangleContext = {
     rawOptions: false,
     runtimeSet: new Set(),
-    classGenerator: new tailwindcssMangleShared.ClassGenerator(),
-    filter: tailwindcssMangleShared.defaultMangleClassFilter,
+    classGenerator: new shared.ClassGenerator(),
+    filter: shared.defaultMangleClassFilter,
     cssHandler: getSelf,
     jsHandler: getSelf,
     wxmlHandler: getSelf
@@ -544,7 +548,7 @@ function useMangleStore() {
         const arr = splitCode(rawSource);
         for (const x of arr) {
             if (ctx.runtimeSet.has(x)) {
-                rawSource = rawSource.replaceAll(new RegExp(escapeStringRegexp(x), 'g'), ctx.classGenerator.generateClassName(x).name);
+                rawSource = rawSource.replaceAll(new RegExp(regex.escapeStringRegexp(x), 'g'), ctx.classGenerator.generateClassName(x).name);
             }
         }
         return rawSource;
@@ -556,11 +560,11 @@ function useMangleStore() {
             if (options === true) {
                 options = {
                     classGenerator: {},
-                    mangleClassFilter: tailwindcssMangleShared.defaultMangleClassFilter
+                    mangleClassFilter: shared.defaultMangleClassFilter
                 };
             }
-            ctx.classGenerator = new tailwindcssMangleShared.ClassGenerator(options.classGenerator);
-            ctx.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : tailwindcssMangleShared.defaultMangleClassFilter;
+            ctx.classGenerator = new shared.ClassGenerator(options.classGenerator);
+            ctx.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : shared.defaultMangleClassFilter;
             ctx.jsHandler = (rawSource) => {
                 return handleValue(rawSource);
             };
@@ -604,10 +608,10 @@ function getOptions(options = {}) {
         options.supportCustomLengthUnitsPatch = undefined;
     }
     if (options.customReplaceDictionary === 'simple') {
-        options.customReplaceDictionary = dic.SimpleMappingChars2String;
+        options.customReplaceDictionary = escape.SimpleMappingChars2String;
     }
     else if (options.customReplaceDictionary === 'complex') {
-        options.customReplaceDictionary = dic.MappingChars2String;
+        options.customReplaceDictionary = escape.MappingChars2String;
     }
     normalizeMatcher(options, 'cssMatcher');
     normalizeMatcher(options, 'htmlMatcher');
@@ -617,7 +621,7 @@ function getOptions(options = {}) {
     const result = defu(options, defaults.defaultOptions, {
         minifiedJs: isProd()
     });
-    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch, arbitraryValues, cssChildCombinatorReplaceValue, inlineWxs, injectAdditionalCssVarScope, jsPreserveClass, disabledDefaultTemplateHandler } = result;
+    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch, arbitraryValues, cssChildCombinatorReplaceValue, inlineWxs, injectAdditionalCssVarScope, jsPreserveClass, disabledDefaultTemplateHandler, jsEscapeStrategy } = result;
     result.escapeMap = customReplaceDictionary;
     const cssInjectPreflight = createInjectPreflight(cssPreflight);
     const customAttributesEntities = defaults.isMap(options.customAttributes)
@@ -642,7 +646,8 @@ function getOptions(options = {}) {
         escapeMap,
         mangleContext,
         arbitraryValues,
-        jsPreserveClass
+        jsPreserveClass,
+        strategy: jsEscapeStrategy
     });
     result.jsHandler = jsHandler;
     const templateHandler = createTemplateHandler({

package/dist/{postcss-4c88cd6d.js → postcss-4e99a8e8.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var selectorParser = require('postcss-selector-parser');
-var shared = require('./shared-4eed0e5c.js');
+var shared = require('./shared-df9de23f.js');
 var postcss = require('postcss');
 require('@csstools/postcss-is-pseudo-class');
 

package/dist/{postcss-99efb521.mjs → postcss-a551ddc0.mjs}

@@ -1,5 +1,5 @@
 import selectorParser from 'postcss-selector-parser';
-import { i as internalCssSelectorReplacer } from './shared-686bfc32.mjs';
+import { i as internalCssSelectorReplacer } from './shared-fd149084.mjs';
 import { Declaration, Rule } from 'postcss';
 import '@csstools/postcss-is-pseudo-class';
 

package/dist/postcss.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var postcss = require('./postcss-4c88cd6d.js');
+var postcss = require('./postcss-4e99a8e8.js');
 var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
 require('postcss-selector-parser');
-require('./shared-4eed0e5c.js');
-require('./dic-05980807.js');
+require('./shared-df9de23f.js');
+require('@weapp-core/escape');
 require('postcss');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

package/dist/postcss.mjs

@@ -1,6 +1,6 @@
-export { p as postcssWeappTailwindcss } from './postcss-99efb521.mjs';
+export { p as postcssWeappTailwindcss } from './postcss-a551ddc0.mjs';
 export { default as postcssIsPseudoClass } from '@csstools/postcss-is-pseudo-class';
 import 'postcss-selector-parser';
-import './shared-686bfc32.mjs';
-import './dic-3790a3a4.mjs';
+import './shared-fd149084.mjs';
+import '@weapp-core/escape';
 import 'postcss';

package/dist/reg.d.ts

@@ -1,16 +1 @@
-import type { ICustomRegexp, ItemOrItemArray } from "./types";
-export declare function escapeStringRegexp(str: string): string;
-export declare const templateClassExactRegexp: RegExp;
-export declare const tagWithEitherClassAndHoverClassRegexp: RegExp;
-interface ICreateRegexpOptions {
-    exact?: boolean;
-}
-export declare function handleRegexp(reg: RegExp): string;
-export declare function getSourceString(input: string | RegExp): string;
-export declare function makePattern(arr: ItemOrItemArray<string | RegExp>): string;
-export declare function createTemplateHandlerMatchRegexp(tag: string | RegExp, attrs: ItemOrItemArray<string | RegExp>, options?: ICreateRegexpOptions): RegExp;
-export declare function createTemplateClassRegexp(attrs: ItemOrItemArray<string | RegExp>, options?: ICreateRegexpOptions): RegExp;
-export declare function makeCustomAttributes(entries?: [string | RegExp, ItemOrItemArray<string | RegExp>][]): ICustomRegexp[] | undefined;
-export declare const variableRegExp: RegExp;
-export declare const wxsTagRegexp: RegExp;
-export {};
+export * from '@weapp-core/regex';

package/dist/replace.d.ts

@@ -1,3 +1,3 @@
-export * from './dic';
+export { MappingChars2String, MappingChars2StringEntries, MappingStringDictionary, SYMBOL_TABLE, SYMBOL_TABLE_TYPE, SYMBOL_TABLE_TYPE_VALUES, SimpleMappingChars2String, SimpleMappingChars2StringEntries } from './escape';
 export { replaceWxml as replaceJs } from './wxml/shared';
 export { internalCssSelectorReplacer as replaceCss } from './postcss/shared';

package/dist/replace.js

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dic = require('./dic-05980807.js');
-var shared = require('./shared-4eed0e5c.js');
+var escape = require('@weapp-core/escape');
+var shared = require('./shared-df9de23f.js');
 
 function replaceWxml(original, options = {
     keepEOL: false,
-    escapeMap: dic.SimpleMappingChars2String
+    escapeMap: escape.SimpleMappingChars2String
 }) {
     const { keepEOL, escapeMap, mangleContext } = options;
     let res = original;
@@ -18,16 +18,31 @@ function replaceWxml(original, options = {
     if (mangleContext) {
         res = mangleContext.wxmlHandler(res);
     }
-    res = shared.escape(res, {
+    res = escape.escape(res, {
         map: escapeMap
     });
     return res;
 }
 
-exports.MappingChars2String = dic.MappingChars2String;
-exports.MappingChars2StringEntries = dic.MappingChars2StringEntries;
-exports.SYMBOL_TABLE = dic.SYMBOL_TABLE;
-exports.SimpleMappingChars2String = dic.SimpleMappingChars2String;
-exports.SimpleMappingChars2StringEntries = dic.SimpleMappingChars2StringEntries;
+Object.defineProperty(exports, 'MappingChars2String', {
+    enumerable: true,
+    get: function () { return escape.MappingChars2String; }
+});
+Object.defineProperty(exports, 'MappingChars2StringEntries', {
+    enumerable: true,
+    get: function () { return escape.MappingChars2StringEntries; }
+});
+Object.defineProperty(exports, 'SYMBOL_TABLE', {
+    enumerable: true,
+    get: function () { return escape.SYMBOL_TABLE; }
+});
+Object.defineProperty(exports, 'SimpleMappingChars2String', {
+    enumerable: true,
+    get: function () { return escape.SimpleMappingChars2String; }
+});
+Object.defineProperty(exports, 'SimpleMappingChars2StringEntries', {
+    enumerable: true,
+    get: function () { return escape.SimpleMappingChars2StringEntries; }
+});
 exports.replaceCss = shared.internalCssSelectorReplacer;
 exports.replaceJs = replaceWxml;

package/dist/replace.mjs

@@ -1,7 +1,6 @@
-import { S as SimpleMappingChars2String } from './dic-3790a3a4.mjs';
-export { M as MappingChars2String, b as MappingChars2StringEntries, a as SYMBOL_TABLE, c as SimpleMappingChars2StringEntries } from './dic-3790a3a4.mjs';
-import { e as escape } from './shared-686bfc32.mjs';
-export { i as replaceCss } from './shared-686bfc32.mjs';
+import { escape, SimpleMappingChars2String } from '@weapp-core/escape';
+export { MappingChars2String, MappingChars2StringEntries, SYMBOL_TABLE, SimpleMappingChars2String, SimpleMappingChars2StringEntries } from '@weapp-core/escape';
+export { i as replaceCss } from './shared-fd149084.mjs';
 
 function replaceWxml(original, options = {
     keepEOL: false,
@@ -22,4 +21,4 @@ function replaceWxml(original, options = {
     return res;
 }
 
-export { SimpleMappingChars2String, replaceWxml as replaceJs };
+export { replaceWxml as replaceJs };