weapp-tailwindcss 2.3.3

package/dist/postcss-dc9eeafc.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var selectorParser = require('postcss-selector-parser');
+var shared = require('./shared-c2953d9d.js');
+var postcss = require('postcss');
+require('@csstools/postcss-is-pseudo-class');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var selectorParser__default = /*#__PURE__*/_interopDefaultCompat(selectorParser);
+
+const createTransform = (rule, options) => {
+    const replaceFlag = options.replaceUniversalSelectorWith !== false;
+    const transform = (selectors) => {
+        selectors.walk((selector) => {
+            if (selector.type === 'universal' && replaceFlag) {
+                selector.value = options.replaceUniversalSelectorWith;
+            }
+            if (selector.type === 'selector') {
+                const node = selector.nodes.find((x) => x.type === 'pseudo' && x.value === ':hover');
+                node && selector.remove();
+            }
+            if (selector.type === 'class') {
+                selector.value = shared.internalCssSelectorReplacer(selector.value, options.escapeMap);
+            }
+        });
+        if (selectors.length === 0) {
+            rule.remove();
+        }
+    };
+    return transform;
+};
+const getTransformer = (rule, options) => {
+    return selectorParser__default["default"](createTransform(rule, options));
+};
+const transformSync = (rule, options) => {
+    const transformer = getTransformer(rule, options);
+    return transformer.transformSync(rule, {
+        lossless: false,
+        updateSelector: true
+    });
+};
+
+const PATTERNS = [/:not\(template\)\s*~\s*:not\(template\)/.source, /:not\(\[hidden\]\)\s*~\s*:not\(\[hidden\]\)/.source].join('|');
+const BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, 'g');
+function testIfVariablesScope(node, count = 1) {
+    if (/:?:before/.test(node.selector) && /:?:after/.test(node.selector)) {
+        for (let i = 0; i < count; i++) {
+            const tryTestDecl = node.nodes[i];
+            if (tryTestDecl && tryTestDecl.type === 'decl' && tryTestDecl.prop.startsWith('--tw-')) {
+                continue;
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function commonChunkPreflight(node, options) {
+    node.selector = node.selector.replace(BROAD_MATCH_GLOBAL_REGEXP, 'view + view');
+    if (testIfVariablesScope(node)) {
+        const selectorParts = node.selector.split(',');
+        if (!selectorParts.includes('view')) {
+            selectorParts.push('view');
+        }
+        if (options.cssPreflightRange === 'all') {
+            if (!selectorParts.includes(':not(not)')) {
+                selectorParts.push(':not(not)');
+            }
+        }
+        node.selector = selectorParts.join(',');
+        if (typeof options.cssInjectPreflight === 'function') {
+            node.append(...options.cssInjectPreflight());
+        }
+        const pseudoVarRule = new postcss.Rule({
+            selector: '::before,::after'
+        });
+        pseudoVarRule.append(new postcss.Declaration({
+            prop: '--tw-content',
+            value: '""'
+        }));
+        node.before(pseudoVarRule);
+    }
+}
+
+const NS = 'jsx-rename-loader';
+const postcssPlugin = 'postcss-weapp-tailwindcss-rename-plugin';
+const pluginName = 'weapp-tailwindcss-webpack-plugin';
+const vitePluginName = 'vite-plugin-uni-app-weapp-tailwindcss-adaptor';
+
+const postcssWeappTailwindcss = (options = {
+    isMainChunk: true
+}) => {
+    const { customRuleCallback, isMainChunk } = options;
+    const flag = typeof customRuleCallback === 'function';
+    return {
+        postcssPlugin,
+        Once(css) {
+            css.walkRules((rule) => {
+                transformSync(rule, options);
+                isMainChunk && commonChunkPreflight(rule, options);
+                flag && customRuleCallback(rule, options);
+            });
+        }
+    };
+};
+postcssWeappTailwindcss.postcss = true;
+
+exports.NS = NS;
+exports.pluginName = pluginName;
+exports.postcssWeappTailwindcss = postcssWeappTailwindcss;
+exports.vitePluginName = vitePluginName;

package/dist/postcss.d.ts

@@ -0,0 +1 @@
+export * from './postcss/plugin';

package/dist/postcss.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var postcss = require('./postcss-dc9eeafc.js');
+var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
+require('postcss-selector-parser');
+require('./shared-c2953d9d.js');
+require('tailwindcss-mangle-shared');
+require('postcss');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var postcssIsPseudoClass__default = /*#__PURE__*/_interopDefaultCompat(postcssIsPseudoClass);
+
+
+
+exports.postcssWeappTailwindcss = postcss.postcssWeappTailwindcss;
+Object.defineProperty(exports, 'postcssIsPseudoClass', {
+	enumerable: true,
+	get: function () { return postcssIsPseudoClass__default["default"]; }
+});

package/dist/postcss.mjs

@@ -0,0 +1,6 @@
+export { p as postcssWeappTailwindcss } from './postcss-1f9a5153.mjs';
+export { default as postcssIsPseudoClass } from '@csstools/postcss-is-pseudo-class';
+import 'postcss-selector-parser';
+import './shared-eae1dc7a.mjs';
+import 'tailwindcss-mangle-shared';
+import 'postcss';

package/dist/reg.d.ts

@@ -0,0 +1,26 @@
+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 createTempleteHandlerMatchRegexp(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 function variableMatch(original: string): RegExpExecArray | null;
+export declare const classRegexp: RegExp;
+export declare const vueTemplateClassRegexp: RegExp;
+export declare const tagRegexp: RegExp;
+export declare const tagWithClassRegexp: RegExp;
+export declare function classStringReplace(str: string, replacement: (substring: string, ...args: any[]) => string): string;
+export declare function tagStringReplace(str: string, replacement: (substring: string, ...args: any[]) => string): string;
+export declare const wxmlAllowClassCharsRegExp: RegExp;
+export declare function createWxmlAllowClassCharsRegExp(): RegExp;
+export declare const doubleQuoteRegexp: RegExp;
+export declare function doubleQuoteStringReplace(str: string, replacement: (substring: string, ...args: any[]) => string): string;
+export {};

package/dist/replace.d.ts

@@ -0,0 +1,4 @@
+import { replaceWxml as replaceJs } from './wxml/shared';
+import { internalCssSelectorReplacer as replaceCss } from './postcss/shared';
+export * from './dic';
+export { replaceJs, replaceCss };

package/dist/replace.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared-c2953d9d.js');
+require('tailwindcss-mangle-shared');
+
+function replaceWxml(original, options = {
+    keepEOL: false,
+    escapeMap: shared.SimpleMappingChars2String
+}) {
+    if (typeof options === 'boolean') {
+        options = {
+            keepEOL: options
+        };
+    }
+    let res = original;
+    if (!options.keepEOL) {
+        res = res
+            .replace(/[\r\n]+/g, '');
+    }
+    const { wxmlHandler } = shared.useStore();
+    res = wxmlHandler(res);
+    res = shared.escape(res, {
+        map: options.escapeMap
+    });
+    return res;
+}
+
+exports.MappingChars2String = shared.MappingChars2String;
+exports.MappingChars2StringEntries = shared.MappingChars2StringEntries;
+exports.SYMBOL_TABLE = shared.SYMBOL_TABLE;
+exports.SimpleMappingChars2String = shared.SimpleMappingChars2String;
+exports.SimpleMappingChars2StringEntries = shared.SimpleMappingChars2StringEntries;
+exports.replaceCss = shared.internalCssSelectorReplacer;
+exports.replaceJs = replaceWxml;

package/dist/replace.mjs

@@ -0,0 +1,27 @@
+import { h as escape, S as SimpleMappingChars2String, u as useStore } from './shared-eae1dc7a.mjs';
+export { M as MappingChars2String, k as MappingChars2StringEntries, j as SYMBOL_TABLE, l as SimpleMappingChars2StringEntries, f as replaceCss } from './shared-eae1dc7a.mjs';
+import 'tailwindcss-mangle-shared';
+
+function replaceWxml(original, options = {
+    keepEOL: false,
+    escapeMap: SimpleMappingChars2String
+}) {
+    if (typeof options === 'boolean') {
+        options = {
+            keepEOL: options
+        };
+    }
+    let res = original;
+    if (!options.keepEOL) {
+        res = res
+            .replace(/[\r\n]+/g, '');
+    }
+    const { wxmlHandler } = useStore();
+    res = wxmlHandler(res);
+    res = escape(res, {
+        map: options.escapeMap
+    });
+    return res;
+}
+
+export { SimpleMappingChars2String, replaceWxml as replaceJs };

package/dist/shared-c2953d9d.js

@@ -0,0 +1,354 @@
+'use strict';
+
+var tailwindcssMangleShared = require('tailwindcss-mangle-shared');
+
+function isRegexp(value) {
+    return Object.prototype.toString.call(value) === '[object RegExp]';
+}
+function isMap(value) {
+    return Object.prototype.toString.call(value) === '[object Map]';
+}
+const noop = () => { };
+function groupBy(arr, cb) {
+    if (!Array.isArray(arr)) {
+        throw new Error('expected an array for first argument');
+    }
+    if (typeof cb !== 'function') {
+        throw new Error('expected a function for second argument');
+    }
+    const result = {};
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        const bucketCategory = cb(item);
+        const bucket = result[bucketCategory];
+        if (!Array.isArray(bucket)) {
+            result[bucketCategory] = [item];
+        }
+        else {
+            result[bucketCategory].push(item);
+        }
+    }
+    return result;
+}
+function getGroupedEntries(entries, options) {
+    const { cssMatcher, htmlMatcher, jsMatcher } = options;
+    const groupedEntries = groupBy(entries, ([file]) => {
+        if (cssMatcher(file)) {
+            return 'css';
+        }
+        else if (htmlMatcher(file)) {
+            return 'html';
+        }
+        else if (jsMatcher(file)) {
+            return 'js';
+        }
+        else {
+            return 'other';
+        }
+    });
+    return groupedEntries;
+}
+
+const SYMBOL_TABLE = {
+    BACKQUOTE: '`',
+    TILDE: '~',
+    EXCLAM: '!',
+    AT: '@',
+    NUMBERSIGN: '#',
+    DOLLAR: '$',
+    PERCENT: '%',
+    CARET: '^',
+    AMPERSAND: '&',
+    ASTERISK: '*',
+    PARENLEFT: '(',
+    PARENRIGHT: ')',
+    MINUS: '-',
+    UNDERSCORE: '_',
+    EQUAL: '=',
+    PLUS: '+',
+    BRACKETLEFT: '[',
+    BRACELEFT: '{',
+    BRACKETRIGHT: ']',
+    BRACERIGHT: '}',
+    SEMICOLON: ';',
+    COLON: ':',
+    QUOTE: "'",
+    DOUBLEQUOTE: '"',
+    BACKSLASH: '\\',
+    BAR: '|',
+    COMMA: ',',
+    LESS: '<',
+    PERIOD: '.',
+    GREATER: '>',
+    SLASH: '/',
+    QUESTION: '?',
+    SPACE: ' ',
+    DOT: '.',
+    HASH: '#'
+};
+const MappingChars2String = {
+    '[': '_bl_',
+    ']': '_br_',
+    '(': '_pl_',
+    ')': '_qr_',
+    '#': '_h_',
+    '!': '_i_',
+    '/': '_s_',
+    '\\': '_bs_',
+    '.': '_d_',
+    ':': '_c_',
+    '%': '_p_',
+    ',': '_co_',
+    "'": '_q_',
+    '"': '_dq_',
+    '*': '_a_',
+    '&': '_am_',
+    '@': '_at_',
+    '{': '_bal_',
+    '}': '_bar_',
+    '+': '_plus_',
+    ';': '_se_',
+    '<': '_l_',
+    '~': '_t_',
+    '=': '_e_',
+    '>': '_g_',
+    '?': '_qu_',
+    '^': '_ca_',
+    '`': '_bq_',
+    '|': '_b_',
+    $: '_do_'
+};
+const MappingChars2StringEntries = Object.entries(MappingChars2String);
+const SimpleMappingChars2String = {
+    '[': '_',
+    ']': '_',
+    '(': '_',
+    ')': '_',
+    '{': '_',
+    '}': '_',
+    '+': 'a',
+    ',': 'b',
+    ':': 'c',
+    '.': 'd',
+    '=': 'e',
+    ';': 'f',
+    '>': 'g',
+    '#': 'h',
+    '!': 'i',
+    '@': 'j',
+    '^': 'k',
+    '<': 'l',
+    '*': 'm',
+    '&': 'n',
+    '?': 'o',
+    '%': 'p',
+    "'": 'q',
+    $: 'r',
+    '/': 's',
+    '~': 't',
+    '|': 'u',
+    '`': 'v',
+    '\\': 'w',
+    '"': 'x'
+};
+const SimpleMappingChars2StringEntries = Object.entries(SimpleMappingChars2String);
+
+function escape(selectors, options = {
+    map: SimpleMappingChars2String
+}) {
+    const { map = SimpleMappingChars2String } = options;
+    const sb = selectors.split('');
+    for (let i = 0; i < sb.length; i++) {
+        const char = sb[i];
+        const code = char.charCodeAt(0);
+        if (code > 127) {
+            sb[i] = 'u' + Number(code).toString(16);
+        }
+        else {
+            const hit = map[char];
+            if (hit) {
+                sb[i] = hit;
+            }
+        }
+    }
+    const res = sb.join('');
+    return res;
+}
+
+const validateFilterRE = /[\w\u00A0-\uFFFF-_:%-?]/;
+function isValidSelector(selector = '') {
+    return validateFilterRE.test(selector);
+}
+const splitCode = (code) => {
+    return code.split(/[\s]+/).filter(isValidSelector);
+};
+
+function escapeStringRegexp(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    return str.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\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 (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 (isRegexp(cur)) {
+                acc.push(handleRegexp(cur));
+            }
+            return acc;
+        }, [])
+            .join('|');
+    }
+    else if (typeof arr === 'string') {
+        pattern = arr;
+    }
+    else if (isRegexp(arr)) {
+        pattern = handleRegexp(arr);
+    }
+    return pattern;
+}
+function createTempleteHandlerMatchRegexp(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: createTempleteHandlerMatchRegexp(k, v),
+                attrRegexp: createTemplateClassRegexp(v),
+                tag: getSourceString(k),
+                attrs: v
+            };
+        });
+    }
+}
+const variableRegExp = /{{(.*?)}}/gs;
+function variableMatch(original) {
+    return variableRegExp.exec(original);
+}
+
+function getSelf(x) {
+    return x;
+}
+const defaultScopedStore = {
+    rawOptions: false,
+    runtimeSet: new Set(),
+    classGenerator: new tailwindcssMangleShared.ClassGenerator(),
+    filter: tailwindcssMangleShared.defaultMangleClassFilter,
+    cssHandler: getSelf,
+    jsHandler: getSelf,
+    wxmlHandler: getSelf
+};
+const store = Object.assign({}, defaultScopedStore);
+function useStore() {
+    return store;
+}
+function handleValue(rawSource) {
+    const arr = splitCode(rawSource);
+    for (let i = 0; i < arr.length; i++) {
+        const x = arr[i];
+        if (store.runtimeSet.has(x)) {
+            rawSource = rawSource.replace(new RegExp(escapeStringRegexp(x), 'g'), store.classGenerator.generateClassName(x).name);
+        }
+    }
+    return rawSource;
+}
+function initStore(options) {
+    var _a;
+    store.rawOptions = options;
+    if (options) {
+        if (options === true) {
+            options = {
+                classGenerator: {},
+                mangleClassFilter: tailwindcssMangleShared.defaultMangleClassFilter
+            };
+        }
+        store.classGenerator = new tailwindcssMangleShared.ClassGenerator(options.classGenerator);
+        store.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : tailwindcssMangleShared.defaultMangleClassFilter;
+        store.jsHandler = (rawSource) => {
+            return handleValue(rawSource);
+        };
+        store.cssHandler = (rawSource) => {
+            return handleValue(rawSource);
+        };
+        store.wxmlHandler = (rawSource) => {
+            return handleValue(rawSource);
+        };
+    }
+}
+function setRuntimeSet(runtimeSet) {
+    const newSet = new Set();
+    runtimeSet.forEach((c) => {
+        if (store.filter(c)) {
+            newSet.add(c);
+        }
+    });
+    store.runtimeSet = newSet;
+}
+
+function internalCssSelectorReplacer(selectors, map = SimpleMappingChars2String) {
+    const { cssHandler } = useStore();
+    selectors = cssHandler(selectors);
+    return escape(selectors, {
+        map
+    });
+}
+
+exports.MappingChars2String = MappingChars2String;
+exports.MappingChars2StringEntries = MappingChars2StringEntries;
+exports.SYMBOL_TABLE = SYMBOL_TABLE;
+exports.SimpleMappingChars2String = SimpleMappingChars2String;
+exports.SimpleMappingChars2StringEntries = SimpleMappingChars2StringEntries;
+exports.escape = escape;
+exports.escapeStringRegexp = escapeStringRegexp;
+exports.getGroupedEntries = getGroupedEntries;
+exports.initStore = initStore;
+exports.internalCssSelectorReplacer = internalCssSelectorReplacer;
+exports.isMap = isMap;
+exports.makeCustomAttributes = makeCustomAttributes;
+exports.noop = noop;
+exports.setRuntimeSet = setRuntimeSet;
+exports.splitCode = splitCode;
+exports.tagWithEitherClassAndHoverClassRegexp = tagWithEitherClassAndHoverClassRegexp;
+exports.templateClassExactRegexp = templateClassExactRegexp;
+exports.useStore = useStore;
+exports.variableMatch = variableMatch;
+exports.variableRegExp = variableRegExp;