weapp-tailwindcss
Version:
把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!
1,004 lines (1,003 loc) • 174 kB
JavaScript
import { $ as hasTailwindSourceDirectives, B as stripMiniProgramCssSpecificityPlaceholders, D as resolveTailwindcssOptions, F as stripUnmatchedTailwindSourceMediaCloseFragments, I as finalizeMiniProgramCss, M as removeMiniProgramHoverSelectors, N as removeTailwindV4GeneratorAtRules, Ot as resolveSourceScanPath, P as stripTailwindSourceMediaFragments, Pt as getTailwindV4IncrementalGenerateCacheStats, Q as hasTailwindRootDirectives, R as pruneMiniProgramGeneratedCss, V as removeTailwindV4GeneratedUserCssArtifacts, X as hasTailwindApplyDirective, _ as upsertTailwindV4CssSource, et as normalizeTailwindConfigDirectives, h as hasConfiguredTailwindV4CssRoots, i as normalizeWeappTailwindcssGeneratorOptions, it as removeTailwindSourceDirectives, j as isCommentOnlyCss, lt as hasTailwindGeneratedCss, o as resolveRuntimeBranch, rt as parseImportRequest, ut as hasTailwindGeneratedCssMarkers } from "./generator-DYeAa2-5.js";
import { n as _defineProperty } from "./object-Bvy6-w9r.js";
import { _ as resolveTailwindV4EntriesFromCssCached, l as getRuntimeClassSetSignature, p as resolveSourceScanEntries } from "./tailwindcss-CTpCc_nd.js";
import { r as getGroupedEntries } from "./utils-MVwpU07P.js";
import { $ as createCompilationDependencyChanges, A as isCssSourceTraceEnabled, B as createRuntimeCompilationAffectingSignature, D as annotateCssSourceTrace, E as stripBundlerGeneratedCssMarkers, F as isPureLocalCssImportWrapper, G as createRuntimeAffectingSourceSignature, K as disposeCompilerOwner, M as createRuntimeClassSetManager, N as collectStrictEscapedRuntimeCandidates, O as createCssSourceTraceCacheSignature, P as createEscapeFragments, Q as recordCompilationDependencyChanges, R as finalizeCompilerShadowRun, S as stripRequestQuery, U as resetRuntimeCompilationBuildState, V as createRuntimeCompilationBuildState, W as updateRuntimeCompilationBuildState, X as getCompilationScopeDependencyRevision, Y as AssetEmissionPlan, _ as collectFrameworkPostcssOptionsFromLoaderEntries, b as hasMiniProgramTailwindV4PreflightReset, c as pushConcurrentTaskFactories, g as captureResolvedFrameworkPostcssOptions, it as resolveSourceCandidateScanFiles, j as processCachedTask, k as createCssTokenSourceMap, l as resolveTaskConcurrency, m as removeGeneratedSelectorCompatCss, n as emitHmrTiming, nt as isSourceCandidateRequest, p as scoreTailwindV4CssSourceFileMatch, q as beginCompilerShadowRun, r as generateTailwindV4Css, s as collectRawSourceClassSelectors, tt as createSourceCandidateStore, v as createCssSourceOrderAppend, w as hasBundlerGeneratedCssMarker, x as isSourceStyleRequest, z as buildRuntimeCompilationSnapshot } from "./hmr-timing-WgN_3dIC.js";
import { h as createDebug, v as md5Hash } from "./wxml-IBzZSaQC.js";
import { d as refreshTailwindRuntimeState, i as pluginName, l as createTailwindRuntimeReadyPromise, n as normalizeStyleHandlerMajorVersion, o as shouldSkipJsTransform, r as resolveStyleOptionsFromContext, t as getCompilerContext, u as ensureRuntimeClassSet } from "./context-YAvTyPV2.js";
import { getDefaultCssPreflight } from "./defaults.js";
import { S as resolveWebpackFrameworkProfile, a as createCandidateSignature, b as webpackStyleInjectorDelegates, d as classifyRuntimeEntry, f as resolvePackageDir, g as toAbsoluteOutputPath, h as resolveOutputSpecifier, p as resolvePluginDisabledState, r as createScopedGeneratorRuntime, t as createSourceCandidateScanSignature, v as createBuiltinWebpackStyleInjectorPlugin } from "./source-candidate-scan-signature-ZozKGBbH.js";
import Module, { createRequire } from "node:module";
import fs from "node:fs";
import path from "node:path";
import process from "node:process";
import { dedupeCoveredCssRules, filterExistingCssRules, mergeCoveredCssRuleDeclarations, postcss } from "@weapp-tailwindcss/postcss";
import { readFile, stat } from "node:fs/promises";
import micromatch from "micromatch";
import { MappingChars2String } from "@weapp-core/escape";
import { fileURLToPath } from "node:url";
//#region src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
function getCacheKey(filename) {
return filename;
}
function stripResourceQuery(resource) {
if (typeof resource !== "string") return resource;
return stripRequestQuery(resource);
}
function isCssLikeModuleResource(resource, cssMatcher) {
if (typeof resource !== "string") return false;
const normalizedResource = stripResourceQuery(resource);
if (normalizedResource && cssMatcher(normalizedResource)) return true;
if (isSourceStyleRequest(resource)) return true;
return false;
}
function hasLoaderEntry(entries, target) {
if (!target) return false;
return entries.some((entry) => entry.loader?.includes?.(target));
}
function normalizeWatchPath(file) {
return path.resolve(file);
}
function isFileInContext(file, context) {
const relative = path.relative(normalizeWatchPath(context), normalizeWatchPath(file));
return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
}
function toChunkFiles(files) {
if (!files) return [];
if (Array.isArray(files)) return files;
return [...files];
}
function inferWebpackMainCssFiles(chunks, cssMatcher, options = {}) {
const mainCssFiles = /* @__PURE__ */ new Set();
const shouldCheckSourceResources = Boolean(options.mainSourceFiles?.size);
for (const chunk of chunks) {
const files = toChunkFiles(chunk.files);
if (!(chunk.hasRuntime?.() === true)) continue;
for (const file of files) {
if (!cssMatcher(file)) continue;
if (shouldCheckSourceResources) {
const resources = options.resourcesByAsset?.get(file);
if (!resources || ![...resources].some((resource) => options.mainSourceFiles?.has(resource))) continue;
}
mainCssFiles.add(file);
}
}
return mainCssFiles;
}
function resolveSingleActiveWebpackCssResource(assetResources, activeWebpackAssetResourceFiles) {
const activeAssetResourceMatches = [...assetResources ?? []].map((sourceFile) => path.resolve(sourceFile)).filter((sourceFile) => activeWebpackAssetResourceFiles.has(sourceFile)).sort();
return activeAssetResourceMatches.length === 1 ? activeAssetResourceMatches[0] : void 0;
}
function resolveWebpackCssModuleIdentifierResource(module) {
if (!module.type?.startsWith("css/") || typeof module.identifier !== "function") return;
const identifier = module.identifier();
const request = identifier.startsWith("css|") ? identifier.slice(4) : identifier;
const resourceWithMetadata = request.slice(request.lastIndexOf("!") + 1);
const metadataIndex = resourceWithMetadata.indexOf("|");
return metadataIndex === -1 ? resourceWithMetadata : resourceWithMetadata.slice(0, metadataIndex);
}
function createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, onlyUnambiguousCssAssets) {
const resourcesByAsset = /* @__PURE__ */ new Map();
if (!chunkGraph?.getChunkModulesIterable) return resourcesByAsset;
const collectModuleResources = (module, resources, seen = /* @__PURE__ */ new Set()) => {
if (!module || seen.has(module)) return;
seen.add(module);
const candidates = [
module.resource,
module.request,
module.userRequest
];
if (onlyUnambiguousCssAssets) candidates.push(resolveWebpackCssModuleIdentifierResource(module));
for (const candidate of candidates) {
if (typeof candidate !== "string") continue;
const normalized = normalizeResource(candidate, module);
if (normalized) resources.add(normalized);
}
for (const nested of [module.rootModule, chunkGraph.getIssuer?.(module)]) if (nested) collectModuleResources(nested, resources, seen);
for (const nested of module.modules ?? []) collectModuleResources(nested, resources, seen);
for (const dependency of module.dependencies ?? []) {
const dependencyLike = dependency;
for (const candidate of [dependencyLike.request, dependencyLike.userRequest]) {
if (typeof candidate !== "string") continue;
const normalized = normalizeResource(candidate, module);
if (normalized) resources.add(normalized);
}
const dependencyModule = chunkGraph.getModule?.(dependency);
if (dependencyModule) collectModuleResources(dependencyModule, resources, seen);
}
};
for (const chunk of chunks) {
const cssFiles = toChunkFiles(chunk.files).filter((file) => cssMatcher(file));
if (cssFiles.length === 0 || onlyUnambiguousCssAssets && cssFiles.length !== 1) continue;
const modules = chunkGraph.getChunkModulesIterable(chunk);
if (!modules) continue;
const cssResources = /* @__PURE__ */ new Set();
for (const module of modules) collectModuleResources(module, cssResources);
if (cssResources.size === 0) continue;
for (const cssFile of cssFiles) resourcesByAsset.set(cssFile, cssResources);
}
return resourcesByAsset;
}
function createWebpackCssAssetResourceMap(chunks, chunkGraph, cssMatcher, normalizeResource) {
return createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, false);
}
function createWebpackDirectCssAssetResourceMap(chunks, chunkGraph, cssMatcher, normalizeResource) {
return createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, true);
}
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 createRuntimeAwareCssHash(assetHash, sourceHash, runtimeSetHash) {
return `${assetHash ?? sourceHash}:${runtimeSetHash}`;
}
function isWatchFileInRuntimeDependencies(file, dependencies) {
const normalizedFile = normalizeWatchPath(file);
for (const dependency of dependencies.files ?? []) if (normalizeWatchPath(dependency) === normalizedFile) return true;
for (const context of dependencies.contexts ?? []) if (isFileInContext(normalizedFile, context)) return true;
return false;
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/runtime-candidates.ts
function isRuntimeTransformCandidate(candidate) {
return candidate.length > 0 && !candidate.includes("=") && !candidate.includes("<") && !candidate.includes(">") && !candidate.includes("${");
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/user-css-markers.ts
function collectWebpackAssetUserCssMarkers(source) {
const markers = /* @__PURE__ */ new Set();
for (const match of source.matchAll(/\.((?:\\.|[_a-z\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/gi)) markers.add(`class:${match[1]}`);
for (const match of source.matchAll(/@(?:-[\w-]+-)?keyframes\s+((?:\\.|[-\w\u00A0-\uFFFF])+)/gi)) markers.add(`keyframes:${match[1]}`);
try {
const root = postcss.parse(source);
root.walkRules((rule) => {
for (const selector of rule.selectors) if (!/(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i.test(selector)) markers.add(`selector:${selector.trim().replace(/\s+/g, " ")}`);
rule.walkDecls((decl) => {
if (decl.prop.startsWith("--")) markers.add(`custom-property:${decl.prop}`);
});
});
root.walkAtRules("font-face", (rule) => {
rule.walkDecls("font-family", (decl) => {
markers.add(`font-face:${decl.value.trim()}`);
});
});
} catch {}
return markers;
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/generated-css.ts
const WEBPACK_TAILWIND_GENERATED_LAYER_NAMES = /* @__PURE__ */ new Set([
"theme",
"base",
"utilities"
]);
const WEBPACK_TAILWIND_UTILITY_RULE_MARKER_RE = /(?:^|[^\w-])\.[^,{]{0,512}(?:\\:|\\\[|\\#)/;
const WEBPACK_TAILWIND_UTILITY_PREFIX_RE = /^\.(?:-?(?:bg|text|border|ring|shadow|drop-shadow|[pmwhz]|px|py|pt|pr|pb|pl|mx|my|mt|mr|mb|ml|min-w|min-h|max-w|max-h|flex|grid|inline|block|hidden|rounded|opacity|translate|scale|rotate|skew|top|right|bottom|left|inset|gap|font|leading|tracking|underline|container)(?:[\-\\{]|$)|\\\[)/;
const WEBPACK_TAILWIND_BANNER_RE = /tailwindcss v4\./;
const WEBPACK_TAILWIND_PREFLIGHT_SELECTORS = /* @__PURE__ */ new Set([
"*",
":after",
":before",
"::after",
"::before",
"::backdrop",
"view",
"text"
]);
const WEBPACK_TAILWIND_PREFLIGHT_PROPS = /* @__PURE__ */ new Set([
"box-sizing",
"border",
"border-width",
"border-style",
"border-color",
"margin",
"padding"
]);
const WEBPACK_TAILWIND_THEME_TOKEN_RE = /^--(?:tw-|color-|spacing|breakpoint-|container-|text-|font-|tracking-|leading-|radius-|shadow-|inset-shadow-|drop-shadow-|ease-|animate-|blur-|perspective-|aspect-|default-)/;
function parseWebpackCssLayerNames(params) {
return params.split(",").map((name) => name.trim()).filter(Boolean);
}
function removeWebpackTailwindGeneratedAssetCss(source) {
const cleaned = removeTailwindV4GeneratedUserCssArtifacts(source);
try {
const root = postcss.parse(cleaned);
let changed = false;
let removingBannerPrefix = false;
for (const node of [...root.nodes]) {
if (node.type === "comment" && WEBPACK_TAILWIND_BANNER_RE.test(node.text)) {
node.remove();
changed = true;
removingBannerPrefix = true;
continue;
}
if (!removingBannerPrefix) continue;
if (isWebpackTailwindGeneratedPrefixNode(node)) {
node.remove();
changed = true;
continue;
}
removingBannerPrefix = false;
}
root.walkAtRules("layer", (rule) => {
const names = parseWebpackCssLayerNames(rule.params);
const hasGeneratedLayerName = names.some((name) => WEBPACK_TAILWIND_GENERATED_LAYER_NAMES.has(name));
const isLayerDeclaration = rule.nodes === void 0;
const shouldRemoveLayer = isLayerDeclaration ? hasGeneratedLayerName : names.length > 0 && names.every((name) => WEBPACK_TAILWIND_GENERATED_LAYER_NAMES.has(name));
if (shouldRemoveLayer && isLayerDeclaration) {
rule.remove();
changed = true;
return;
}
if (shouldRemoveLayer && !names.includes("utilities")) {
for (const child of [...rule.nodes ?? []]) if (isWebpackTailwindGeneratedLayerNode(child, names)) {
child.remove();
changed = true;
}
if (rule.nodes?.length === 0) {
rule.remove();
changed = true;
}
return;
}
if (shouldRemoveLayer) {
for (const child of [...rule.nodes ?? []]) if (isWebpackTailwindGeneratedLayerNode(child, names)) {
child.remove();
changed = true;
}
if (rule.nodes?.length === 0) {
rule.remove();
changed = true;
}
}
});
root.walkRules((rule) => {
if (rule.parent?.type === "atrule" && rule.parent.name === "layer") return;
const selector = rule.selector.trim();
if (WEBPACK_TAILWIND_UTILITY_RULE_MARKER_RE.test(selector) || isWebpackTailwindGeneratedPreflightRule(rule)) {
rule.remove();
changed = true;
}
});
root.walkComments((comment) => {
if (WEBPACK_TAILWIND_BANNER_RE.test(comment.text)) {
comment.remove();
changed = true;
}
});
root.walkAtRules((rule) => {
if (rule.nodes !== void 0 && rule.nodes.length === 0) {
rule.remove();
changed = true;
}
});
return changed ? root.toString() : cleaned;
} catch {
return cleaned;
}
}
function isWebpackTailwindGeneratedPrefixNode(node) {
if (node.type === "rule") return isWebpackTailwindGeneratedRule(node, [
"theme",
"base",
"utilities"
], true);
if (node.type !== "atrule") return false;
const names = node.name === "layer" ? parseWebpackCssLayerNames(node.params) : [];
if (node.name === "property" && node.params.trim().startsWith("--tw-")) return true;
if (names.length > 0 && names.every((name) => WEBPACK_TAILWIND_GENERATED_LAYER_NAMES.has(name))) {
if (node.nodes === void 0) return true;
return node.nodes.length > 0 && node.nodes.every((child) => isWebpackTailwindGeneratedLayerNode(child, names));
}
if (node.nodes === void 0 || node.nodes.length === 0) return false;
return node.nodes.every((child) => isWebpackTailwindGeneratedPrefixNode(child));
}
function isWebpackTailwindGeneratedLayerNode(node, layerNames) {
if (node.type === "rule") return isWebpackTailwindGeneratedRule(node, layerNames, false);
if (node.type !== "atrule") return false;
if (node.name === "property" && node.params.trim().startsWith("--tw-")) return true;
if (node.nodes === void 0 || node.nodes.length === 0) return false;
return node.nodes.every((child) => isWebpackTailwindGeneratedLayerNode(child, layerNames));
}
function isWebpackTailwindGeneratedRule(rule, layerNames, includePrefix) {
const selectors = rule.selectors ?? [rule.selector];
if (selectors.every((selector) => isWebpackTailwindGeneratedUtilitySelector(selector.trim(), includePrefix))) return true;
if (selectors.every((selector) => isWebpackTailwindGeneratedUtilitySelector(selector.trim(), true))) return true;
if (layerNames.includes("theme") && isWebpackTailwindGeneratedThemeRule(rule)) return true;
if (layerNames.includes("base") && isWebpackTailwindGeneratedPreflightRule(rule)) return true;
return false;
}
function isWebpackTailwindGeneratedThemeRule(rule) {
const declarations = (rule.nodes ?? []).filter((node) => node.type === "decl");
return declarations.length > 0 && declarations.every((decl) => WEBPACK_TAILWIND_THEME_TOKEN_RE.test(decl.prop) || decl.value.includes("--theme("));
}
function isWebpackTailwindGeneratedPreflightRule(rule) {
const selectors = rule.selectors ?? [rule.selector];
const declarations = (rule.nodes ?? []).filter((node) => node.type === "decl");
return selectors.length > 0 && declarations.length > 0 && selectors.every((selector) => {
const normalized = selector.trim().replace(/\s+/g, " ");
return WEBPACK_TAILWIND_PREFLIGHT_SELECTORS.has(normalized);
}) && declarations.every((decl) => WEBPACK_TAILWIND_PREFLIGHT_PROPS.has(decl.prop));
}
function isOnlyWebpackTailwindGeneratedPreflightCss(source) {
try {
const nodes = postcss.parse(source).nodes ?? [];
return nodes.length > 0 && nodes.every((node) => {
if (node.type === "rule") return isWebpackTailwindGeneratedPreflightRule(node);
return node.type === "atrule" && (node.nodes === void 0 || node.nodes.length === 0);
});
} catch {
return false;
}
}
function isWebpackTailwindGeneratedUtilitySelector(selector, includePrefix) {
return WEBPACK_TAILWIND_UTILITY_RULE_MARKER_RE.test(selector) || includePrefix && WEBPACK_TAILWIND_UTILITY_PREFIX_RE.test(selector);
}
function collectWebpackCssRuleIdentityMarkers(source) {
const markers = /* @__PURE__ */ new Set();
try {
const root = postcss.parse(source);
root.walkRules((rule) => {
for (const selector of rule.selectors) for (const match of selector.matchAll(/\.((?:\\.|[_a-z\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/gi)) markers.add(`class:${match[1]}`);
});
root.walkAtRules("keyframes", (rule) => {
if (rule.params) markers.add(`keyframes:${rule.params}`);
});
} catch {}
return markers;
}
function unescapeCssIdentifier(value) {
return value.replace(/\\([0-9a-f]{1,6}\s?|.)/gi, (_match, escaped) => {
const hex = escaped.trim();
if (/^[0-9a-f]+$/i.test(hex)) return String.fromCodePoint(Number.parseInt(hex, 16));
return escaped;
});
}
function collectGeneratedCssRuntimeCandidates(source) {
const candidates = /* @__PURE__ */ new Set();
if (hasBundlerGeneratedCssMarker(source) || !hasTailwindGeneratedCss(source) && !hasTailwindGeneratedCssMarkers(source)) return candidates;
try {
postcss.parse(source).walkRules((rule) => {
for (const selector of rule.selectors) for (const match of selector.matchAll(/\.((?:\\.|[\w\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/g)) {
const candidate = unescapeCssIdentifier(match[1]);
if (isRuntimeTransformCandidate(candidate)) candidates.add(candidate);
}
});
} catch {}
return candidates;
}
function hasAdditionalWebpackAssetUserCssMarkers(rawSource, generatorRawSource) {
const rawMarkers = collectWebpackAssetUserCssMarkers(rawSource);
if (rawMarkers.size === 0) return false;
const generatorMarkers = collectWebpackAssetUserCssMarkers(generatorRawSource);
for (const marker of rawMarkers) if (!generatorMarkers.has(marker)) return true;
return false;
}
function hasWebpackTailwindSourceDirectives(source) {
return Boolean(source) && (hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindSourceDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source) || hasTailwindGeneratedCss(source) || hasTailwindGeneratedCssMarkers(source));
}
function resolveConfiguredWebpackCssPreflight(compilerOptions, styleOptions) {
return styleOptions.cssPreflight ?? compilerOptions.cssPreflight ?? getDefaultCssPreflight();
}
function resolveExistingWebpackCssPreflight(compilerOptions, styleOptions, source) {
return hasMiniProgramPreflightSelector(source) ? resolveConfiguredWebpackCssPreflight(compilerOptions, styleOptions) : void 0;
}
function removeMiniProgramPreflightSelectorRule(source) {
try {
const root = postcss.parse(source);
let changed = false;
root.walkRules((rule) => {
const selectors = new Set((rule.selectors ?? [rule.selector]).map((selector) => selector.trim().replace(/^:before$/, "::before").replace(/^:after$/, "::after")));
if (selectors.has("view") && selectors.has("text") && selectors.has("::before") && selectors.has("::after")) {
rule.remove();
changed = true;
}
});
return changed ? root.toString() : source;
} catch {
return source.replace(/(?:^|[}\s])\s*view\s*,\s*text\s*,\s*::after\s*,\s*::before\s*\{[^}]*\}/g, "");
}
}
function dedupeMiniProgramPreflightSelectorRules(source) {
try {
const root = postcss.parse(source);
let firstRule;
let changed = false;
root.walkRules((rule) => {
const selectors = new Set((rule.selectors ?? [rule.selector]).map((selector) => selector.trim().replace(/^:before$/, "::before").replace(/^:after$/, "::after")));
if (!selectors.has("view") || !selectors.has("text") || !selectors.has("::before") || !selectors.has("::after")) return;
if (!firstRule) {
firstRule = rule;
return;
}
const existingProps = /* @__PURE__ */ new Set();
firstRule.walkDecls((decl) => {
existingProps.add(decl.prop);
});
rule.walkDecls((decl) => {
if (!existingProps.has(decl.prop)) {
firstRule?.append(decl.clone());
existingProps.add(decl.prop);
}
});
rule.remove();
changed = true;
});
return changed ? root.toString() : source;
} catch {
return source;
}
}
function hasMiniProgramPreflightSelector(source) {
try {
let found = false;
postcss.parse(source).walkRules((rule) => {
const selectors = new Set((rule.selectors ?? [rule.selector]).map((selector) => selector.trim().replace(/^:before$/, "::before").replace(/^:after$/, "::after")));
if (selectors.has("view") && selectors.has("text") && selectors.has("::before") && selectors.has("::after")) {
found = true;
return false;
}
});
return found;
} catch {
return /(?:^|[},])\s*view\s*,\s*text\s*,\s*::after\s*,\s*::before\s*\{/.test(source);
}
}
function ensureWebpackMiniProgramTwContentInit(source) {
if (!source.includes("var(--tw-content)")) return source;
try {
const root = postcss.parse(source);
let changed = false;
root.walkRules((rule) => {
const selectors = new Set((rule.selectors ?? [rule.selector]).map((selector) => selector.trim().replace(/^:before$/, "::before").replace(/^:after$/, "::after")));
if (!selectors.has("view") || !selectors.has("text") || !selectors.has("::before") || !selectors.has("::after")) return;
let hasContentInit = false;
rule.walkDecls("--tw-content", () => {
hasContentInit = true;
});
if (!hasContentInit) {
rule.append(postcss.decl({
prop: "--tw-content",
value: "''"
}));
changed = true;
}
return false;
});
return changed ? root.toString() : source;
} catch {
return source;
}
}
function removeTailwindV4StandaloneHostPreflightRule(source) {
if (!source.includes("--theme(")) return source;
try {
const root = postcss.parse(source);
let changed = false;
root.walkRules((rule) => {
if (rule.selector.trim() !== ":host") return;
if (!rule.nodes?.some((node) => node.type === "decl" && node.value?.includes("--theme("))) return;
rule.remove();
changed = true;
});
return changed ? root.toString() : source;
} catch {
return source;
}
}
function collectRuntimeTokenSignatureParts(source) {
return source.match(/[\w-]+_[A-Z][\w-]*/gi) ?? [];
}
function hasMissingRuntimeCandidates(classSet, candidates) {
if (!classSet || !candidates?.size) return false;
for (const candidate of candidates) if (isRuntimeTransformCandidate(candidate) && !classSet.has(candidate)) return true;
return false;
}
function hasStaleRuntimeCandidates(classSet, candidates) {
if (!classSet || !candidates) return false;
for (const candidate of classSet) if (isRuntimeTransformCandidate(candidate) && !candidates.has(candidate)) return true;
return false;
}
function resolveGeneratedCssRuntimeCandidates(source, fallbackClassSet) {
const classSet = collectGeneratedCssRuntimeCandidates(source);
if (classSet.size > 0 || fallbackClassSet === void 0) return classSet;
return fallbackClassSet;
}
function getRuntimeClassSetSync(tailwindRuntime) {
if (typeof tailwindRuntime.getClassSetSync !== "function") return /* @__PURE__ */ new Set();
try {
return new Set(tailwindRuntime.getClassSetSync() ?? []);
} catch {
return /* @__PURE__ */ new Set();
}
}
function toMb(bytes) {
return Math.round(bytes / 1024 / 1024);
}
function pruneMapToMaxSize(map, maxSize) {
while (map.size > maxSize) {
const oldestKey = map.keys().next().value;
if (oldestKey === void 0) break;
map.delete(oldestKey);
}
}
function stripTrailingLineWhitespace(source) {
return source.replace(/[ \t]+$/gm, "");
}
function pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache, cssUserHandlerOptionsCache, activeCssFiles) {
const activeSuffixes = [...activeCssFiles].map((file) => `:${file}`);
for (const key of cssHandlerOptionsCache.keys()) if (!activeSuffixes.some((suffix) => key.endsWith(suffix))) cssHandlerOptionsCache.delete(key);
for (const key of cssUserHandlerOptionsCache.keys()) if (!activeSuffixes.some((suffix) => key.endsWith(suffix))) cssUserHandlerOptionsCache.delete(key);
pruneMapToMaxSize(cssHandlerOptionsCache, 128);
pruneMapToMaxSize(cssUserHandlerOptionsCache, 128);
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/memory-trace.ts
function resolveWebpackMemoryDebugStats(context) {
if (process.env["WEAPP_TW_HMR_MEMORY_DEBUG"] !== "1") return;
const memory = process.memoryUsage();
const processCacheInstanceSize = context.cache.instance.size;
const processCacheHashMapSize = context.cache.hashMap.size;
return {
phase: context.phase,
process: {
rssMb: toMb(memory.rss),
heapTotalMb: toMb(memory.heapTotal),
heapUsedMb: toMb(memory.heapUsed),
externalMb: toMb(memory.external),
arrayBuffersMb: toMb(memory.arrayBuffers)
},
assets: {
active: context.activeAssetFiles,
activeCss: context.activeCssFiles
},
processCache: {
instance: processCacheInstanceSize,
hashMap: processCacheHashMapSize,
activeCacheKeys: context.activeProcessCacheKeys.size,
activeHashKeys: context.activeProcessHashKeys.size,
staleCacheKeys: Math.max(0, processCacheInstanceSize - context.activeProcessCacheKeys.size),
staleHashKeys: Math.max(0, processCacheHashMapSize - context.activeProcessHashKeys.size),
pruned: true,
pruneSkipped: false
},
webpackCss: {
handlerOptions: context.cssHandlerOptionsCache.size,
userHandlerOptions: context.cssUserHandlerOptionsCache.size,
maxHandlerOptions: 128
},
sourceCandidateScan: context.sourceCandidateScan,
tailwind: { v4: getTailwindV4IncrementalGenerateCacheStats() }
};
}
function shouldInjectWebpackCssTracePreflight(_appType, cssHandlerOptions) {
if (includesTailwindPreflightImport(cssHandlerOptions.sourceOptions?.sourceCss)) return true;
return cssHandlerOptions.isMainChunk !== false;
}
function includesTailwindPreflightImport(source) {
if (!source) return false;
try {
let includesPreflight = false;
postcss.parse(source).walkAtRules((rule) => {
if (rule.name === "tailwind") {
includesPreflight || (includesPreflight = rule.params.trim() === "base");
return;
}
if (rule.name !== "import") return;
const request = parseImportRequest(rule.params)?.replaceAll("\\", "/");
includesPreflight || (includesPreflight = request === "tailwindcss" || request === "tailwindcss/preflight.css" || request?.endsWith("/tailwindcss/index.css") === true || request?.endsWith("/tailwindcss/preflight.css") === true);
});
return includesPreflight;
} catch {
return false;
}
}
function finalizeMiniProgramUserCssAssetSource(source, compilerOptions, isWebGeneratorTarget, options = {}) {
const styleOptions = resolveStyleOptionsFromContext(compilerOptions);
if (isWebGeneratorTarget) return source;
return stripMiniProgramCssSpecificityPlaceholders(removeTailwindV4StandaloneHostPreflightRule(finalizeMiniProgramCss(removeMiniProgramHoverSelectors(source, styleOptions.cssRemoveHoverPseudoClass), {
cssPreflight: options.cssPreflight === false ? false : !hasMiniProgramTailwindV4PreflightReset(source) ? resolveConfiguredWebpackCssPreflight(compilerOptions, styleOptions) : void 0,
isTailwindcssV4: true,
tailwindcssV4GradientFallback: styleOptions.tailwindcssV4GradientFallback
})));
}
function shouldFallbackToWebpackUserCssOnGeneratorError(options) {
return !hasTailwindRootDirectives(options.generatorRawSource, { importFallback: true }) && !hasTailwindSourceDirectives(options.generatorRawSource, { importFallback: true }) && !hasTailwindApplyDirective(options.generatorRawSource) && !options.hasExplicitTailwindV4SourceCss && options.configuredMainCssEntryFilesLength === 0;
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/finalize.ts
function finalizeTracedWebpackCssAsset(css, cssHandlerOptions, options) {
if (options.finalized === true) return options.annotateCss(css);
if (options.isWebGeneratorTarget || !isCssSourceTraceEnabled(options.compilerOptions)) return options.annotateCss(css);
const finalized = finalizeMiniProgramUserCssAssetSource(css, options.compilerOptions, options.isWebGeneratorTarget, { cssPreflight: shouldInjectWebpackCssTracePreflight(options.compilerOptions.appType, cssHandlerOptions) });
return options.annotateCss(finalized);
}
function finalizeWebpackCssAssetSource(source, compilerOptions, isWebGeneratorTarget, options = {}) {
const styleOptions = resolveStyleOptionsFromContext(compilerOptions);
if (isWebGeneratorTarget) {
if (options.generatedCss === true) return stripTrailingLineWhitespace(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(stripBundlerGeneratedCssMarkers(source))));
return stripTrailingLineWhitespace(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(removeTailwindV4GeneratorAtRules(removeTailwindSourceDirectives(stripBundlerGeneratedCssMarkers(source), { importFallback: true })))));
}
let finalized = removeTailwindSourceDirectives(stripBundlerGeneratedCssMarkers(source), { importFallback: true });
if (options.generatedCss !== true) {
finalized = finalizeMiniProgramCss(finalized, {
cssPreflight: false,
isTailwindcssV4: true,
tailwindcssV4GradientFallback: styleOptions.tailwindcssV4GradientFallback
});
finalized = dedupeMiniProgramPreflightSelectorRules(finalized);
return stripMiniProgramCssSpecificityPlaceholders(removeMiniProgramHoverSelectors(finalized, styleOptions.cssRemoveHoverPseudoClass));
}
try {
finalized = pruneMiniProgramGeneratedCss(finalized, { preservePreflight: options.cssPreflight !== false });
} catch {}
const shouldRemoveExistingPreflight = options.cssPreflight === false && options.preserveExistingPreflight === false;
if (shouldRemoveExistingPreflight) finalized = removeMiniProgramPreflightSelectorRule(finalized);
const hasExistingMiniProgramPreflight = options.preserveExistingPreflight !== false && hasMiniProgramPreflightSelector(source);
finalized = finalizeMiniProgramCss(finalized, {
cssPreflight: options.cssPreflight === false && !hasExistingMiniProgramPreflight ? false : !hasMiniProgramTailwindV4PreflightReset(finalized) ? resolveExistingWebpackCssPreflight(compilerOptions, styleOptions, source) : void 0,
isTailwindcssV4: true,
tailwindcssV4GradientFallback: styleOptions.tailwindcssV4GradientFallback
});
finalized = ensureWebpackMiniProgramTwContentInit(finalized);
if (shouldRemoveExistingPreflight) finalized = removeMiniProgramPreflightSelectorRule(finalized);
else finalized = dedupeMiniProgramPreflightSelectorRules(finalized);
return stripMiniProgramCssSpecificityPlaceholders(removeMiniProgramHoverSelectors(finalized, styleOptions.cssRemoveHoverPseudoClass));
}
function finalizeWebpackCssAssetOutputSource(source, compilerOptions, isWebGeneratorTarget) {
if (isWebGeneratorTarget) return source;
const styleOptions = resolveStyleOptionsFromContext(compilerOptions);
return stripMiniProgramCssSpecificityPlaceholders(removeMiniProgramHoverSelectors(dedupeCoveredCssRules(dedupeMiniProgramPreflightSelectorRules(source)), styleOptions.cssRemoveHoverPseudoClass));
}
function collectWebpackJsRuntimeCandidatesFromAssets(options) {
if (options.isWebGeneratorTarget) return;
const candidates = /* @__PURE__ */ new Set();
for (const file of options.jsAssets) {
const sourceLike = options.getAssetSource(file);
if (sourceLike === void 0) continue;
const source = stringifyWebpackSourceLike(sourceLike);
for (const candidate of collectStrictEscapedRuntimeCandidates(source, MappingChars2String, options.escapeFragments)) if (isRuntimeTransformCandidate(candidate)) candidates.add(candidate);
}
return candidates;
}
function collectWebpackJsRuntimeTokenSignature(options) {
if (options.isWebGeneratorTarget) return "";
const tokens = [];
for (const file of options.jsAssets) {
const sourceLike = options.getAssetSource(file);
if (sourceLike === void 0) continue;
tokens.push(...collectRuntimeTokenSignatureParts(stringifyWebpackSourceLike(sourceLike)));
}
return tokens.sort().join("\n");
}
function addRuntimeTransformCandidates(target, candidates) {
if (!candidates?.size) return;
for (const candidate of candidates) if (isRuntimeTransformCandidate(candidate)) target.add(candidate);
}
function createWebpackCssSourceTraceTokenSources(compilerOptions, webpackSourceCandidates) {
if (!isCssSourceTraceEnabled(compilerOptions) || !webpackSourceCandidates) return;
return createCssTokenSourceMap(webpackSourceCandidates.tokenSources, compilerOptions);
}
function stringifyOptionalWebpackSourceValue(value) {
return typeof value === "string" ? value : value?.toString() ?? "";
}
function stringifyWebpackSourceLike(source) {
if (typeof source === "string") return source;
const value = source.source();
return typeof value === "string" ? value : value.toString();
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/resources.ts
function isWindowsAbsoluteResourcePath(file) {
return /^[a-z]:[\\/]/i.test(file) || /^[/\\]{2}[^/\\]/.test(file);
}
function isPosixAbsoluteResourcePath(file) {
return file.startsWith("/");
}
function resolveWebpackResourcePath(file, base) {
if (isWindowsAbsoluteResourcePath(file)) return path.win32.resolve(file);
if (isPosixAbsoluteResourcePath(file)) return path.posix.resolve(file);
if (base) {
if (isWindowsAbsoluteResourcePath(base)) return path.win32.resolve(base, file);
if (isPosixAbsoluteResourcePath(base)) return path.posix.resolve(base, file);
return path.resolve(base, file);
}
}
function dirnameWebpackResourcePath(file) {
if (isWindowsAbsoluteResourcePath(file)) return path.win32.dirname(file);
if (isPosixAbsoluteResourcePath(file)) return path.posix.dirname(file);
return path.dirname(file);
}
function resolveWebpackCssAssetModuleResource(resource, issuer, options) {
if (!isCssLikeModuleResource(resource, options.cssMatcher, options.appType)) return;
const normalized = stripResourceQuery(resource);
if (!normalized) return;
const absoluteResource = resolveWebpackResourcePath(normalized);
if (absoluteResource) return absoluteResource;
const issuerResource = issuer?.resource ? stripResourceQuery(issuer.resource) : void 0;
const issuerResourcePath = issuerResource ? resolveWebpackResourcePath(issuerResource) : void 0;
return resolveWebpackResourcePath(normalized, issuerResourcePath ? dirnameWebpackResourcePath(issuerResourcePath) : issuer?.context);
}
function isSameWebpackCssSourceScope(options) {
if (!options.currentSourceFile) return false;
const candidateKey = resolveWebpackResourcePath(options.candidateSourceFile) ?? path.resolve(options.candidateSourceFile);
if (candidateKey === (resolveWebpackResourcePath(options.currentSourceFile) ?? path.resolve(options.currentSourceFile))) return true;
const outputResources = options.resourcesByAsset.get(options.outputFile);
if (!outputResources) return false;
return [...outputResources].some((resource) => {
return (resolveWebpackResourcePath(resource) ?? path.resolve(resource)) === candidateKey;
});
}
function shouldAppendCurrentWebpackAssetUserCss(options) {
const hasGeneratedAssetUserCss = options.currentAssetLooksGenerated && options.currentAssetHasUserCss;
return !options.currentAssetHasBundlerGeneratedMarker && !options.shouldPreserveGeneratedWebAssetUserCss && (hasGeneratedAssetUserCss || !options.sourceCssProcessed || options.registeredUserRawSource === void 0 || options.currentAssetHasUserCss) && !(options.sourceCssProcessed && options.currentAssetLooksGenerated && !options.currentAssetHasUserCss);
}
function createWebpackCurrentAssetUserRawSource(options) {
if (!options.shouldAppendCurrentAssetUserCss) return;
if (options.sourceCssProcessed) return {
css: options.currentAssetUserCssSource,
processed: true
};
if (!options.currentAssetHasUserCss) return;
return {
css: options.currentAssetUserCssSource,
processed: options.currentAssetLooksGenerated
};
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/sources.ts
function resolveWebpackGeneratorRawSource(rawSource, cssHandlerOptions) {
const sourceCss = cssHandlerOptions.sourceOptions?.sourceCss;
if (sourceCss && (hasTailwindRootDirectives(sourceCss, { importFallback: true }) || hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || hasTailwindApplyDirective(sourceCss) || hasTailwindGeneratedCss(sourceCss) || hasTailwindGeneratedCssMarkers(sourceCss))) return sourceCss;
return rawSource;
}
function shouldConsumeWebpackLoaderGeneratedCss(options) {
if (!options.shouldRegenerateExplicitTailwindV4CssSource) return true;
if (options.watchMode === true && options.loaderGeneratedClassSet && options.sourceCandidates && hasStaleRuntimeCandidates(options.loaderGeneratedClassSet, options.sourceCandidates)) return false;
if (options.hasBundlerGeneratedCssMarker) return true;
if (options.watchMode === true && options.loaderGeneratedClassSet && options.sourceCandidates && hasMissingRuntimeCandidates(options.loaderGeneratedClassSet, options.sourceCandidates)) return false;
return Boolean(options.allowMarkerlessRegistryMatch && options.loaderGeneratedClassSet && options.sourceCandidates && !hasMissingRuntimeCandidates(options.loaderGeneratedClassSet, options.sourceCandidates) && !hasStaleRuntimeCandidates(options.loaderGeneratedClassSet, options.sourceCandidates));
}
function hasDeferredWebpackGeneratedCss(source, generatedClassSets) {
const selectors = collectRawSourceClassSelectors(source);
for (const classSet of generatedClassSets) for (const candidate of classSet) if (selectors.has(candidate)) return true;
return false;
}
function hasUsableWebpackGeneratorCssSources(cssSources) {
return Array.isArray(cssSources) && cssSources.some((source) => typeof source?.css === "string" && source.css.length > 0);
}
function normalizeWebpackGeneratorCssSources(cssSources) {
if (!Array.isArray(cssSources)) return;
const normalized = cssSources.filter((source) => typeof source?.css === "string" && source.css.length > 0);
return normalized.length > 0 ? normalized : void 0;
}
function scopeWebpackGeneratorOptionsToCssSource(compilerOptions, sourceFile, options = {}) {
const withoutCssEntries = () => ({
...compilerOptions,
...compilerOptions.cssEntries?.length ? { cssEntries: [] } : {},
tailwindcss: {
...compilerOptions.tailwindcss,
v4: {
...compilerOptions.tailwindcss?.v4,
...compilerOptions.tailwindcss?.v4?.cssEntries?.length || compilerOptions.cssEntries?.length ? { cssEntries: [] } : {}
}
}
});
if (!sourceFile) {
if (options.disableUnmatchedCssEntries !== true) return compilerOptions;
if (!compilerOptions.cssEntries?.length && !compilerOptions.tailwindcss?.v4?.cssEntries?.length) return compilerOptions;
return withoutCssEntries();
}
const resolvedSourceFile = path.resolve(sourceFile);
if (options.disableUnmatchedCssEntries === true) {
const configuredEntries = [...compilerOptions.cssEntries ?? [], ...compilerOptions.tailwindcss?.v4?.cssEntries ?? []];
if (configuredEntries.length > 0 && !configuredEntries.some((entry) => path.resolve(entry) === resolvedSourceFile)) return withoutCssEntries();
}
const cssEntries = compilerOptions.cssEntries?.filter((entry) => path.resolve(entry) === resolvedSourceFile);
const runtimeCssEntries = compilerOptions.tailwindcss?.v4?.cssEntries?.filter((entry) => path.resolve(entry) === resolvedSourceFile);
const hasScopedCssEntries = Boolean(cssEntries?.length);
const hasScopedRuntimeCssEntries = Boolean(runtimeCssEntries?.length);
if (!hasScopedCssEntries && !hasScopedRuntimeCssEntries) return compilerOptions;
return {
...compilerOptions,
...hasScopedCssEntries ? { cssEntries } : {},
tailwindcss: {
...compilerOptions.tailwindcss,
v4: {
...compilerOptions.tailwindcss?.v4,
...hasScopedRuntimeCssEntries ? { cssEntries: runtimeCssEntries } : hasScopedCssEntries ? { cssEntries } : {}
}
}
};
}
function hasProcessedCssAssetUrl(css) {
return /url\(\s*["']?data:/i.test(css);
}
function shouldUseWebpackAssetAsGeneratorUserCss(rawSource, generatorRawSource, options = {}) {
const rawMarkers = collectWebpackAssetUserCssMarkers(rawSource);
return rawSource !== generatorRawSource && (options.processed === true || !rawSource.includes("data:")) && !hasTailwindRootDirectives(rawSource, { importFallback: true }) && !hasTailwindSourceDirectives(rawSource, { importFallback: true }) && !hasTailwindApplyDirective(rawSource) && rawMarkers.size > 0 && !isOnlyWebpackTailwindGeneratedPreflightCss(rawSource) && (!hasTailwindGeneratedCssMarkers(rawSource) || hasAdditionalWebpackAssetUserCssMarkers(rawSource, generatorRawSource));
}
function hasWebpackClassSelector(selector) {
return /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i.test(selector);
}
function isWebpackKeyframesRule(rule) {
let parent = rule.parent;
while (parent) {
if (parent.type === "atrule" && parent.name.endsWith("keyframes")) return true;
parent = parent.parent;
}
return false;
}
function collectWebpackBareSelectorUserCss(source) {
try {
const normalizedSource = removeTailwindSourceDirectives(stripTailwindSourceMediaFragments(removeTailwindV4GeneratorAtRules(source)), { importFallback: true });
const root = postcss.parse(normalizedSource);
let changed = false;
root.walkAtRules((rule) => {
if (rule.name === "import" || rule.name === "font-face" || rule.name.endsWith("keyframes")) {
rule.remove();
changed = true;
}
});
root.walkRules((rule) => {
if (isWebpackKeyframesRule(rule) || rule.selectors.some((selector) => hasWebpackClassSelector(selector))) {
rule.remove();
changed = true;
}
});
root.walkAtRules((rule) => {
if (rule.nodes !== void 0 && rule.nodes.length === 0) {
rule.remove();
changed = true;
}
});
return changed ? root.toString() : normalizedSource;
} catch {
return "";
}
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/user-css.ts
function isWebpackTailwindImportRequest(request) {
return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/") || request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/");
}
function removeWebpackGeneratorNonTailwindImports(source) {
if (!source?.includes("@import")) return source;
try {
const root = postcss.parse(source);
let changed = false;
root.walkAtRules("import", (rule) => {
if (isWebpackTailwindImportRequest(parseImportRequest(rule.params))) return;
rule.remove();
changed = true;
});
return changed ? root.toString() : source;
} catch {
return source;
}
}
function isWebpackCssSourceRepresentedInAsset(rawSource, sourceCss) {
if (!sourceCss || !hasWebpackTailwindSourceDirectives(sourceCss)) return false;
const sourceMarkers = collectWebpackCssRuleIdentityMarkers(sourceCss);
if (sourceMarkers.size === 0) return false;
const rawMarkers = collectWebpackCssRuleIdentityMarkers(rawSource);
for (const marker of sourceMarkers) if (!rawMarkers.has(marker)) return false;
return true;
}
function createWebpackGeneratorCssSource(file, css) {
if (!file || !css || !hasWebpackTailwindSourceDirectives(css)) return;
return {
file,
base: path.dirname(file),
css,
dependencies: [file]
};
}
function createWebpackUserCssSourceAppend(sources, generatorRawSource, currentSourceFile, shouldIncludeSource) {
const matchedSources = [];
const seen = /* @__PURE__ */ new Set();
for (const source of sources) {
const css = source.css;
if (!css || seen.has(css)) continue;
if (shouldIncludeSource && !shouldIncludeSource(source.file)) continue;
seen.add(css);
if ((source.processed === true || !css.includes("data:")) && hasAdditionalWebpackAssetUserCssMarkers(css, generatorRawSource)) matchedSources.push({
css,
file: source.file,
processed: source.processed === true
});
}
const currentFile = currentSourceFile ? path.resolve(currentSourceFile) : void 0;
const parts = matchedSources.sort((a, b) => {
const aCurrent = currentFile !== void 0 && path.resolve(a.file) === currentFile;
if (aCurrent !== (currentFile !== void 0 && path.resolve(b.file) === currentFile)) return aCurrent ? -1 : 1;
return a.file.localeCompare(b.file);
}).map((source) => source.css);
return parts.length > 0 ? {
css: parts.join("\n"),
processed: matchedSources.every((source) => source.processed)
} : void 0;
}
function createWebpackGeneratorUserCssSourceAppend(...sources) {
const parts = sources.filter((source) => source !== void 0 && source.css.trim().length > 0);
if (parts.length === 0) return;
let css = "";
const usedParts = [];
for (const source of parts) {
const merged = css.trim().length > 0 ? mergeCoveredCssRuleDeclarations(css, source.css) : void 0;
if (merged?.changed) css = merged.baseCss;
const nextCss = css.trim().length > 0 ? filterExistingCssRules(css, merged?.css ?? source.css) : source.css;
if (!(nextCss.trim().length > 0)) continue;
css = createCssSourceOrderAppend(css, nextCss);
usedParts.push(source);
}
return {
css,
processed: usedParts.every((source) => source.processed)
};
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/css-source-resolvers.ts
function normalizeWebpackCssSourceRef(file) {
return file.replaceAll("\\", "/");
}
function collectWebpackCssTokenSourceRefs(source) {
const refs = /* @__PURE__ */ new Set();
for (const line of source.split("\n")) {
if (!line.includes("/* tokens:") || !line.includes("<=")) continue;
const traceStart = line.indexOf("<=");
const traceEnd = line.indexOf("*/", traceStart);
const trace = line.slice(traceStart + 2, traceEnd >= 0 ? traceEnd : void 0);
for (const segment of trace.split("|")) {
const sourceList = segment.replace(/^[^<]*<=\s*/, "").split(",");
for (const ref of sourceList) {
const normalizedRef = ref.trim();
if (normalizedRef) refs.add(normalizeWebpackCssSourceRef(normalizedRef));
}
}
}
return refs;
}
function readWebpackCompilationAssetSource(compilation, file) {
const source = compilation.getAsset?.(file)?.source?.source?.();
if (source === void 0) return;
return typeof source === "string" ? source : source.toString();
}
function resolveWebpackCssImportFile(file, request) {
if (/^(?:https?:)?\/\//i.test(request) || request.startsWith("/")) return;
if (!/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(request)) return;
const cleanRequest = request.replace(/[?#].*$/, "");
return normalizeWebpackCssSourceRef(path.posix.join(path.posix.dirname(normalizeWebpackCssSourceRef(file)), cleanRequest));
}
function collectCssImportRequests(source) {
return [...source.matchAll(/@import\s+(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s;)]+))/g)].map((match) => match[1] ?? match[2] ?? match[3]).filter((request) => typeof request === "string" && request.length > 0);
}
function collectMainImportedCssFiles(compilation, cssAssetFiles, cssMatcher, isMainCssFile) {
const files = /* @__PURE__ */ new Set();
const candidates = new Set(cssAssetFiles);
for (const chunk of compilation.chunks) for (const file of chunk.files ?? []) candidates.add(file);
for (const file of candidates) {
if (!cssMatcher(file) || !isMainCssFile(file)) continue;
const source = readWebpackCompilationAssetSource(compilation, file);
if (!source?.includes("@import")) continue;
for (const request of collectCssImportRequests(source)) {
const importedFile = resolveWebpackCssImportFile(file, request);
if (importedFile) files.add(importedFile);
}
}
return files;