weapp-tailwindcss 5.5.5 → 5.5.7

package/dist/generation/candidates.d.ts

@@ -0,0 +1 @@
+export { collectCssApplyCandidates, collectGeneratorCssCandidates } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/class-selectors.d.ts

@@ -0,0 +1,4 @@
+import { collectRawSourceClassSelectors } from '@weapp-tailwindcss/postcss/transform';
+export { collectRawSourceClassSelectors };
+export declare function collectGeneratedRawSourceCandidates(candidates: Iterable<string>, rawSource: string, escapeMap: Record<string, string> | undefined): Set<string>;
+export declare function collectGeneratedRawSourceCandidatesFromCss(candidates: Iterable<string>, cssSources: Iterable<string>, escapeMap: Record<string, string> | undefined): Set<string>;

package/dist/generation/config-directive.d.ts

@@ -0,0 +1 @@
+export { normalizeConfigDirective, prependConfigDirective } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/directives/fallback.d.ts

@@ -0,0 +1 @@
+export { extractConfigRequestFromSource, extractTailwindDirectiveLines, extractTailwindSourceForPostcssFallback, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/directives.d.ts

@@ -0,0 +1 @@
+export { hasLocalCssImport, hasTailwindApplyDirective, hasTailwindNonRootGenerationDirectives, hasTailwindRootDirectives, hasTailwindRootImportDirectives, hasTailwindSourceDirectives, normalizeTailwindConfigDirectives, normalizeTailwindSourceDirectives, normalizeTailwindSourceForGenerator, parseImportRequest, removeTailwindSourceDirectives, resolveCssEntrySource, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/framework-css-composition.d.ts

@@ -0,0 +1 @@
+export { composeFrameworkProcessedCss } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/framework-postcss.d.ts

@@ -0,0 +1,25 @@
+import type { LoadedPostcssOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GenerateCssByGeneratorResult } from './index.js';
+import type { GenerationStyleHandlerOptions as IStyleHandlerOptions } from './style-options.js';
+import type { Compiler, CompilerSnapshot } from '../core/compiler/index.js';
+import type { InternalUserDefinedOptions } from '../types/index.js';
+export declare function resolveFrameworkPostcssOptions(value: unknown): LoadedPostcssOptions | undefined;
+export declare function collectFrameworkPostcssOptionsFromLoaderEntries(entries: unknown[], loaderContext?: unknown): LoadedPostcssOptions | undefined;
+export declare function captureFrameworkPostcssOptions(owner: InternalUserDefinedOptions, options: unknown): LoadedPostcssOptions | undefined;
+export declare function captureResolvedFrameworkPostcssOptions(owner: InternalUserDefinedOptions, options: LoadedPostcssOptions | undefined): LoadedPostcssOptions | undefined;
+export declare function hasFrameworkPostcssOptions(owner: InternalUserDefinedOptions): boolean;
+export declare function adaptGeneratedCssWithFrameworkPipeline(owner: InternalUserDefinedOptions, generated: GenerateCssByGeneratorResult, options: {
+    cssHandlerOptions: IStyleHandlerOptions;
+    file: string;
+    majorVersion: number;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+}): Promise<string>;
+export declare function adaptGeneratedCssWithFrameworkRootPipeline(owner: InternalUserDefinedOptions, generated: GenerateCssByGeneratorResult, options: {
+    cssHandlerOptions: IStyleHandlerOptions;
+    file: string;
+    majorVersion: number;
+    rawCandidates: Iterable<string>;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    compiler?: Compiler | undefined;
+    snapshot?: CompilerSnapshot | undefined;
+}): Promise<string>;

package/dist/generation/framework-user-css.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './index.js';
+import type { NormalizedWeappTailwindcssGeneratorOptions } from '../generator/index.js';
+import { normalizeFrameworkProcessedUserCss } from '@weapp-tailwindcss/postcss/transform';
+export { normalizeFrameworkProcessedUserCss };
+export declare function restoreFrameworkProcessedUserCss(css: string, generated: GenerateCssByGeneratorResult, source: string, options: GenerateCssByGeneratorOptions, generatorOptions: NormalizedWeappTailwindcssGeneratorOptions): Promise<string>;

package/dist/generation/generation-helpers/preflight.d.ts

@@ -0,0 +1,19 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
+export declare function hasMiniProgramTailwindV4PreflightReset(css: string): boolean;
+export declare function finalizeMiniProgramGeneratorCss(css: string, target: string, _majorVersion: number | undefined, cssPreflight: InternalUserDefinedOptions['cssPreflight'], options?: {
+    injectPreflight?: boolean | undefined;
+    preservePreflight?: boolean | undefined;
+    removeEmptyAtRuleAncestors?: boolean | undefined;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+}): string;
+export declare function resolveMiniProgramPreflightModeForGeneratorCss(opts: InternalUserDefinedOptions, options: {
+    cssHandlerOptions: IStyleHandlerOptions;
+    isolateCurrentCssCandidates: boolean;
+    localImports?: string | undefined;
+    primaryCssSource?: boolean | undefined;
+    explicitCssSource?: boolean | undefined;
+}): {
+    inject: boolean;
+    preserve: boolean;
+};

package/dist/generation/generation-helpers/results.d.ts

@@ -0,0 +1,23 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { CompilerGenerateResult, CompilerSnapshot } from '../../core/compiler/index.js';
+export declare function shouldFinalizeMarkedUserLayerComponentsCss(file: string): boolean;
+export declare function splitRawSourceByGeneratedCssOrder(rawSource: string, rawTailwindCss: string): {
+    before: string;
+    after: string;
+} | undefined;
+export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+    forceGenerator?: boolean | undefined;
+    hasGeneratedCss: boolean;
+    hasGeneratedMarkers: boolean;
+    hasSourceDirectives: boolean;
+    rawSource: string;
+    runtimeCandidateCount?: number | undefined;
+    target?: string | undefined;
+    configuredCssSourceCount?: number | undefined;
+}): boolean | undefined;
+export declare function hasGeneratorSourceDirectives(source: string, importFallback: boolean): boolean;
+export declare function createRuntimeWithCurrentCssCandidates(runtime: Set<string>, currentCssCandidates: string[], isolateCurrentCssCandidates: boolean): Set<string>;
+export declare function mergeGeneratorResults(generatedResults: GeneratorResult[]): GeneratorResult | undefined;
+export type GeneratorResult = Omit<CompilerGenerateResult, 'cache' | 'revision' | 'snapshot'> & {
+    snapshot?: CompilerSnapshot | undefined;
+};

package/dist/generation/generation-helpers/runtime-isolation.d.ts

@@ -0,0 +1,30 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRecord } from '../source-resolver.js';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan.js';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
+export declare function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime: Set<string>, runtime: Set<string>, options: {
+    currentCssCandidates?: string[] | undefined;
+    cssHandlerOptions: IStyleHandlerOptions;
+    isolateCssSource: boolean;
+    majorVersion?: number | undefined;
+    matchedCssSourceFile: boolean;
+}): Set<string>;
+export declare function shouldIsolateScopedCssSource(_majorVersion: number | undefined, record: GeneratorSourceRecord, sourceEntries: TailwindSourceEntry[] | undefined, options: {
+    cssHandlerOptions?: IStyleHandlerOptions | undefined;
+    target: string;
+}): boolean;
+export declare function shouldIsolateCurrentTailwindV4CssCandidates(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+    hasGeneratedCss: boolean;
+    hasGeneratedMarkers: boolean;
+    rawSource: string;
+}): boolean;
+export declare function shouldScanTailwindV4Sources(majorVersion: number | undefined, target: string, generatorRuntime: Set<string>, isolateCssSource: boolean): boolean;
+export declare function shouldAppendWebBundleCssFallback(target: string, _options: {
+    hasSourceDirectives: boolean;
+    hasMatchedCssSourceFile: boolean;
+}): target is "web";
+export declare function isEmptyCssSourceOrderParts(parts: {
+    before: string;
+    after: string;
+}): boolean;
+export declare function resolveGeneratorStyleOptions(opts: InternalUserDefinedOptions, cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Partial<IStyleHandlerOptions>;

package/dist/generation/generation-helpers/source-order.d.ts

@@ -0,0 +1 @@
+export { createCssSourceOrderAppend, deduplicateGeneratedCssRules } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/generation-helpers.d.ts

@@ -0,0 +1,4 @@
+export { finalizeMiniProgramGeneratorCss, hasMiniProgramTailwindV4PreflightReset, resolveMiniProgramPreflightModeForGeneratorCss } from './generation-helpers/preflight.js';
+export { createRuntimeWithCurrentCssCandidates, hasGeneratorSourceDirectives, mergeGeneratorResults, shouldFinalizeMarkedUserLayerComponentsCss, shouldUseGeneratorForCurrentCss, splitRawSourceByGeneratedCssOrder } from './generation-helpers/results.js';
+export { isEmptyCssSourceOrderParts, mergeScopedRuntimeWithCurrentRuntime, resolveGeneratorStyleOptions, shouldAppendWebBundleCssFallback, shouldIsolateCurrentTailwindV4CssCandidates, shouldIsolateScopedCssSource, shouldScanTailwindV4Sources } from './generation-helpers/runtime-isolation.js';
+export { createCssSourceOrderAppend, deduplicateGeneratedCssRules } from './generation-helpers/source-order.js';

package/dist/generation/index.d.ts

@@ -0,0 +1,9 @@
+export { hasTailwindSourceDirectives, normalizeTailwindSourceForGenerator, removeTailwindSourceDirectives, resolveCssEntrySource, } from './directives.js';
+export { removeTailwindApplyRules, } from './legacy-compat.js';
+export { inheritLegacyUnitConvertedDeclarations, } from './legacy-units.js';
+export { isPureLocalCssImportWrapper, } from './local-imports.js';
+export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './markers.js';
+export { generateCssByGenerator } from './pipeline.js';
+export { resolveGeneratorSource, } from './source-resolver.js';
+export type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult, } from './types.js';
+export { validateCandidatesByGenerator, } from './validate.js';

package/dist/generation/legacy-compat.d.ts

@@ -0,0 +1,12 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindResolvedSource } from '../generator/index.js';
+import type { InternalUserDefinedOptions } from '../types/index.js';
+import { removeTailwindApplyRules } from '@weapp-tailwindcss/postcss/transform';
+export { removeTailwindApplyRules };
+export declare function hasConfiguredContainerCompatSources(sources: TailwindResolvedSource[]): boolean;
+export declare function appendLegacyCompatCss(css: string, rawSource: string, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined, options?: {
+    preserveSelectorOverrides?: boolean | undefined;
+    generatedSource?: string | undefined;
+    compileAuthorCssFunctions?: ((css: string) => Promise<string>) | undefined;
+}): Promise<string>;
+export declare function appendLegacyContainerCompatCss(css: string, rawSource: string, file: string, runtime: Set<string>, configuredContainerCompat: boolean, generatorTarget: string, styleHandler: InternalUserDefinedOptions['styleHandler'], cssHandlerOptions: IStyleHandlerOptions, generatorStyleOptions: Partial<IStyleHandlerOptions> | undefined): Promise<string>;

package/dist/generation/legacy-selectors.d.ts

@@ -0,0 +1 @@
+export { collectDedupedPostTransformCompatCss, collectGeneratedSelectors, normalizeCompatSelectors, removeDuplicatedViteMarkers, removeGeneratedSelectorCompatCss, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/legacy-units.d.ts

@@ -0,0 +1 @@
+export { inheritLegacyUnitConvertedDeclarations } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/local-imports.d.ts

@@ -0,0 +1 @@
+export { cleanLocalCssImportWrapperTailwindDirectives, cleanLocalCssImportWrapperTailwindDirectivesRoot, createCssSourceOrderAppend, isLocalCssImportRequest, isPureLocalCssImportWrapper, isPureLocalCssImportWrapperRoot, normalizeOutputImportRequest, removeMatchingLocalCssImports, removeMatchingLocalCssImportsRoot, restoreLocalCssImports, rewriteLocalCssImportRequestsForOutput, rewriteLocalCssImportRequestsForOutputRoot, splitLocalCssImports, splitLocalCssImportsRoot, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/markers.d.ts

@@ -0,0 +1 @@
+export { createCssAppend, GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE, GENERATOR_PLACEHOLDER_MARKER_RE, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, TAILWIND_BANNER_GLOBAL_RE, TAILWIND_BANNER_PREFIX_RE, TAILWIND_BANNER_RE, TAILWIND_GENERATED_CSS_MARKER_RE, TAILWIND_V4_BANNER_RE, VITE_MARKER_RE, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/output-import-shell.d.ts

@@ -0,0 +1 @@
+export { normalizeMiniProgramGeneratorCssSource, normalizeMiniProgramImportShell, removeMiniProgramOutputImports, removeSelfMiniProgramOutputImports, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/pipeline/context.d.ts

@@ -0,0 +1,60 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorResult } from '../generation-helpers/results.js';
+import type { TailwindV4CssSource } from '../source-resolver/types.js';
+import type { GenerateCssByGeneratorOptions } from '../types.js';
+import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../generator/index.js';
+import type { RuntimeBranch } from '../../runtime-branch.js';
+export interface GeneratorPipelineExecutionContext {
+    cssHandlerOptions: GenerateCssByGeneratorOptions['cssHandlerOptions'];
+    cssUserHandlerOptions: GenerateCssByGeneratorOptions['cssUserHandlerOptions'];
+    debug: GenerateCssByGeneratorOptions['debug'];
+    file: string;
+    finalizeGeneratorCss: (css: string, target: string, options?: {
+        injectPreflight?: boolean | undefined;
+        preservePreflight?: boolean | undefined;
+        removeEmptyAtRuleAncestors?: boolean | undefined;
+        styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+    }) => string;
+    generatedUserCssRawSource: string;
+    generatorBranch: RuntimeBranch;
+    generatorOptions: NormalizedWeappTailwindcssGeneratorOptions;
+    generatorRawSource: string;
+    getSourceCandidatesForEntries: GenerateCssByGeneratorOptions['getSourceCandidatesForEntries'];
+    hasDistinctUserRawSource: boolean;
+    hasGeneratedCss: boolean;
+    hasGeneratedMarkers: boolean;
+    hasSourceDirectives: boolean;
+    hasWebUserCssFallbackSource: boolean;
+    legacyCompatUserCssRawSource: string;
+    localImports: string | undefined;
+    majorVersion: number;
+    normalizeGeneratorSource: (source: TailwindResolvedSource) => TailwindResolvedSource;
+    normalizedCssSources: TailwindV4CssSource[] | undefined;
+    options: GenerateCssByGeneratorOptions;
+    opts: GenerateCssByGeneratorOptions['opts'];
+    prepareFinalGeneratorCss: (css: string) => string;
+    runtime: Set<string>;
+    runtimeState: GenerateCssByGeneratorOptions['runtimeState'];
+    shouldPreserveLegacyCompatSelectorOverrides: boolean;
+    styleHandler: GenerateCssByGeneratorOptions['styleHandler'];
+    userCssOrderSource: string;
+    userCssRawSource: string;
+    userRawSourceProcessed: boolean | undefined;
+    useMiniProgramCssBranch: boolean;
+}
+export interface GeneratorPipelineOutputContext extends GeneratorPipelineExecutionContext {
+    compileAuthorCssFunctions: (css: string) => Promise<string>;
+    configuredContainerCompat: boolean;
+    filterGeneratedApplyOnlyCss: (css: string) => string;
+    generated: GeneratorResult;
+    generatedCss: string;
+    generatorStyleOptions: Partial<IStyleHandlerOptions>;
+    hasMatchedCssSourceFile: boolean;
+    isolateCurrentCssCandidates: boolean;
+    preflightMode: {
+        inject: boolean;
+        preserve: boolean;
+    };
+    runtimeWithCurrentCss: Set<string>;
+    shouldFilterApplyOnlyCss: boolean;
+}

package/dist/generation/pipeline/deferred-output.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateCssByGeneratorResult } from '../types.js';
+import type { GeneratorPipelineOutputContext } from './context.js';
+export declare function finalizeDeferredGeneratorCss(context: GeneratorPipelineOutputContext): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/generation/pipeline/execution.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateCssByGeneratorResult } from '../types.js';
+import type { GeneratorPipelineExecutionContext } from './context.js';
+export declare function executeGeneratorPipeline(context: GeneratorPipelineExecutionContext): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/generation/pipeline/fallback-output.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateCssByGeneratorResult } from '../types.js';
+import type { GeneratorPipelineOutputContext } from './context.js';
+export declare function finalizeFallbackGeneratorCss(context: GeneratorPipelineOutputContext): Promise<GenerateCssByGeneratorResult>;

package/dist/generation/pipeline/ordered-output.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateCssByGeneratorResult } from '../types.js';
+import type { GeneratorPipelineOutputContext } from './context.js';
+export declare function finalizeOrderedGeneratorCss(context: GeneratorPipelineOutputContext): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/generation/pipeline/preparation.d.ts

@@ -0,0 +1,19 @@
+import type { GeneratorSourceRecord } from '../source-resolver.js';
+import type { GeneratorPipelineExecutionContext } from './context.js';
+import type { CompilationScopeDependency } from '../../compiler/index.js';
+export declare function resolveCompilationDependencies(dependencies: Iterable<string>): CompilationScopeDependency[];
+export declare function prepareGeneratorInputs(context: GeneratorPipelineExecutionContext): Promise<{
+    isolateCurrentCssCandidates: boolean;
+    runtimeWithCurrentCss: Set<string>;
+    generatorSourceRecords: GeneratorSourceRecord[];
+    generatorStyleOptions: Partial<import("@weapp-tailwindcss/postcss").IStyleHandlerOptions>;
+    configuredContainerCompat: boolean;
+    sourceConcurrency: number;
+    preparedGenerationInputs: {
+        generatorRuntime: Set<string>;
+        generatorSource: import("../../index.js").TailwindV4ResolvedSource;
+        dependencies: CompilationScopeDependency[];
+        isolateCssSource: boolean;
+        sourceId: string;
+    }[];
+}>;

package/dist/generation/pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './types.js';
+export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/generation/result-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { normalizeWeappTailwindcssGeneratorOptions } from '../generator/index.js';
+import { finalizeMiniProgramGeneratorCss } from './generation-helpers.js';
+export { isCssAlreadyRepresentedByMarkers } from '@weapp-tailwindcss/postcss/transform';
+export declare function resolveGeneratedCssClassSet(target: string, classSet: ReadonlySet<string>, candidates: Iterable<string>, css: string, escapeMap: Record<string, string> | undefined, previousClassSet?: Set<string> | undefined): Set<string>;
+export declare function finalizeWebGeneratorCss(css: string, target: string, webCompat: ReturnType<typeof normalizeWeappTailwindcssGeneratorOptions>['webCompat']): string;
+export declare function finalizeIncrementalGeneratorCss(previousCss: string, incrementalCss: string, target: string, majorVersion: number | undefined, cssPreflight: Parameters<typeof finalizeMiniProgramGeneratorCss>[3], options: Parameters<typeof finalizeMiniProgramGeneratorCss>[4], webCompat: ReturnType<typeof normalizeWeappTailwindcssGeneratorOptions>['webCompat']): string;

package/dist/generation/scoped-rules.d.ts

@@ -0,0 +1 @@
+export { preferScopedGeneratedCssRules, } from '@weapp-tailwindcss/postcss/transform';

package/dist/generation/service.d.ts

@@ -0,0 +1,20 @@
+import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './index.js';
+import type { CompilationDependencyChange, CompilerShadowReport, CssStage, GenerationArtifact, SourceScope } from '../compiler/index.js';
+import type { InternalUserDefinedOptions } from '../types/index.js';
+export interface TailwindV4GenerationCoreInput extends GenerateCssByGeneratorOptions {
+    compilerMode?: 'legacy' | undefined;
+    compilationChanges?: CompilationDependencyChange[] | undefined;
+    frameworkPostcssOwner?: InternalUserDefinedOptions | undefined;
+    cssStage?: CssStage | undefined;
+    outputFile?: string | undefined;
+    onCompilerShadowReport?: ((report: CompilerShadowReport) => void) | undefined;
+    scope?: SourceScope | undefined;
+    sourceCandidates?: Set<string> | undefined;
+}
+export interface TailwindV4GenerationCoreResult extends GenerateCssByGeneratorResult {
+    artifact?: GenerationArtifact | undefined;
+    classSet: Set<string>;
+    dependencies: string[];
+    metadata: NonNullable<GenerateCssByGeneratorResult['metadata']>;
+}
+export declare function generateTailwindV4Css(options: TailwindV4GenerationCoreInput): Promise<TailwindV4GenerationCoreResult | undefined>;

package/dist/generation/source-files.d.ts

@@ -0,0 +1,21 @@
+export interface SourceSideCssEntryOptions {
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
+    cssSources?: Array<{
+        file?: string | undefined;
+    }> | undefined;
+    cssEntries?: string[] | undefined;
+}
+export interface SourceSideCssEntrySource {
+    css: string;
+    config?: string | undefined;
+    configRequest?: string | undefined;
+    base: string;
+    file: string;
+}
+export declare function resolveSourceSideCssEntrySource(file: string, sourceOptions: SourceSideCssEntryOptions, resolveOptions?: {
+    removeConfig?: boolean;
+}): SourceSideCssEntrySource | undefined;

package/dist/generation/source-resolver/apply-reference.d.ts

@@ -0,0 +1,10 @@
+export { createTailwindV4SourceReferenceSource } from '@weapp-tailwindcss/postcss/transform';
+interface TailwindV4ApplyReferenceSourceOptions {
+    cssEntries?: string[] | undefined;
+    cssSources?: Array<{
+        css?: string | undefined;
+        file?: string | undefined;
+    }> | undefined;
+    packageName?: string | undefined;
+}
+export declare function createTailwindV4ApplyReferenceSource(css: string, sourceOptions: TailwindV4ApplyReferenceSourceOptions): string;

package/dist/generation/source-resolver/config.d.ts

@@ -0,0 +1,7 @@
+export declare function resolveExistingConfigPath(config: string | undefined, configRequest: string | undefined, file: string, sourceOptions: {
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    config?: string | undefined;
+    sourceFile?: string | undefined;
+    outputRoot?: string | undefined;
+}): string | undefined;

package/dist/generation/source-resolver/configuration.d.ts

@@ -0,0 +1,33 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, SourceStyleMatchOptions, TailwindV4CssSource, TailwindV4SourceOptions } from './types.js';
+import type { TailwindResolvedSource } from '../../generator/index.js';
+export declare function createCssEntrySources(cssEntries: string[] | undefined): {
+    file: string;
+}[] | undefined;
+export declare function mergeCssSources(cssSources: TailwindV4CssSource[] | undefined, cssEntrySources: TailwindV4CssSource[] | undefined): import("@weapp-tailwindcss/engine").TailwindV4CssSource[] | undefined;
+export declare function resolveUniqueTailwindV4CssConfig(sourceOptions: TailwindV4SourceOptions): string | undefined;
+export declare function createSingleTailwindV4SourceOptions(sourceOptions: TailwindV4SourceOptions, options: {
+    base: string;
+    css: string;
+    cssEntries?: string[] | undefined;
+}): Partial<{
+    projectRoot: string;
+    baseFallbacks: string[];
+    packageName: string;
+    base: string;
+    css: string;
+    cssEntries: string[];
+}>;
+export declare function resolveTailwindV4CssEntrySource(cssEntry: string, sourceOptions: TailwindV4SourceOptions, options?: {
+    candidateMatched?: boolean | undefined;
+    includesPreflight?: boolean | undefined;
+    index?: number | undefined;
+}): Promise<import("./metadata.js").GeneratorResolvedSource>;
+export declare function canResolveSourceSideCssEntry(file: string, cssHandlerOptions: IStyleHandlerOptions, sourceOptions?: Pick<SourceStyleMatchOptions, 'sourceFile' | 'cssSources' | 'outputRoot'>): boolean;
+export declare function shouldResolveSourceSideCssEntry(rawSource: string): boolean;
+export declare function normalizeTailwindV4CssSourceConfig(cssSource: TailwindV4CssSource, sourceBase: string): import("@weapp-tailwindcss/engine").TailwindV4CssSource;
+export declare function normalizeResolvedTailwindV4SourceConfig<T extends TailwindResolvedSource>(source: T, file: string | undefined, sourceOptions: TailwindV4SourceOptions | undefined): T;
+export declare function normalizeTailwindV4CssSourceConfigs(sourceOptions: TailwindV4SourceOptions): TailwindV4SourceOptions;
+export declare function tryResolveTailwindV4SourceOptions(runtimeState: GeneratorSourceRuntimeState): TailwindV4SourceOptions | undefined;
+export declare function hasConfiguredTailwindV4CssSource(sourceOptions: TailwindV4SourceOptions | undefined): boolean;
+export declare function isSameTailwindV4CssSource(a: TailwindV4CssSource | undefined, b: TailwindV4CssSource | undefined): boolean;

package/dist/generation/source-resolver/matching.d.ts

@@ -0,0 +1,3 @@
+import type { SourceStyleMatchOptions } from './types.js';
+export declare function normalizeCssSourceForCompare(css: string): string;
+export declare function scoreTailwindV4CssSourceFileMatch(file: string, cssSourceFile: string, sourceOptions: SourceStyleMatchOptions): number;

package/dist/generation/source-resolver/metadata.d.ts

@@ -0,0 +1,28 @@
+import type { SourceSideCssEntrySource } from '../source-files.js';
+import type { TailwindResolvedSource } from '../../generator/index.js';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan.js';
+export interface GeneratorSourceMetadata {
+    candidateMatchedCssSource?: boolean | undefined;
+    cssEntryIndex?: number | undefined;
+    cssSourceIndex?: number | undefined;
+    includesPreflight?: boolean | undefined;
+    isolateCssSource?: boolean | undefined;
+    matchedCssSourceFile?: string | undefined;
+    primaryCssSource?: boolean | undefined;
+    sourceEntries?: TailwindSourceEntry[] | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+declare const generatorSourceMetadataKey: unique symbol;
+export type GeneratorResolvedSource = TailwindResolvedSource & {
+    [generatorSourceMetadataKey]?: GeneratorSourceMetadata | undefined;
+};
+export interface GeneratorSourceRecord {
+    source: TailwindResolvedSource;
+    metadata: GeneratorSourceMetadata;
+}
+export declare function getGeneratorSourceMetadata(source: TailwindResolvedSource): GeneratorSourceMetadata | undefined;
+export declare function withGeneratorSourceMetadata(source: TailwindResolvedSource, metadata: GeneratorSourceMetadata): GeneratorResolvedSource;
+export declare function createGeneratorSourceRecord(source: TailwindResolvedSource): GeneratorSourceRecord;
+export declare function withMatchedSourceSideMetadata(source: TailwindResolvedSource, resolvedEntrySource: SourceSideCssEntrySource, metadata?: GeneratorSourceMetadata): import("../../generator/index.js").TailwindV4ResolvedSource;
+export {};

package/dist/generation/source-resolver/postcss-source.d.ts

@@ -0,0 +1,14 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4CssSource } from './types.js';
+export declare function resolvePostcssFromOption(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolvePostcssRequestOption(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolvePostcssSourceFile(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolveCssHandlerSourceOptions(cssHandlerOptions: IStyleHandlerOptions): {
+    outputRoot?: string | undefined;
+    requestFile?: string | undefined;
+    sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+    cssEntries?: string[] | undefined;
+} | undefined;
+export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;

package/dist/generation/source-resolver/resolve-source.d.ts

@@ -0,0 +1,4 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './types.js';
+import type { NormalizedWeappTailwindcssGeneratorOptions } from '../../generator/index.js';
+export declare function resolveGeneratorSource(_majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("../../generator/index.js").TailwindV4ResolvedSource>;

package/dist/generation/source-resolver/resolve-sources.d.ts

@@ -0,0 +1,5 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRecord } from './metadata.js';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './types.js';
+import type { NormalizedWeappTailwindcssGeneratorOptions } from '../../generator/index.js';
+export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<GeneratorSourceRecord[]>;

package/dist/generation/source-resolver/single-source.d.ts

@@ -0,0 +1,16 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { resolveSourceSideCssEntrySource } from '../source-files.js';
+import type { GeneratorSourceSelectionOptions, TailwindV4CssSource, TailwindV4SourceOptions } from './types.js';
+import type { NormalizedWeappTailwindcssGeneratorOptions, resolveTailwindV4SourceOptionsFromRuntime } from '../../generator/index.js';
+export declare function resolveSingleTailwindV4CssSource(cssSource: TailwindV4CssSource, sourceOptions: TailwindV4SourceOptions, options?: {
+    includesPreflight?: boolean | undefined;
+    index?: number | undefined;
+    matched?: boolean;
+    primary?: boolean | undefined;
+}): Promise<import("./metadata.js").GeneratorResolvedSource>;
+export declare function resolveTailwindV4CssSourceEntries(cssSource: TailwindV4CssSource, sourceOptions: TailwindV4SourceOptions): Promise<import("../../project-sources/index.js").ResolvedTailwindV4CssEntries | undefined>;
+export declare function resolveCandidateMatchedTailwindV4CssSource(_rawSource: string, _cssHandlerOptions: IStyleHandlerOptions, sourceOptions: TailwindV4SourceOptions, selectionOptions: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata.js").GeneratorResolvedSource | undefined>;
+export declare function resolveTailwindV4CssEntryIncludesPreflight(cssEntry: string): Promise<boolean | undefined>;
+export declare function resolveCandidateMatchedTailwindV4CssEntry(sourceOptions: TailwindV4SourceOptions, selectionOptions: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata.js").GeneratorResolvedSource | undefined>;
+export declare function createTailwindV4CssSourceResolver(sourceOptions: TailwindV4SourceOptions, generatorOptions: NormalizedWeappTailwindcssGeneratorOptions | undefined): (cssSource: NonNullable<typeof sourceOptions.cssSources>[number], index: number) => Promise<import("./metadata.js").GeneratorResolvedSource>;
+export declare function resolveTailwindV4SourceSideEntrySource(resolvedEntrySource: ReturnType<typeof resolveSourceSideCssEntrySource>, sourceOptions: ReturnType<typeof resolveTailwindV4SourceOptionsFromRuntime>, generatorOptions: NormalizedWeappTailwindcssGeneratorOptions | undefined, file: string, currentCss?: string): Promise<import("../../generator/index.js").TailwindV4ResolvedSource | undefined>;

package/dist/generation/source-resolver/source-entries.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorSourceRecord } from './metadata.js';
+import type { GeneratorSourceRuntimeState } from './types.js';
+export declare function resolveGeneratorSourceEntries(record: GeneratorSourceRecord, runtimeState?: GeneratorSourceRuntimeState): Promise<import("@weapp-tailwindcss/source-scan").TailwindSourceEntry[] | undefined>;

package/dist/generation/source-resolver/source-matching.d.ts

@@ -0,0 +1,5 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceSelectionOptions, TailwindV4SourceOptions } from './types.js';
+import type { resolveTailwindV4SourceOptionsFromRuntime } from '../../generator/index.js';
+export declare function resolveMatchingTailwindV4CssEntry(rawSource: string, file: string, sourceOptions: ReturnType<typeof resolveTailwindV4SourceOptionsFromRuntime>): Promise<import("./metadata.js").GeneratorResolvedSource | undefined>;
+export declare function resolveMatchingTailwindV4CssSource(rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, sourceOptions: TailwindV4SourceOptions, selectionOptions?: GeneratorSourceSelectionOptions | undefined): Promise<import("./metadata.js").GeneratorResolvedSource | undefined>;

package/dist/generation/source-resolver/types.d.ts

@@ -0,0 +1,22 @@
+import type { SourceSideCssEntryOptions } from '../source-files.js';
+import type { resolveTailwindV4SourceOptionsFromRuntime } from '../../generator/index.js';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan.js';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
+export interface GeneratorSourceRuntimeState {
+    tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
+}
+export interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+    cssEntries?: string[] | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+}
+export type TailwindV4SourceOptions = ReturnType<typeof resolveTailwindV4SourceOptionsFromRuntime> & {
+    config?: string | undefined;
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+};
+export type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
+export type TailwindV4CssSourceRef = Pick<TailwindV4CssSource, 'file'>;
+export interface SourceStyleMatchOptions extends SourceSideCssEntryOptions {
+}

package/dist/generation/source-resolver.d.ts

@@ -0,0 +1,7 @@
+export type { GeneratorResolvedSource, GeneratorSourceMetadata, GeneratorSourceRecord } from './source-resolver/metadata.js';
+export { createGeneratorSourceRecord, getGeneratorSourceMetadata } from './source-resolver/metadata.js';
+export { resolveCssSourceBase } from './source-resolver/postcss-source.js';
+export { resolveGeneratorSource } from './source-resolver/resolve-source.js';
+export { resolveGeneratorSources } from './source-resolver/resolve-sources.js';
+export { resolveGeneratorSourceEntries } from './source-resolver/source-entries.js';
+export type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/types.js';

package/dist/generation/style-options.d.ts

@@ -0,0 +1,8 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { SourceSideCssEntryOptions } from './source-files.js';
+export interface GenerationStyleHandlerOptions extends IStyleHandlerOptions {
+    sourceOptions?: SourceSideCssEntryOptions & {
+        requestFile?: string | undefined;
+    } | undefined;
+}
+export type { GenerationStyleHandlerOptions as BundlerStyleHandlerOptions };

package/dist/generation/style-requests.d.ts

@@ -0,0 +1,5 @@
+export declare function stripRequestQuery(request: string): string;
+export declare function isSourceStyleRequest(request: string | undefined): boolean;
+export declare function isSfcStyleSourceRequest(request: string | undefined): boolean;
+export declare function isSourcePreprocessorRequest(request: string | undefined, lang?: string): boolean;
+export declare function isVueScopedStyleRequest(request: string | undefined): boolean;