weapp-tailwindcss 2.3.3

package/dist/shared-eae1dc7a.mjs

@@ -0,0 +1,333 @@
+import { ClassGenerator, defaultMangleClassFilter } from '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 ClassGenerator(),
+    filter: 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: defaultMangleClassFilter
+            };
+        }
+        store.classGenerator = new ClassGenerator(options.classGenerator);
+        store.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : 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
+    });
+}
+
+export { MappingChars2String as M, SimpleMappingChars2String as S, templateClassExactRegexp as a, variableRegExp as b, initStore as c, setRuntimeSet as d, escapeStringRegexp as e, internalCssSelectorReplacer as f, getGroupedEntries as g, escape as h, isMap as i, SYMBOL_TABLE as j, MappingChars2StringEntries as k, SimpleMappingChars2StringEntries as l, makeCustomAttributes as m, noop as n, splitCode as s, tagWithEitherClassAndHoverClassRegexp as t, useStore as u, variableMatch as v };

package/dist/tailwindcss/patcher.d.ts

@@ -0,0 +1,8 @@
+import type { ILengthUnitsPatchOptions, InternalPatchResult } from "../types";
+import { TailwindcssPatcher } from 'tailwindcss-patch';
+export declare function getInstalledPkgJsonPath(options: ILengthUnitsPatchOptions): string | undefined;
+export declare function createPatch(options: false | ILengthUnitsPatchOptions): () => void;
+export declare function monkeyPatchForSupportingCustomUnit(rootDir: string, options: ILengthUnitsPatchOptions): string | undefined;
+export declare function internalPatch(pkgJsonPath: string | undefined, options: ILengthUnitsPatchOptions, overwrite?: boolean): InternalPatchResult | undefined;
+export declare function mkCacheDirectory(cwd?: string): string;
+export declare function createTailwindcssPatcher(): TailwindcssPatcher;

package/dist/tailwindcss/supportCustomUnit.d.ts

@@ -0,0 +1,6 @@
+import * as t from '@babel/types';
+import type { ILengthUnitsPatchOptions } from "../types";
+export declare function findAstNode(content: string, options: ILengthUnitsPatchOptions): {
+    arrayRef: t.ArrayExpression | undefined;
+    changed: boolean;
+};

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+import type { InjectPreflight } from './postcss/preflight';
+import type { Rule } from 'postcss';
+import type { IClassGeneratorOptions } from 'tailwindcss-mangle-shared';
+import type { GeneratorResult } from '@babel/generator';
+export type ItemOrItemArray<T> = T | T[];
+export type { TraverseOptions } from '@babel/traverse';
+export type { Node } from '@babel/types';
+export type AppType = 'uni-app' | 'uni-app-vite' | 'taro' | 'remax' | 'rax' | 'native' | 'kbone' | 'mpx';
+export interface IPropValue {
+    prop: string;
+    value: string;
+}
+export type CssPresetProps = string;
+export type CssPreflightOptions = {
+    [key: CssPresetProps]: string | number | boolean;
+} | false;
+type RequiredStyleHandlerOptions = {
+    isMainChunk: boolean;
+    cssInjectPreflight?: InjectPreflight;
+    cssPreflightRange?: 'view' | 'all';
+    replaceUniversalSelectorWith?: string | false;
+    escapeMap?: Record<string, string>;
+};
+export type CustomRuleCallback = (node: Rule, options: Readonly<RequiredStyleHandlerOptions>) => void;
+export type IStyleHandlerOptions = {
+    customRuleCallback?: CustomRuleCallback;
+} & RequiredStyleHandlerOptions;
+export type ICustomAttributes = Record<string, ItemOrItemArray<string | RegExp>> | Map<string | RegExp, ItemOrItemArray<string | RegExp>>;
+export type ICustomAttributesEntities = [string | RegExp, ItemOrItemArray<string | RegExp>][];
+export type IJsHandlerOptions = {
+    escapeMap?: Record<string, string>;
+    classNameSet: Set<string>;
+    minifiedJs?: boolean;
+};
+export interface RawSource {
+    start: number;
+    end: number;
+    raw: string;
+    source?: string;
+    prevConcatenated: boolean;
+    nextConcatenated: boolean;
+}
+export interface ILengthUnitsPatchDangerousOptions {
+    packageName?: string;
+    gteVersion?: string;
+    lengthUnitsFilePath?: string;
+    variableName?: string;
+    overwrite?: boolean;
+    destPath?: string;
+}
+export interface ILengthUnitsPatchOptions {
+    units: string[];
+    paths?: string[];
+    dangerousOptions?: ILengthUnitsPatchDangerousOptions;
+    basedir?: string;
+}
+export interface IMangleOptions {
+    classGenerator?: IClassGeneratorOptions;
+    mangleClassFilter?: (className: string) => boolean;
+}
+export interface UserDefinedOptions {
+    htmlMatcher?: ((name: string) => boolean) | string | string[];
+    cssMatcher?: ((name: string) => boolean) | string | string[];
+    jsMatcher?: ((name: string) => boolean) | string | string[];
+    mainCssChunkMatcher?: ((name: string, appType?: AppType) => boolean) | string | string[];
+    cssPreflight?: CssPreflightOptions;
+    cssPreflightRange?: 'view' | 'all';
+    replaceUniversalSelectorWith?: string | false;
+    disabled?: boolean;
+    customRuleCallback?: CustomRuleCallback;
+    onLoad?: () => void;
+    onStart?: () => void;
+    onUpdate?: (filename: string, oldVal: string, newVal: string) => void;
+    onEnd?: () => void;
+    customAttributes?: ICustomAttributes;
+    customReplaceDictionary?: 'simple' | 'complex' | Record<string, string>;
+    supportCustomLengthUnitsPatch?: ILengthUnitsPatchOptions | boolean;
+    appType?: AppType;
+    minifiedJs?: boolean;
+    mangle?: boolean | IMangleOptions;
+}
+export interface ICommonReplaceOptions {
+    keepEOL?: boolean;
+    escapeMap?: Record<string, string>;
+}
+export type ICustomRegexp = {
+    tagRegexp: RegExp;
+    attrRegexp: RegExp;
+    tag: string;
+    attrs: ItemOrItemArray<string | RegExp>;
+};
+export interface ITempleteHandlerOptions extends ICommonReplaceOptions {
+    customAttributesEntities?: ICustomAttributesEntities;
+    escapeMap?: Record<string, string>;
+}
+export type GlobOrFunctionMatchers = 'htmlMatcher' | 'cssMatcher' | 'jsMatcher' | 'mainCssChunkMatcher';
+export type InternalUserDefinedOptions = Required<Omit<UserDefinedOptions, GlobOrFunctionMatchers | 'supportCustomLengthUnitsPatch' | 'customReplaceDictionary'> & {
+    [K in GlobOrFunctionMatchers]: K extends 'mainCssChunkMatcher' ? (name: string, appType?: AppType) => boolean : (name: string) => boolean;
+} & {
+    supportCustomLengthUnitsPatch: ILengthUnitsPatchOptions | false;
+    templeteHandler: (rawSource: string, options?: ITempleteHandlerOptions) => string;
+    styleHandler: (rawSource: string, options: IStyleHandlerOptions) => string;
+    jsHandler: (rawSource: string, set: Set<string>) => GeneratorResult;
+    escapeMap: Record<string, string>;
+    patch: () => void;
+    customReplaceDictionary: Record<string, string>;
+}>;
+export type InternalPostcssOptions = Pick<UserDefinedOptions, 'cssMatcher' | 'mainCssChunkMatcher' | 'cssPreflight' | 'replaceUniversalSelectorWith' | 'cssPreflightRange' | 'customRuleCallback' | 'disabled'>;
+export interface IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    apply: (compiler: any) => void;
+}
+export interface InternalPatchResult {
+    dataTypes?: string;
+    processTailwindFeatures?: string;
+    plugin?: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import type { InternalUserDefinedOptions } from "./types";
+import defu from 'defu';
+export declare function isRegexp(value: unknown): boolean;
+export declare function isMap(value: unknown): boolean;
+export declare function regExpTest(arr: (string | RegExp)[] | undefined, str: string): boolean;
+export declare const noop: () => void;
+export declare function isAscii(str: string): boolean;
+export { defu };
+export declare function getGroupedEntries<T>(entries: [string, T][], options: InternalUserDefinedOptions): Record<"css" | "html" | "js" | "other", [string, T][]>;

package/dist/vite/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import { UserDefinedOptions } from "../types";
+export declare function UnifiedViteWeappTailwindcssPlugin(options?: UserDefinedOptions): Plugin | undefined;

package/dist/vite.d.ts

@@ -0,0 +1 @@
+export * from './vite/index';

package/dist/vite.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var options = require('./options-3a695e84.js');
+var postcss = require('./postcss-dc9eeafc.js');
+var shared = require('./shared-c2953d9d.js');
+require('micromatch');
+require('@babel/generator');
+require('@babel/parser');
+require('@babel/traverse');
+require('./replace.js');
+require('tailwindcss-mangle-shared');
+require('@babel/types');
+require('postcss');
+require('@csstools/postcss-is-pseudo-class');
+require('path');
+require('fs');
+require('semver');
+require('tailwindcss-patch');
+require('postcss-selector-parser');
+
+function UnifiedViteWeappTailwindcssPlugin(options$1 = {}) {
+    if (typeof options$1.customReplaceDictionary === 'undefined') {
+        options$1.customReplaceDictionary = 'simple';
+    }
+    const opts = options.getOptions(options$1, ['patch', 'style', 'templete', 'js']);
+    const { disabled, onEnd, onLoad, onStart, onUpdate, templeteHandler, styleHandler, patch, jsHandler, mainCssChunkMatcher, appType, mangle } = opts;
+    if (disabled) {
+        return;
+    }
+    patch === null || patch === void 0 ? void 0 : patch();
+    shared.initStore(mangle);
+    const twPatcher = options.createTailwindcssPatcher();
+    onLoad();
+    return {
+        name: postcss.vitePluginName,
+        enforce: 'post',
+        buildStart() {
+            onStart();
+        },
+        generateBundle(opt, bundle, isWrite) {
+            const entries = Object.entries(bundle);
+            const groupedEntries = shared.getGroupedEntries(entries, opts);
+            const set = twPatcher.getClassSet();
+            shared.setRuntimeSet(set);
+            if (Array.isArray(groupedEntries.html)) {
+                for (let i = 0; i < groupedEntries.html.length; i++) {
+                    const [file, originalSource] = groupedEntries.html[i];
+                    const oldVal = originalSource.source.toString();
+                    originalSource.source = templeteHandler(oldVal);
+                    onUpdate(file, oldVal, originalSource.source);
+                }
+            }
+            if (Array.isArray(groupedEntries.css)) {
+                for (let i = 0; i < groupedEntries.css.length; i++) {
+                    const [file, originalSource] = groupedEntries.css[i];
+                    const rawSource = originalSource.source.toString();
+                    const css = styleHandler(rawSource, {
+                        isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType)
+                    });
+                    originalSource.source = css;
+                    onUpdate(file, rawSource, css);
+                }
+            }
+            if (Array.isArray(groupedEntries.js)) {
+                for (let i = 0; i < groupedEntries.js.length; i++) {
+                    const [file, originalSource] = groupedEntries.js[i];
+                    const rawSource = originalSource.code;
+                    const { code } = jsHandler(rawSource, set);
+                    originalSource.code = code;
+                    onUpdate(file, rawSource, code);
+                }
+            }
+        },
+        buildEnd() {
+            onEnd();
+        }
+    };
+}
+
+exports.UnifiedViteWeappTailwindcssPlugin = UnifiedViteWeappTailwindcssPlugin;

package/dist/vite.mjs

@@ -0,0 +1,78 @@
+import { g as getOptions, a as createTailwindcssPatcher } from './options-ed6f4a3a.mjs';
+import { v as vitePluginName } from './postcss-1f9a5153.mjs';
+import { c as initStore, g as getGroupedEntries, d as setRuntimeSet } from './shared-eae1dc7a.mjs';
+import 'micromatch';
+import '@babel/generator';
+import '@babel/parser';
+import '@babel/traverse';
+import './replace.mjs';
+import 'tailwindcss-mangle-shared';
+import '@babel/types';
+import 'postcss';
+import '@csstools/postcss-is-pseudo-class';
+import 'path';
+import 'fs';
+import 'semver';
+import 'tailwindcss-patch';
+import 'postcss-selector-parser';
+
+function UnifiedViteWeappTailwindcssPlugin(options = {}) {
+    if (typeof options.customReplaceDictionary === 'undefined') {
+        options.customReplaceDictionary = 'simple';
+    }
+    const opts = getOptions(options, ['patch', 'style', 'templete', 'js']);
+    const { disabled, onEnd, onLoad, onStart, onUpdate, templeteHandler, styleHandler, patch, jsHandler, mainCssChunkMatcher, appType, mangle } = opts;
+    if (disabled) {
+        return;
+    }
+    patch === null || patch === void 0 ? void 0 : patch();
+    initStore(mangle);
+    const twPatcher = createTailwindcssPatcher();
+    onLoad();
+    return {
+        name: vitePluginName,
+        enforce: 'post',
+        buildStart() {
+            onStart();
+        },
+        generateBundle(opt, bundle, isWrite) {
+            const entries = Object.entries(bundle);
+            const groupedEntries = getGroupedEntries(entries, opts);
+            const set = twPatcher.getClassSet();
+            setRuntimeSet(set);
+            if (Array.isArray(groupedEntries.html)) {
+                for (let i = 0; i < groupedEntries.html.length; i++) {
+                    const [file, originalSource] = groupedEntries.html[i];
+                    const oldVal = originalSource.source.toString();
+                    originalSource.source = templeteHandler(oldVal);
+                    onUpdate(file, oldVal, originalSource.source);
+                }
+            }
+            if (Array.isArray(groupedEntries.css)) {
+                for (let i = 0; i < groupedEntries.css.length; i++) {
+                    const [file, originalSource] = groupedEntries.css[i];
+                    const rawSource = originalSource.source.toString();
+                    const css = styleHandler(rawSource, {
+                        isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType)
+                    });
+                    originalSource.source = css;
+                    onUpdate(file, rawSource, css);
+                }
+            }
+            if (Array.isArray(groupedEntries.js)) {
+                for (let i = 0; i < groupedEntries.js.length; i++) {
+                    const [file, originalSource] = groupedEntries.js[i];
+                    const rawSource = originalSource.code;
+                    const { code } = jsHandler(rawSource, set);
+                    originalSource.code = code;
+                    onUpdate(file, rawSource, code);
+                }
+            }
+        },
+        buildEnd() {
+            onEnd();
+        }
+    };
+}
+
+export { UnifiedViteWeappTailwindcssPlugin };

package/dist/webpack/BaseUnifiedPlugin/v5.d.ts

@@ -0,0 +1,9 @@
+import type { AppType, UserDefinedOptions, InternalUserDefinedOptions, IBaseWebpackPlugin } from "../../types";
+import type { Compiler } from 'webpack';
+export declare class UnifiedWebpackPluginV5 implements IBaseWebpackPlugin {
+    options: InternalUserDefinedOptions;
+    appType?: AppType;
+    static NS: string;
+    constructor(options?: UserDefinedOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/webpack/index.d.ts

@@ -0,0 +1 @@
+export * from './BaseUnifiedPlugin/v5';

package/dist/webpack.d.ts

@@ -0,0 +1 @@
+export * from './webpack/index';