weapp-tailwindcss 5.1.16 → 5.2.1

package/dist/source-candidate-scan-signature-CzrG7nGp.cjs

@@ -0,0 +1,555 @@
+const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
+const require_framework = require("./framework.cjs");
+const require_generator = require("./generator-BE34PYSC.cjs");
+require("./auto-DtU6f3X6.cjs");
+const require_options = require("./options-hVsoTfwL.cjs");
+const require_v4_generation_core = require("./v4-generation-core-BrCR6ic8.cjs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_module = require("node:module");
+let weapp_style_injector_vite = require("weapp-style-injector/vite");
+let weapp_style_injector_vite_taro = require("weapp-style-injector/vite/taro");
+let weapp_style_injector_vite_uni_app = require("weapp-style-injector/vite/uni-app");
+let weapp_style_injector_webpack = require("weapp-style-injector/webpack");
+let weapp_style_injector_webpack_mpx = require("weapp-style-injector/webpack/mpx");
+let weapp_style_injector_webpack_taro = require("weapp-style-injector/webpack/taro");
+let weapp_style_injector_webpack_uni_app = require("weapp-style-injector/webpack/uni-app");
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+//#region src/bundlers/framework-selector.ts
+function resolveBundlerAppType(options) {
+	if (options.appType) return options.appType;
+	return require_framework.detectAppType({
+		cwd: options.cwd,
+		detectEnv: options.detectEnv,
+		env: options.env,
+		manifest: options.manifest,
+		packageJson: options.packageJson,
+		root: options.root,
+		searchUp: options.searchUp
+	});
+}
+function isUniAppXFramework(appType, uniAppX) {
+	return appType === "uni-app-x" || require_options.resolveUniAppXOptions(uniAppX).enabled;
+}
+function resolveViteFrameworkProfile(options) {
+	const appType = resolveBundlerAppType(options);
+	if (isUniAppXFramework(appType, options.uniAppX)) return {
+		appType,
+		frameworkName: "uni-app-x"
+	};
+	if (appType === "uni-app" || appType === "uni-app-vite") return {
+		appType,
+		frameworkName: "uni-app"
+	};
+	if (appType === "taro") return {
+		appType,
+		frameworkName: "taro"
+	};
+	if (appType === "weapp-vite") return {
+		appType,
+		frameworkName: "weapp-vite"
+	};
+	return {
+		appType,
+		frameworkName: "generic"
+	};
+}
+function resolveWebpackFrameworkProfile(options) {
+	const appType = resolveBundlerAppType(options);
+	if (appType === "mpx") return {
+		appType,
+		frameworkName: "mpx"
+	};
+	if (appType === "taro") return {
+		appType,
+		frameworkName: "taro"
+	};
+	if (appType === "uni-app" || appType === "uni-app-vite" || isUniAppXFramework(appType, options.uniAppX)) return {
+		appType,
+		frameworkName: "uni-app"
+	};
+	if (appType === "weapp-vite") return {
+		appType,
+		frameworkName: "weapp-vite"
+	};
+	return {
+		appType,
+		frameworkName: "generic"
+	};
+}
+//#endregion
+//#region src/style-injector/options.ts
+function normalizeStyleInjectorOptions(options) {
+	if (options === true) return {};
+	if (!options) return;
+	return options;
+}
+//#endregion
+//#region src/style-injector/internal.ts
+function toPluginArray(pluginOrPlugins) {
+	return Array.isArray(pluginOrPlugins) ? pluginOrPlugins : [pluginOrPlugins];
+}
+function normalizeWebpackStyleInjectorOptions(options) {
+	const normalized = normalizeStyleInjectorOptions(options);
+	if (!normalized) return;
+	const { generateSubpackageStyle, loadSubpackageTargetStyle, ...rest } = normalized;
+	const webpackOptions = { ...rest };
+	if (generateSubpackageStyle) webpackOptions.generateSubpackageStyle = (context) => {
+		const generated = generateSubpackageStyle(context);
+		if (generated && typeof generated.then === "function") throw new TypeError("[weapp-style-injector] Webpack subpackage style generators must return synchronously.");
+		return generated;
+	};
+	if (loadSubpackageTargetStyle) webpackOptions.loadSubpackageTargetStyle = (fileName, sourceAbsolutePath) => {
+		const loaded = loadSubpackageTargetStyle(fileName, sourceAbsolutePath);
+		if (loaded && typeof loaded.then === "function") throw new TypeError("[weapp-style-injector] Webpack subpackage target style loaders must return synchronously.");
+		return loaded;
+	};
+	return webpackOptions;
+}
+function getTransformHandler(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && typeof hook === "object" && typeof hook.handler === "function") return hook.handler;
+}
+function getGenerateBundleHandler(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && typeof hook === "object" && typeof hook.handler === "function") return hook.handler;
+}
+const viteStyleInjectorDelegates = {
+	generic: ((options) => [(0, weapp_style_injector_vite.weappStyleInjector)(options)]),
+	taro: ((options) => toPluginArray((0, weapp_style_injector_vite_taro.StyleInjector)(options))),
+	uniApp: ((options) => toPluginArray((0, weapp_style_injector_vite_uni_app.StyleInjector)(options)))
+};
+const webpackStyleInjectorDelegates = {
+	generic: ((options) => (0, weapp_style_injector_webpack.weappStyleInjectorWebpack)(options)),
+	mpx: ((options) => (0, weapp_style_injector_webpack_mpx.StyleInjector)(options)),
+	taro: ((options) => (0, weapp_style_injector_webpack_taro.StyleInjector)(options)),
+	uniApp: ((options) => (0, weapp_style_injector_webpack_uni_app.StyleInjector)(options))
+};
+function createBuiltinViteStyleInjectorPlugins(options, getDelegateFactory) {
+	const normalized = normalizeStyleInjectorOptions(options);
+	if (!normalized) return [];
+	let config;
+	let delegates;
+	let delegatesConfigured = false;
+	let delegatesBuildStarted = false;
+	const resolveDelegates = () => {
+		if (delegates) return delegates;
+		delegates = getDelegateFactory()(normalized);
+		return delegates;
+	};
+	const configureDelegates = async () => {
+		if (delegatesConfigured || !config) return;
+		delegatesConfigured = true;
+		for (const plugin of resolveDelegates()) if (typeof plugin.configResolved === "function") await plugin.configResolved(config);
+	};
+	const startDelegates = async (context) => {
+		if (delegatesBuildStarted) return;
+		await configureDelegates();
+		delegatesBuildStarted = true;
+		for (const plugin of resolveDelegates()) if (typeof plugin.buildStart === "function") await plugin.buildStart.call(context, {});
+	};
+	return [{
+		name: "weapp-tailwindcss:style-injector-pre",
+		apply: "build",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		async buildStart() {
+			await startDelegates(this);
+		},
+		async load(id, options) {
+			await configureDelegates();
+			for (const plugin of resolveDelegates()) {
+				if (typeof plugin.load !== "function") continue;
+				const result = await plugin.load.call(this, id, options);
+				if (result != null) return result;
+			}
+		},
+		async transform(code, id, options) {
+			await configureDelegates();
+			let currentCode = code;
+			let changed = false;
+			for (const plugin of resolveDelegates()) {
+				const handler = getTransformHandler(plugin.transform);
+				if (!handler) continue;
+				const result = await handler.call(this, currentCode, id, options);
+				if (!result) continue;
+				if (typeof result === "string") {
+					currentCode = result;
+					changed = true;
+				} else if (typeof result === "object" && typeof result.code === "string") {
+					currentCode = result.code;
+					changed = true;
+				}
+			}
+			if (changed) return {
+				code: currentCode,
+				map: null
+			};
+		}
+	}, {
+		name: "weapp-tailwindcss:style-injector",
+		apply: "build",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		async generateBundle(outputOptions, bundle, isWrite) {
+			await configureDelegates();
+			for (const plugin of resolveDelegates()) {
+				const handler = getGenerateBundleHandler(plugin.generateBundle);
+				if (!handler) continue;
+				await handler.call(this, outputOptions, bundle, isWrite);
+			}
+		}
+	}];
+}
+function createBuiltinWebpackStyleInjectorPlugin(options, delegateFactory) {
+	const normalized = normalizeWebpackStyleInjectorOptions(options);
+	if (!normalized) return;
+	return delegateFactory(normalized);
+}
+//#endregion
+//#region src/bundlers/shared/module-graph.ts
+const QUERY_HASH_RE = /[?#].*$/u;
+const PROTOCOL_RE = /^[a-z][a-z+.-]*:/iu;
+const WINDOWS_ABSOLUTE_RE = /^[a-z]:[\\/]/iu;
+const VIRTUAL_PREFIX = "\0";
+const JS_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+function normalizeOutputPathKey(value) {
+	return node_path.default.normalize(value).replace(/\\/g, "/");
+}
+function stripQueryAndHash(specifier) {
+	return specifier.replace(QUERY_HASH_RE, "");
+}
+function isResolvableSpecifier(specifier) {
+	if (!specifier) return false;
+	const normalized = stripQueryAndHash(specifier);
+	if (normalized.startsWith(VIRTUAL_PREFIX)) return false;
+	if (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) return true;
+	return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+	if (node_path.default.isAbsolute(fileName) || WINDOWS_ABSOLUTE_RE.test(fileName)) return node_path.default.normalize(fileName);
+	return node_path.default.resolve(outDir, fileName);
+}
+function matchWithExtensions(candidate, hasOutput) {
+	if (hasOutput(candidate)) return candidate;
+	if (!node_path.default.extname(candidate)) for (const ext of JS_EXTENSIONS) {
+		const extended = `${candidate}${ext}`;
+		if (hasOutput(extended)) return extended;
+	}
+}
+function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
+	if (!isResolvableSpecifier(specifier)) return;
+	const normalized = stripQueryAndHash(specifier);
+	let candidate;
+	if (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) candidate = node_path.default.normalize(normalized);
+	else if (normalized.startsWith("/")) candidate = node_path.default.resolve(outDir, normalized.slice(1));
+	else candidate = node_path.default.resolve(node_path.default.dirname(importer), normalized);
+	return matchWithExtensions(candidate, hasOutput);
+}
+//#endregion
+//#region src/utils/disabled.ts
+function resolvePluginDisabledState(disabled) {
+	if (disabled === true) return { plugin: true };
+	if (disabled === false || disabled == null) return { plugin: false };
+	return { plugin: disabled.plugin ?? false };
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function resolvePackageDir(name) {
+	const pkgPath = require$1.resolve(`${name}/package.json`);
+	return node_path.default.dirname(pkgPath);
+}
+//#endregion
+//#region src/bundlers/shared/runtime-entry-type.ts
+const CSS_REQUEST_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\?)/;
+const HTML_REQUEST_RE = /\.html?(?:$|\?)/;
+function classifyRuntimeEntry(file, matchers) {
+	if (matchers.htmlMatcher(file) || HTML_REQUEST_RE.test(file)) return "html";
+	if (matchers.cssMatcher(file) || CSS_REQUEST_RE.test(file) || require_v4_generation_core.isSourceStyleRequest(file)) return "css";
+	if (matchers.jsMatcher(file) || matchers.wxsMatcher(file)) return "js";
+	return "other";
+}
+//#endregion
+//#region src/bundlers/shared/runtime-signatures.ts
+function summarizeStringDiff(previous, next) {
+	if (previous === next) return "same";
+	const previousLength = previous.length;
+	const nextLength = next.length;
+	const minLength = Math.min(previousLength, nextLength);
+	let prefixLength = 0;
+	while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) prefixLength += 1;
+	let previousSuffixCursor = previousLength - 1;
+	let nextSuffixCursor = nextLength - 1;
+	while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+		previousSuffixCursor -= 1;
+		nextSuffixCursor -= 1;
+	}
+	const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+	const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+	return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+	const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+	if (!changedLinkedFiles || changedLinkedFiles.size === 0) return;
+	return [...changedLinkedFiles].sort().map((file) => {
+		return `${file}:${sourceHashByFile.get(file) ?? "missing"}`;
+	}).join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+	if (!linkedImpactSignature) return runtimeSignature;
+	return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
+function createStableTextSignature(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function createCandidateSignature(candidates) {
+	if (candidates.size === 0) return "empty";
+	return createStableTextSignature([...candidates].sort().join("\n"));
+}
+function getSnapshotHash(snapshotMap, file, fallback) {
+	return snapshotMap.get(file) ?? fallback;
+}
+function hasRuntimeAffectingSourceChanges(changedByType) {
+	return changedByType.html.size > 0 || changedByType.js.size > 0;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/scoped-generator.ts
+function hasOwnSourceDirectives(rawSource) {
+	return rawSource.includes("@source") || rawSource.includes("@config");
+}
+function createLocalSourceEntries(sourceFile) {
+	return [{
+		base: node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, ""))),
+		negated: false,
+		pattern: "**/*"
+	}];
+}
+function intersectCandidates(first, second) {
+	if (first.size === 0 || second.size === 0) return /* @__PURE__ */ new Set();
+	const [small, large] = first.size <= second.size ? [first, second] : [second, first];
+	const scoped = /* @__PURE__ */ new Set();
+	for (const candidate of small) if (large.has(candidate)) scoped.add(candidate);
+	return scoped;
+}
+function mergeCandidates(first, second) {
+	return /* @__PURE__ */ new Set([...first, ...second]);
+}
+function canFallbackToOutputCandidates(rawSource, entries) {
+	return rawSource.includes("@source") && entries.length > 0 && entries.every((entry) => !entry.negated);
+}
+function resolveScopedSourceEntries(rawSource, sourceFile, resolvedEntries) {
+	if (!hasOwnSourceDirectives(rawSource)) return {
+		entries: resolvedEntries,
+		localEntries: void 0
+	};
+	if (resolvedEntries !== void 0) return { entries: resolvedEntries };
+	return { entries: createLocalSourceEntries(sourceFile) };
+}
+async function resolveScopedGeneratorSourceEntries(rawSource, sourceFile) {
+	return resolveScopedSourceEntries(rawSource, sourceFile, (await require_options.resolveTailwindV4EntriesFromCssCached(rawSource, node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, "")))))?.entries);
+}
+async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
+	if (!getSourceCandidatesForEntries || !hasOwnSourceDirectives(rawSource)) return fallbackSignature;
+	const { entries } = await resolveScopedGeneratorSourceEntries(rawSource, sourceFile);
+	if (entries === void 0) return fallbackSignature;
+	const scopedSignature = createCandidateSignature(getSourceCandidatesForEntries(entries));
+	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
+}
+async function createScopedGeneratorSourceTraceMap(rawSource, sourceFile, getSourceCandidateSourcesForEntries) {
+	if (!getSourceCandidateSourcesForEntries || !hasOwnSourceDirectives(rawSource)) return getSourceCandidateSourcesForEntries?.(void 0);
+	const { entries } = await resolveScopedGeneratorSourceEntries(rawSource, sourceFile);
+	if (entries === void 0) return getSourceCandidateSourcesForEntries(void 0);
+	return getSourceCandidateSourcesForEntries(entries);
+}
+async function createScopedGeneratorRuntime(options) {
+	const { cssHandlerOptions, fallbackRuntime, getSourceCandidatesForEntries, outputFile, rawSource, shouldExcludeSubpackageSourceCandidates, sourceFile, scopedSourceCandidateGetter } = options;
+	if (getSourceCandidatesForEntries && rawSource && sourceFile) {
+		const { entries } = await resolveScopedGeneratorSourceEntries(rawSource, sourceFile);
+		if (entries !== void 0 && (entries.length > 0 || hasOwnSourceDirectives(rawSource))) {
+			const explicitCandidates = getSourceCandidatesForEntries(entries);
+			const outputCandidates = scopedSourceCandidateGetter?.(void 0);
+			const scopedCandidates = outputCandidates ? explicitCandidates.size === 0 && canFallbackToOutputCandidates(rawSource, entries) ? outputCandidates : intersectCandidates(explicitCandidates, outputCandidates) : explicitCandidates;
+			return (0, _weapp_tailwindcss_postcss.hasCssMacroTailwindV4CustomVariantConditionalComments)(rawSource) ? mergeCandidates(scopedCandidates, fallbackRuntime) : scopedCandidates;
+		}
+	}
+	const scopedCandidates = scopedSourceCandidateGetter?.(void 0);
+	if (scopedCandidates && (scopedCandidates.size > 0 || shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions))) return shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions) ? scopedCandidates : mergeCandidates(scopedCandidates, fallbackRuntime);
+	if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return fallbackRuntime;
+	return fallbackRuntime;
+}
+//#endregion
+//#region src/bundlers/shared/source-candidate-scan-signature.ts
+function normalizeSignaturePath(value) {
+	return require_generator.toPosixPath(node_path.default.resolve(value));
+}
+function serializeInlineCandidates(inlineCandidates) {
+	return {
+		excluded: [...inlineCandidates?.excluded ?? []].sort(),
+		included: [...inlineCandidates?.included ?? []].sort()
+	};
+}
+function serializeSourceEntries(entries) {
+	return (entries ?? []).map((entry) => ({
+		base: normalizeSignaturePath(entry.base),
+		negated: entry.negated,
+		pattern: entry.pattern
+	})).sort((a, b) => `${a.base}\0${a.pattern}\0${a.negated}`.localeCompare(`${b.base}\0${b.pattern}\0${b.negated}`));
+}
+function createSourceCandidateScanSignature(input) {
+	return JSON.stringify({
+		inlineCandidates: serializeInlineCandidates(input.inlineCandidates),
+		outDir: input.outDir ? normalizeSignaturePath(input.outDir) : void 0,
+		roots: input.roots.map((root) => ({
+			entries: serializeSourceEntries(root.entries),
+			root: normalizeSignaturePath(root.root)
+		})),
+		scanAllSources: input.scanAllSources ?? false
+	});
+}
+//#endregion
+Object.defineProperty(exports, "classifyRuntimeEntry", {
+	enumerable: true,
+	get: function() {
+		return classifyRuntimeEntry;
+	}
+});
+Object.defineProperty(exports, "createBuiltinViteStyleInjectorPlugins", {
+	enumerable: true,
+	get: function() {
+		return createBuiltinViteStyleInjectorPlugins;
+	}
+});
+Object.defineProperty(exports, "createBuiltinWebpackStyleInjectorPlugin", {
+	enumerable: true,
+	get: function() {
+		return createBuiltinWebpackStyleInjectorPlugin;
+	}
+});
+Object.defineProperty(exports, "createCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createJsHashSalt", {
+	enumerable: true,
+	get: function() {
+		return createJsHashSalt;
+	}
+});
+Object.defineProperty(exports, "createLinkedImpactSignature", {
+	enumerable: true,
+	get: function() {
+		return createLinkedImpactSignature;
+	}
+});
+Object.defineProperty(exports, "createScopedGeneratorCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createScopedGeneratorRuntime", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorRuntime;
+	}
+});
+Object.defineProperty(exports, "createScopedGeneratorSourceTraceMap", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorSourceTraceMap;
+	}
+});
+Object.defineProperty(exports, "createSourceCandidateScanSignature", {
+	enumerable: true,
+	get: function() {
+		return createSourceCandidateScanSignature;
+	}
+});
+Object.defineProperty(exports, "getSnapshotHash", {
+	enumerable: true,
+	get: function() {
+		return getSnapshotHash;
+	}
+});
+Object.defineProperty(exports, "hasRuntimeAffectingSourceChanges", {
+	enumerable: true,
+	get: function() {
+		return hasRuntimeAffectingSourceChanges;
+	}
+});
+Object.defineProperty(exports, "normalizeOutputPathKey", {
+	enumerable: true,
+	get: function() {
+		return normalizeOutputPathKey;
+	}
+});
+Object.defineProperty(exports, "resolveOutputSpecifier", {
+	enumerable: true,
+	get: function() {
+		return resolveOutputSpecifier;
+	}
+});
+Object.defineProperty(exports, "resolvePackageDir", {
+	enumerable: true,
+	get: function() {
+		return resolvePackageDir;
+	}
+});
+Object.defineProperty(exports, "resolvePluginDisabledState", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginDisabledState;
+	}
+});
+Object.defineProperty(exports, "resolveViteFrameworkProfile", {
+	enumerable: true,
+	get: function() {
+		return resolveViteFrameworkProfile;
+	}
+});
+Object.defineProperty(exports, "resolveWebpackFrameworkProfile", {
+	enumerable: true,
+	get: function() {
+		return resolveWebpackFrameworkProfile;
+	}
+});
+Object.defineProperty(exports, "summarizeStringDiff", {
+	enumerable: true,
+	get: function() {
+		return summarizeStringDiff;
+	}
+});
+Object.defineProperty(exports, "toAbsoluteOutputPath", {
+	enumerable: true,
+	get: function() {
+		return toAbsoluteOutputPath;
+	}
+});
+Object.defineProperty(exports, "viteStyleInjectorDelegates", {
+	enumerable: true,
+	get: function() {
+		return viteStyleInjectorDelegates;
+	}
+});
+Object.defineProperty(exports, "webpackStyleInjectorDelegates", {
+	enumerable: true,
+	get: function() {
+		return webpackStyleInjectorDelegates;
+	}
+});

package/dist/style-injector/internal.d.ts

@@ -1,14 +1,14 @@
 import type { Plugin } from 'vite';
 import type { WebpackObjectPluginInstance, WebpackWeappStyleInjectorOptions } from 'weapp-style-injector/webpack';
-import type { WeappTailwindcssStyleInjectorUserOptions } from './options';
-import { normalizeStyleInjectorOptions } from './options';
+import type { WeappTailwindcssStyleInjectorUserOptions } from './options.js';
+import { normalizeStyleInjectorOptions } from './options.js';
 export type ViteStyleInjectorDelegateFactory = (options: NonNullable<ReturnType<typeof normalizeStyleInjectorOptions>>) => Plugin[];
 export type WebpackStyleInjectorDelegateFactory = (options: NonNullable<ReturnType<typeof normalizeWebpackStyleInjectorOptions>>) => WebpackObjectPluginInstance;
 declare function normalizeWebpackStyleInjectorOptions(options: WeappTailwindcssStyleInjectorUserOptions | undefined): WebpackWeappStyleInjectorOptions | undefined;
 export declare const viteStyleInjectorDelegates: {
-    generic: (options: import("./options").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
-    taro: (options: import("./options").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
-    uniApp: (options: import("./options").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
+    generic: (options: import("./options.js").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
+    taro: (options: import("./options.js").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
+    uniApp: (options: import("./options.js").WeappTailwindcssStyleInjectorOptions) => Plugin<any>[];
 };
 export declare const webpackStyleInjectorDelegates: {
     generic: (options: WebpackWeappStyleInjectorOptions) => WebpackObjectPluginInstance;
@@ -18,4 +18,4 @@ export declare const webpackStyleInjectorDelegates: {
 };
 export declare function createBuiltinViteStyleInjectorPlugins(options: WeappTailwindcssStyleInjectorUserOptions | undefined, getDelegateFactory: () => ViteStyleInjectorDelegateFactory): Plugin[];
 export declare function createBuiltinWebpackStyleInjectorPlugin(options: WeappTailwindcssStyleInjectorUserOptions | undefined, delegateFactory: WebpackStyleInjectorDelegateFactory): WebpackObjectPluginInstance | undefined;
-export type { WeappTailwindcssStyleInjectorOptions, WeappTailwindcssStyleInjectorUserOptions } from './options';
+export type { WeappTailwindcssStyleInjectorOptions, WeappTailwindcssStyleInjectorUserOptions } from './options.js';

package/dist/style-options-B_ppaVIg.cjs

@@ -0,0 +1,77 @@
+const require_generator = require("./generator-BE34PYSC.cjs");
+const require_options = require("./options-hVsoTfwL.cjs");
+//#region src/context/style-options.ts
+function normalizeStyleHandlerMajorVersion(majorVersion) {
+	return majorVersion === 4 ? 4 : void 0;
+}
+function resolveStyleOptionsFromContext(ctx, tailwindcssMajorVersion) {
+	const resolvedUniAppXOptions = require_options.resolveUniAppXOptions(ctx.uniAppX);
+	const branch = require_generator.resolveGeneratorRuntimeBranch(require_generator.normalizeWeappTailwindcssGeneratorOptions(ctx.generator, {
+		appType: ctx.appType,
+		platform: ctx.cssOptions?.platform ?? ctx.platform,
+		tailwindcssMajorVersion,
+		uniAppX: resolvedUniAppXOptions
+	}), {
+		appType: ctx.appType,
+		platform: ctx.cssOptions?.platform ?? ctx.platform,
+		tailwindcssMajorVersion,
+		uniAppX: resolvedUniAppXOptions
+	});
+	const hasCssOptions = ctx.cssOptions !== void 0;
+	const configuredRem2rpx = ctx.cssOptions?.rem2rpx ?? ctx.rem2rpx;
+	const rem2rpx = branch.isWeb && require_generator.shouldUseUniAppWebRpxCompatibility(ctx.appType) ? false : configuredRem2rpx;
+	const cssOptions = {
+		cssPreflight: ctx.cssOptions?.cssPreflight ?? ctx.cssPreflight,
+		cssPreflightRange: ctx.cssOptions?.cssPreflightRange ?? ctx.cssPreflightRange,
+		cssChildCombinatorReplaceValue: ctx.cssOptions?.cssChildCombinatorReplaceValue ?? ctx.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: ctx.cssOptions?.cssSelectorReplacement ?? ctx.cssSelectorReplacement,
+		rem2rpx,
+		cssRemoveProperty: ctx.cssOptions?.cssRemoveProperty ?? ctx.cssRemoveProperty,
+		cssRemoveHoverPseudoClass: ctx.cssOptions?.cssRemoveHoverPseudoClass ?? ctx.cssRemoveHoverPseudoClass,
+		tailwindcssV4GradientFallback: ctx.cssOptions?.tailwindcssV4GradientFallback ?? ctx.tailwindcssV4GradientFallback,
+		cssPresetEnv: ctx.cssOptions?.cssPresetEnv ?? ctx.cssPresetEnv,
+		atRules: ctx.cssOptions?.atRules ?? ctx.atRules,
+		autoprefixer: ctx.cssOptions?.autoprefixer ?? ctx.autoprefixer,
+		cssCalc: ctx.cssOptions?.cssCalc ?? ctx.cssCalc,
+		platform: branch.platform ?? ctx.cssOptions?.platform ?? ctx.platform,
+		px2rpx: ctx.cssOptions?.px2rpx ?? ctx.px2rpx,
+		unitsToPx: ctx.cssOptions?.unitsToPx ?? ctx.unitsToPx,
+		unitConversion: ctx.cssOptions?.unitConversion ?? ctx.unitConversion,
+		injectAdditionalCssVarScope: ctx.cssOptions?.injectAdditionalCssVarScope ?? ctx.injectAdditionalCssVarScope
+	};
+	return {
+		appType: ctx.appType,
+		postcssOptions: ctx.postcssOptions,
+		cssPreflight: cssOptions.cssPreflight,
+		cssPreflightRange: cssOptions.cssPreflightRange,
+		cssChildCombinatorReplaceValue: cssOptions.cssChildCombinatorReplaceValue,
+		cssSelectorReplacement: cssOptions.cssSelectorReplacement,
+		rem2rpx: cssOptions.rem2rpx,
+		...hasCssOptions ? { cssOptions } : {},
+		cssRemoveProperty: cssOptions.cssRemoveProperty,
+		cssRemoveHoverPseudoClass: cssOptions.cssRemoveHoverPseudoClass,
+		tailwindcssV4GradientFallback: cssOptions.tailwindcssV4GradientFallback,
+		cssPresetEnv: cssOptions.cssPresetEnv,
+		atRules: cssOptions.atRules,
+		autoprefixer: cssOptions.autoprefixer,
+		cssCalc: cssOptions.cssCalc,
+		uniAppX: branch.isNativeApp,
+		platform: cssOptions.platform,
+		px2rpx: cssOptions.px2rpx,
+		unitsToPx: cssOptions.unitsToPx,
+		unitConversion: cssOptions.unitConversion
+	};
+}
+//#endregion
+Object.defineProperty(exports, "normalizeStyleHandlerMajorVersion", {
+	enumerable: true,
+	get: function() {
+		return normalizeStyleHandlerMajorVersion;
+	}
+});
+Object.defineProperty(exports, "resolveStyleOptionsFromContext", {
+	enumerable: true,
+	get: function() {
+		return resolveStyleOptionsFromContext;
+	}
+});

package/dist/tailwindcss/candidates.d.ts

@@ -1,5 +1,5 @@
-import type { ICustomAttributesEntities } from '../types';
-import type { IArbitraryValues } from '../types/shared';
+import type { ICustomAttributesEntities } from '../types/index.js';
+import type { IArbitraryValues } from '../types/shared.js';
 export interface SourceCandidateExtractionOptions {
     bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
     customAttributesEntities?: ICustomAttributesEntities | undefined;

package/dist/tailwindcss/index.d.ts

@@ -1,6 +1,6 @@
 import type { PackageResolvingOptions } from 'local-pkg';
 import type { PackageJson } from 'pkg-types';
-import { createTailwindcssRuntime } from './runtime-factory';
+import { createTailwindcssRuntime } from './runtime-factory.js';
 declare function getTailwindcssPackageInfo(options?: PackageResolvingOptions): {
     name: string;
     version: string | undefined;

package/dist/tailwindcss/runtime/cache.d.ts

@@ -1,4 +1,4 @@
-import type { TailwindcssRuntimeLike } from '../../types';
+import type { TailwindcssRuntimeLike } from '../../types/index.js';
 interface RuntimeClassSetCacheEntry {
     value?: Set<string> | undefined;
     promise?: Promise<Set<string>> | undefined;