weapp-tailwindcss 4.12.0 → 5.0.0-next.1

package/dist/index.mjs

@@ -1,24 +1,6 @@
-import {
-  UnifiedWebpackPluginV5,
-  weappTailwindcssPackageDir
-} from "./chunk-57SOQCAU.mjs";
-import "./chunk-RRQZL7FQ.mjs";
-import {
-  createPlugins
-} from "./chunk-XZP3MREK.mjs";
-import {
-  UnifiedViteWeappTailwindcssPlugin
-} from "./chunk-5ZYHNDEK.mjs";
-import "./chunk-3VQKDHGP.mjs";
-import "./chunk-76S2EME4.mjs";
-import "./chunk-KGTVD4EP.mjs";
-import "./chunk-PCDYXXSK.mjs";
-import "./chunk-XAKAD2CR.mjs";
-import "./chunk-OOHJLO5M.mjs";
-import "./chunk-NNOQDMUP.mjs";
-export {
-  UnifiedViteWeappTailwindcssPlugin,
-  UnifiedWebpackPluginV5,
-  createPlugins,
-  weappTailwindcssPackageDir
-};
+import { t as createWeappTailwindcssGenerator } from "./generator-Dwxgra97.mjs";
+import { WeappTailwindcss as createPlugins } from "./gulp.mjs";
+import weappTailwindcssPostcssPlugin from "./postcss.mjs";
+import { t as UnifiedViteWeappTailwindcssPlugin } from "./vite-C8JlHiyR.mjs";
+import { n as weappTailwindcssPackageDir, t as UnifiedWebpackPluginV5 } from "./webpack-CABjKGGQ.mjs";
+export { UnifiedViteWeappTailwindcssPlugin, UnifiedWebpackPluginV5, createPlugins, createWeappTailwindcssGenerator, weappTailwindcssPackageDir, weappTailwindcssPostcssPlugin };

package/dist/js/JsTokenUpdater.d.ts

@@ -0,0 +1,14 @@
+import type MagicString from 'magic-string';
+import type { JsToken } from './types';
+export declare class JsTokenUpdater {
+    private tokens;
+    constructor({ value }?: {
+        value?: JsToken[];
+    });
+    addToken(token?: JsToken): void;
+    push(...args: JsToken[]): this;
+    get length(): number;
+    map(callbackfn: (value: JsToken, index: number, array: JsToken[]) => JsToken): this;
+    filter(callbackfn: (value: JsToken, index: number, array: JsToken[]) => unknown): this;
+    updateMagicString(ms: MagicString): MagicString;
+}

package/dist/js/ModuleGraph.d.ts

@@ -0,0 +1,18 @@
+import type { JsModuleGraphOptions, LinkedJsModuleResult } from '../types';
+import type { ModuleGraphEntry } from './module-graph/types';
+export type { ModuleGraphEntry } from './module-graph/types';
+export declare class JsModuleGraph {
+    private readonly modules;
+    private readonly queue;
+    private readonly resolve;
+    private readonly load;
+    private readonly filter?;
+    private readonly maxDepth;
+    private readonly baseOptions;
+    private readonly parserOptions?;
+    private readonly rootFilename;
+    private readonly ignoredExports;
+    constructor(entry: ModuleGraphEntry, graphOptions: JsModuleGraphOptions);
+    build(): Record<string, LinkedJsModuleResult> | undefined;
+    private collectDependencies;
+}

package/dist/js/NodePathWalker.d.ts

@@ -0,0 +1,33 @@
+import type { NodePath } from '@babel/traverse';
+import type { ArrayExpression, BinaryExpression, CallExpression, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, LogicalExpression, Node, ObjectExpression, StringLiteral, TemplateElement, TemplateLiteral, VariableDeclarator } from '@babel/types';
+import type { ImportToken } from './node-path-walker/import-tokens';
+export type { ImportToken } from './node-path-walker/import-tokens';
+export declare class NodePathWalker {
+    ignoreCallExpressionIdentifiers: (string | RegExp)[];
+    callback: (path: NodePath<StringLiteral | TemplateElement>) => void;
+    private isIgnoredCallIdentifier;
+    private hasIgnoredCallIdentifiers;
+    private importsStore;
+    private visitedStore;
+    constructor({ ignoreCallExpressionIdentifiers, callback }?: {
+        ignoreCallExpressionIdentifiers?: (string | RegExp)[];
+        callback?: (path: NodePath<StringLiteral | TemplateElement>) => void;
+    });
+    get imports(): Set<ImportToken>;
+    private getWritableImports;
+    private addImportToken;
+    private getVisited;
+    walkVariableDeclarator(path: NodePath<VariableDeclarator>): void;
+    walkTemplateLiteral(path: NodePath<TemplateLiteral>): void;
+    walkStringLiteral(path: NodePath<StringLiteral>): void;
+    walkBinaryExpression(path: NodePath<BinaryExpression>): void;
+    walkLogicalExpression(path: NodePath<LogicalExpression>): void;
+    walkObjectExpression(path: NodePath<ObjectExpression>): void;
+    walkArrayExpression(path: NodePath<ArrayExpression>): void;
+    walkNode(arg: NodePath<Node | null | undefined>): void;
+    walkCallExpression(path: NodePath<CallExpression>): void;
+    walkExportDeclaration(path: NodePath<ExportDeclaration>): void;
+    walkExportNamedDeclaration(path: NodePath<ExportNamedDeclaration>): void;
+    walkExportDefaultDeclaration(path: NodePath<ExportDefaultDeclaration>): void;
+    walkExportAllDeclaration(path: NodePath<ExportAllDeclaration>): void;
+}

package/dist/js/babel/parse.d.ts

@@ -0,0 +1,9 @@
+import type { ParseResult, ParserOptions } from '@babel/parser';
+import type { File } from '@babel/types';
+import { LRUCache } from 'lru-cache';
+export declare const parseCache: LRUCache<string, ParseResult<File>>;
+export declare function genCacheKey(source: string, options: any): string;
+export declare function babelParse(code: string, opts?: (ParserOptions & {
+    cache?: boolean;
+    cacheKey?: string;
+})): ParseResult<File>;

package/dist/js/babel/process.d.ts

@@ -0,0 +1,4 @@
+import type { IJsHandlerOptions } from '../../types';
+import type { SourceAnalysis } from '../sourceAnalysis';
+import MagicString from 'magic-string';
+export declare function processUpdatedSource(rawSource: string, options: IJsHandlerOptions, analysis: SourceAnalysis): MagicString;

package/dist/js/babel.d.ts

@@ -0,0 +1,13 @@
+import type { ParseResult } from '@babel/parser';
+import type { File } from '@babel/types';
+import type { IJsHandlerOptions, JsHandlerResult } from '../types';
+import type { EvalHandler } from './evalTransforms';
+import type { SourceAnalysis } from './sourceAnalysis';
+import { babelParse } from './babel/parse';
+import { processUpdatedSource } from './babel/process';
+export declare function analyzeSource(ast: ParseResult<File>, options: IJsHandlerOptions, handler?: EvalHandler, collectModuleMetadata?: boolean): SourceAnalysis;
+export declare function jsHandler(rawSource: string, options: IJsHandlerOptions): JsHandlerResult;
+export { babelParse, processUpdatedSource };
+export { genCacheKey, parseCache } from './babel/parse';
+export { isEvalPath } from './evalTransforms';
+export type { SourceAnalysis } from './sourceAnalysis';

package/dist/js/class-context.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/traverse';
+import type { StringLiteral, TemplateElement } from '@babel/types';
+export declare function isClassContextLiteralPath(path: NodePath<StringLiteral | TemplateElement>): boolean;

package/dist/js/evalTransforms.d.ts

@@ -0,0 +1,7 @@
+import type { NodePath } from '@babel/traverse';
+import type { CallExpression, Node } from '@babel/types';
+import type { IJsHandlerOptions, JsHandlerResult } from '../types';
+import type { JsTokenUpdater } from './JsTokenUpdater';
+export type EvalHandler = (source: string, opts: IJsHandlerOptions) => JsHandlerResult;
+export declare function isEvalPath(path: NodePath<Node>): boolean;
+export declare function walkEvalExpression(path: NodePath<CallExpression>, options: IJsHandlerOptions, updater: JsTokenUpdater, handler: EvalHandler): void;

package/dist/js/handlers.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from '@babel/traverse';
+import type { StringLiteral, TemplateElement } from '@babel/types';
+import type { IJsHandlerOptions } from '../types';
+import type { JsToken } from './types';
+export declare function replaceHandleValue(path: NodePath<StringLiteral | TemplateElement>, options: IJsHandlerOptions): JsToken | undefined;

package/dist/js/index.d.ts

@@ -0,0 +1,4 @@
+import type { CreateJsHandlerOptions, JsHandler } from '../types';
+import { jsHandler } from './babel';
+export { jsHandler, };
+export declare function createJsHandler(options: CreateJsHandlerOptions): JsHandler;

package/dist/js/module-graph/ignored-exports.d.ts

@@ -0,0 +1,18 @@
+import type { JsModuleGraphOptions } from '../../types';
+import type { SourceAnalysis } from '../babel';
+import type { ImportToken } from '../NodePathWalker';
+import type { ModuleState } from './types';
+interface IgnoredExportsTrackerOptions {
+    resolve: JsModuleGraphOptions['resolve'];
+    filter?: JsModuleGraphOptions['filter'];
+    modules: Map<string, ModuleState>;
+}
+export declare class IgnoredExportsTracker {
+    private readonly options;
+    private readonly ignoredExportNames;
+    constructor(options: IgnoredExportsTrackerOptions);
+    addIgnoredExport(filename: string, exportName: string): void;
+    registerIgnoredExportsFromTokens(resolved: string, tokens: ImportToken[]): void;
+    applyIgnoredExportsToAnalysis(filename: string, analysis: SourceAnalysis): void;
+}
+export {};

package/dist/js/module-graph/types.d.ts

@@ -0,0 +1,17 @@
+import type { IJsHandlerOptions } from '../../types';
+import type { SourceAnalysis } from '../babel';
+export interface ModuleState {
+    filename: string;
+    source: string;
+    analysis: SourceAnalysis;
+}
+export interface QueueItem {
+    filename: string;
+    depth: number;
+}
+export interface ModuleGraphEntry {
+    filename: string;
+    source: string;
+    analysis: SourceAnalysis;
+    handlerOptions: IJsHandlerOptions;
+}

package/dist/js/node-path-walker/export-handlers.d.ts

@@ -0,0 +1,12 @@
+import type { NodePath } from '@babel/traverse';
+import type { ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, Node } from '@babel/types';
+import type { ImportToken } from './import-tokens';
+interface ExportWalkContext {
+    addImportToken: (token: ImportToken) => void;
+    walkNode: (path: NodePath<Node | null | undefined>) => void;
+}
+export declare function walkExportDeclaration(ctx: ExportWalkContext, path: NodePath<ExportDeclaration>): void;
+export declare function walkExportNamedDeclaration(ctx: ExportWalkContext, path: NodePath<ExportNamedDeclaration>): void;
+export declare function walkExportDefaultDeclaration(ctx: ExportWalkContext, path: NodePath<ExportDefaultDeclaration>): void;
+export declare function walkExportAllDeclaration(ctx: ExportWalkContext, path: NodePath<ExportAllDeclaration>): void;
+export {};

package/dist/js/node-path-walker/import-tokens.d.ts

@@ -0,0 +1,24 @@
+import type { NodePath } from '@babel/traverse';
+import type { ExportAllDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportSpecifier, Node } from '@babel/types';
+export interface ImportSpecifierImportToken {
+    declaration: NodePath<ImportDeclaration>;
+    specifier: NodePath<ImportSpecifier>;
+    local: string;
+    imported: string;
+    source: string;
+    type: 'ImportSpecifier';
+}
+export interface ImportDefaultSpecifierImportToken {
+    declaration: NodePath<ImportDeclaration>;
+    specifier: NodePath<ImportDefaultSpecifier>;
+    local: string;
+    source: string;
+    type: 'ImportDefaultSpecifier';
+}
+export interface ExportAllDeclarationImportToken {
+    declaration: NodePath<ExportAllDeclaration>;
+    source: string;
+    type: 'ExportAllDeclaration';
+}
+export type ImportToken = ImportSpecifierImportToken | ImportDefaultSpecifierImportToken | ExportAllDeclarationImportToken;
+export declare function maybeAddImportToken(imports: Set<ImportToken>, arg: NodePath<Node | null | undefined>): boolean;

package/dist/js/precheck.d.ts

@@ -0,0 +1,2 @@
+import type { CreateJsHandlerOptions } from '../types';
+export declare function shouldSkipJsTransform(rawSource: string, options?: CreateJsHandlerOptions): boolean;

package/dist/js/sourceAnalysis.d.ts

@@ -0,0 +1,17 @@
+import type { ParseResult } from '@babel/parser';
+import type { NodePath } from '@babel/traverse';
+import type { ExportDeclaration, File, ImportDeclaration, StringLiteral, TemplateElement } from '@babel/types';
+import type { JsTokenUpdater } from './JsTokenUpdater';
+import type { NodePathWalker } from './NodePathWalker';
+import type { JsToken } from './types';
+export interface SourceAnalysis {
+    ast: ParseResult<File>;
+    walker: NodePathWalker;
+    jsTokenUpdater: JsTokenUpdater;
+    targetPaths: NodePath<StringLiteral | TemplateElement>[];
+    importDeclarations: Set<NodePath<ImportDeclaration>>;
+    exportDeclarations: Set<NodePath<ExportDeclaration>>;
+    requireCallPaths: NodePath<StringLiteral>[];
+    ignoredPaths: WeakSet<NodePath<StringLiteral | TemplateElement>>;
+}
+export declare function collectModuleSpecifierReplacementTokens(analysis: SourceAnalysis, replacements: Record<string, string>): JsToken[];

package/dist/js/syntax.d.ts

@@ -0,0 +1,10 @@
+export interface DetectSyntaxOptions {
+    stripComments?: boolean;
+}
+export declare function hasESMSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+export declare function hasCJSSyntax(code: string, opts?: DetectSyntaxOptions): boolean;
+export declare function detectSyntax(code: string, opts?: DetectSyntaxOptions): {
+    hasESM: boolean;
+    hasCJS: boolean;
+    isMixed: boolean;
+};

package/dist/js/taggedTemplateIgnore.d.ts

@@ -0,0 +1,13 @@
+import type { NodePath } from '@babel/traverse';
+import type { Node } from '@babel/types';
+import type { NameMatcher } from '../utils/nameMatcher';
+interface TaggedTemplateIgnoreOptions {
+    matcher: NameMatcher;
+    names?: (string | RegExp)[];
+}
+interface TaggedTemplateIgnore {
+    shouldIgnore: (tagPath: NodePath<Node>) => boolean;
+    getEffectiveTagPath: (tagPath: NodePath<Node>) => NodePath<Node>;
+}
+export declare function createTaggedTemplateIgnore({ matcher, names }: TaggedTemplateIgnoreOptions): TaggedTemplateIgnore;
+export {};

package/dist/js/types.d.ts

@@ -0,0 +1,11 @@
+import type { NodePath } from '@babel/traverse';
+import type { StringLiteral, TemplateElement } from '@babel/types';
+export interface JsTokenMeta {
+    ignore?: boolean;
+}
+export interface JsToken {
+    start: number;
+    end: number;
+    value: string;
+    path: NodePath<StringLiteral | TemplateElement>;
+}

package/dist/lightningcss/index.d.ts

@@ -0,0 +1,8 @@
+import { Buffer } from 'node:buffer';
+import { createLightningcssStyleHandler } from './style-handler';
+export { createLightningcssStyleHandler };
+export declare function transformCss(css?: string | Buffer): Promise<{
+    code: Buffer<ArrayBuffer>;
+    map: Buffer<ArrayBuffer> | undefined;
+    warnings: import("lightningcss").Warning[];
+}>;

package/dist/lightningcss/style-handler/options.d.ts

@@ -0,0 +1,3 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss';
+export declare function createRootSpecificityReplacer(options: IStyleHandlerOptions): ((code: string) => string) | undefined;
+export declare function prepareStyleOptions(options?: Partial<IStyleHandlerOptions>): IStyleHandlerOptions;

package/dist/lightningcss/style-handler/selector-transform.d.ts

@@ -0,0 +1,10 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss';
+import type { SelectorComponent } from 'lightningcss';
+type CustomAtRules = Record<string, never>;
+export interface SelectorTransformContext {
+    options: IStyleHandlerOptions;
+    childCombinatorReplacement?: SelectorComponent[];
+}
+export declare function buildChildCombinatorReplacement(options: IStyleHandlerOptions): SelectorComponent[] | undefined;
+export declare function createVisitor(ctx: SelectorTransformContext): import("lightningcss").Visitor<CustomAtRules>;
+export {};

package/dist/lightningcss/style-handler/selector-utils.d.ts

@@ -0,0 +1,10 @@
+import type { Selector, SelectorComponent } from 'lightningcss';
+export declare function createTypeSelector(name: string): SelectorComponent;
+export declare function cloneComponent<T>(value: T): T;
+export declare function cloneComponents(list: SelectorComponent[]): SelectorComponent[];
+export declare function normalizeNestedSelectors(selectors: Selector[] | Selector | null | undefined): Selector[] | undefined;
+export declare function assignNestedSelectors(target: SelectorComponent & {
+    selectors?: Selector[] | Selector | null;
+}, value: Selector[] | undefined): void;
+export declare function trimCombinators(components: SelectorComponent[]): SelectorComponent[];
+export declare function matchesHiddenNot(component: SelectorComponent | undefined): boolean;

package/dist/lightningcss/style-handler.d.ts

@@ -0,0 +1,17 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss';
+import type { TransformOptions, Warning } from 'lightningcss';
+type CustomAtRules = Record<string, never>;
+export interface LightningcssStyleHandlerResult {
+    code: string;
+    map?: string;
+    warnings: Warning[];
+}
+export interface LightningcssTransformConfig {
+    filename?: string;
+    transformOptions?: Omit<TransformOptions<CustomAtRules>, 'filename' | 'code' | 'visitor'>;
+}
+interface LightningcssStyleHandler {
+    (rawSource: string, overrideOptions?: Partial<IStyleHandlerOptions>): Promise<LightningcssStyleHandlerResult>;
+}
+export declare function createLightningcssStyleHandler(options?: Partial<IStyleHandlerOptions>, config?: LightningcssTransformConfig): LightningcssStyleHandler;
+export {};

package/dist/loader-anchors-DvwgIYdA.mjs

@@ -0,0 +1,205 @@
+import { p as pluginName } from "./recorder-B_XyZ576.mjs";
+import { t as resolveTailwindcssImport } from "./css-imports-CSdPq_Sc.mjs";
+import Module from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/shared/tailwindcss-css-redirect.ts
+const moduleWithMutableResolve = Module;
+const patched = /* @__PURE__ */ new WeakSet();
+function installTailwindcssCssRedirect(pkgDir) {
+	const target = path.join(pkgDir, "index.css");
+	const original = moduleWithMutableResolve._resolveFilename;
+	if (patched.has(original)) return;
+	const replacements = new Set(["tailwindcss", "tailwindcss$"]);
+	const resolveTailwindcssCss = (request, parent, isMain, options) => {
+		if (replacements.has(request)) return target;
+		if (request.startsWith("tailwindcss/")) return path.join(pkgDir, request.slice(12));
+		return original(request, parent, isMain, options);
+	};
+	moduleWithMutableResolve._resolveFilename = resolveTailwindcssCss;
+	patched.add(moduleWithMutableResolve._resolveFilename);
+}
+//#endregion
+//#region src/shared/mpx.ts
+const MPX_STYLE_RESOURCE_QUERY_RE$1 = /(?:^|[?&])type=styles(?:&|$)/;
+function isMpxStyleResourceQuery(query) {
+	if (typeof query !== "string") return false;
+	return MPX_STYLE_RESOURCE_QUERY_RE$1.test(query);
+}
+function isMpx(appType) {
+	return appType === "mpx";
+}
+function getTailwindcssCssEntry(pkgDir) {
+	return path.join(pkgDir, "index.css");
+}
+function ensureMpxTailwindcssAliases(compiler, pkgDir) {
+	const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
+	compiler.options = compiler.options || {};
+	compiler.options.resolve = compiler.options.resolve || {};
+	const alias = compiler.options.resolve.alias ?? {};
+	if (Array.isArray(alias)) alias.push({
+		name: "tailwindcss",
+		alias: tailwindcssCssEntry
+	}, {
+		name: "tailwindcss$",
+		alias: tailwindcssCssEntry
+	});
+	else {
+		compiler.options.resolve.alias = alias;
+		alias.tailwindcss = tailwindcssCssEntry;
+		alias.tailwindcss$ = tailwindcssCssEntry;
+	}
+	return tailwindcssCssEntry;
+}
+function patchMpxLoaderResolve(loaderContext, pkgDir, enabled) {
+	if (!enabled || typeof loaderContext.resolve !== "function") return;
+	const originalResolve = loaderContext.resolve;
+	if (originalResolve.__weappTwPatched) return;
+	const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
+	const wrappedResolve = function(context, request, callback) {
+		if (request === "tailwindcss" || request === "tailwindcss$") return callback(null, tailwindcssCssEntry);
+		if (request?.startsWith("tailwindcss/")) return callback(null, path.join(pkgDir, request.slice(12)));
+		return originalResolve.call(this, context, request, callback);
+	};
+	wrappedResolve.__weappTwPatched = true;
+	loaderContext.resolve = wrappedResolve;
+}
+function setupMpxTailwindcssRedirect(pkgDir, enabled) {
+	if (enabled) installTailwindcssCssRedirect(pkgDir);
+}
+const CSS_EXT_RE$1 = /\.css$/i;
+function injectMpxCssRewritePreRules(compiler, loader, loaderOptions) {
+	var _compiler$options;
+	if (!loader) return;
+	const moduleOptions = (_compiler$options = compiler.options).module ?? (_compiler$options.module = { rules: [] });
+	moduleOptions.rules = moduleOptions.rules || [];
+	const createRule = (match) => ({
+		...match,
+		enforce: "pre",
+		use: [{
+			loader,
+			options: loaderOptions
+		}]
+	});
+	moduleOptions.rules.unshift(createRule({ resourceQuery: (query) => isMpxStyleResourceQuery(query) }), createRule({
+		test: CSS_EXT_RE$1,
+		resourceQuery: (query) => !isMpxStyleResourceQuery(query)
+	}));
+}
+//#endregion
+//#region src/bundlers/webpack/shared/css-imports.ts
+const CSS_EXT_RE = /\.(?:css|scss|sass|less|styl|pcss)$/i;
+function stripResourceQuery$1(file) {
+	let idx = file.indexOf("?");
+	if (idx === -1) idx = file.indexOf("&");
+	return idx === -1 ? file : file.slice(0, idx);
+}
+function rewriteTailwindcssRequestForCss(data, pkgDir, appType) {
+	if (!data) return;
+	const request = data.request;
+	if (!request) return;
+	if (request !== "tailwindcss" && request !== "tailwindcss$" && !request.startsWith("tailwindcss/")) return;
+	const issuer = data.contextInfo?.issuer;
+	if (!issuer) return;
+	const normalizedIssuer = stripResourceQuery$1(issuer);
+	if (!CSS_EXT_RE.test(normalizedIssuer)) return;
+	const resolved = resolveTailwindcssImport(request, pkgDir, { appType });
+	if (!resolved) return;
+	data.request = resolved;
+}
+function applyTailwindcssCssImportRewrite(compiler, options) {
+	if (!options.enabled) return;
+	compiler.hooks.normalModuleFactory.tap(pluginName, (factory) => {
+		factory.hooks.beforeResolve.tap(pluginName, (data) => {
+			rewriteTailwindcssRequestForCss(data, options.pkgDir, options.appType);
+		});
+	});
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
+const MPX_STYLE_RESOURCE_QUERY_RE = /(?:\?|&)type=styles\b/;
+function getCacheKey(filename) {
+	return filename;
+}
+function stripResourceQuery(resource) {
+	if (typeof resource !== "string") return resource;
+	const queryIndex = resource.indexOf("?");
+	if (queryIndex !== -1) return resource.slice(0, queryIndex);
+	const hashIndex = resource.indexOf("#");
+	if (hashIndex !== -1) return resource.slice(0, hashIndex);
+	return resource;
+}
+function isCssLikeModuleResource(resource, cssMatcher, appType) {
+	if (typeof resource !== "string") return false;
+	const normalizedResource = stripResourceQuery(resource);
+	if (normalizedResource && cssMatcher(normalizedResource)) return true;
+	if (appType === "mpx") return MPX_STYLE_RESOURCE_QUERY_RE.test(resource);
+	return false;
+}
+function hasLoaderEntry(entries, target) {
+	if (!target) return false;
+	return entries.some((entry) => entry.loader?.includes?.(target));
+}
+function toChunkFiles(files) {
+	if (!files) return [];
+	if (Array.isArray(files)) return files;
+	return [...files];
+}
+function createAssetHashByChunkMap(chunks) {
+	const partsByFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const hash = typeof chunk.hash === "string" ? chunk.hash : void 0;
+		if (!hash) continue;
+		const chunkId = String(chunk.id ?? chunk.name ?? "");
+		for (const file of toChunkFiles(chunk.files)) {
+			if (!file) continue;
+			let parts = partsByFile.get(file);
+			if (!parts) {
+				parts = [];
+				partsByFile.set(file, parts);
+			}
+			parts.push(`${chunkId}:${hash}`);
+		}
+	}
+	const hashByFile = /* @__PURE__ */ new Map();
+	for (const [file, parts] of partsByFile.entries()) hashByFile.set(file, parts.sort().join("|"));
+	return hashByFile;
+}
+function hasWatchChanges(compiler) {
+	return (compiler.modifiedFiles?.size ?? 0) > 0 || (compiler.removedFiles?.size ?? 0) > 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.21.10_oxc-resolver@11.16.0_@emnapi+core@1.10.0_@emnapi+runtime@1.10.0__synckit_2e62271a4111dd71b1211b37ea0ad6f5/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+//#endregion
+//#region src/bundlers/webpack/shared/loader-anchors.ts
+const MPX_STRIP_CONDITIONAL_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/strip-conditional-loader";
+const MPX_STYLE_COMPILER_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/index";
+const MPX_REWRITE_PRECEDENCE_LOADERS = [MPX_STYLE_COMPILER_LOADER, MPX_STRIP_CONDITIONAL_LOADER];
+function createFinder(targets) {
+	return (entries) => entries.findIndex((entry) => targets.some((target) => entry?.loader?.includes?.(target)));
+}
+function createPrioritizedFinder(targets) {
+	return (entries) => {
+		for (const target of targets) {
+			const idx = entries.findIndex((entry) => entry?.loader?.includes?.(target));
+			if (idx !== -1) return idx;
+		}
+		return -1;
+	};
+}
+function createLoaderAnchorFinders(appType) {
+	if (isMpx(appType)) return {
+		findRewriteAnchor: createPrioritizedFinder(MPX_REWRITE_PRECEDENCE_LOADERS),
+		findClassSetAnchor: createFinder([MPX_STYLE_COMPILER_LOADER])
+	};
+	const fallbackFinder = createFinder(["postcss-loader"]);
+	return {
+		findRewriteAnchor: fallbackFinder,
+		findClassSetAnchor: fallbackFinder
+	};
+}
+//#endregion
+export { hasLoaderEntry as a, applyTailwindcssCssImportRewrite as c, isMpx as d, patchMpxLoaderResolve as f, getCacheKey as i, ensureMpxTailwindcssAliases as l, __dirname as n, hasWatchChanges as o, setupMpxTailwindcssRedirect as p, createAssetHashByChunkMap as r, isCssLikeModuleResource as s, createLoaderAnchorFinders as t, injectMpxCssRewritePreRules as u };