tailwindcss-patch 9.4.1 → 9.4.3

package/src/v3/style-generator.ts

@@ -0,0 +1,384 @@
+import type { Node } from 'postcss'
+import type { Config } from 'tailwindcss'
+import type { TailwindStyleCandidateOptions, TailwindStyleSource } from '../style-candidates'
+import type { TailwindcssRuntimeContext } from '../types'
+import { createRequire } from 'node:module'
+import process from 'node:process'
+import path from 'pathe'
+import postcss from 'postcss'
+import { collectTailwindStyleCandidates } from '../style-candidates'
+
+type NodeRequire = ReturnType<typeof createRequire>
+
+interface TailwindV3CreateContextModule {
+  createContext: (
+    tailwindConfig: Config,
+    changedContent?: Array<{ content?: string, extension?: string }>,
+    root?: ReturnType<typeof postcss.root>,
+  ) => TailwindcssRuntimeContext
+}
+
+interface TailwindV3GenerateRulesModule {
+  generateRules: (
+    candidates: Set<string>,
+    context: TailwindcssRuntimeContext,
+  ) => Array<[unknown, Node]>
+}
+
+interface TailwindV3ProcessResult {
+  css: string
+  messages: Array<Record<string, unknown>>
+}
+
+interface TailwindV3CollapseRulesModule {
+  default?: (context: TailwindcssRuntimeContext) => (root: postcss.Root, result: TailwindV3ProcessResult) => void
+}
+
+interface TailwindV3ProcessTailwindFeaturesModule {
+  default?: (
+    setupContext: () => (root: postcss.Root) => TailwindcssRuntimeContext,
+  ) => (root: postcss.Root, result: TailwindV3ProcessResult) => Promise<TailwindcssRuntimeContext>
+}
+
+interface TailwindV3ResolveDefaultsAtRulesModule {
+  default?: (context: TailwindcssRuntimeContext) => (root: postcss.Root, result: TailwindV3ProcessResult) => void
+}
+
+interface TailwindV3ValidateConfigModule {
+  validateConfig: (config: unknown) => Config
+}
+
+interface TailwindV3SharedStateModule {
+  NOT_ON_DEMAND?: string
+}
+
+type ResolveConfig = (config: Config) => Config
+
+interface TailwindV3Offsets {
+  sort: <T>(rules: Array<[unknown, T]>) => Array<[{
+    layer: 'base' | 'components' | 'defaults' | 'utilities' | 'variants'
+  }, T]>
+}
+
+export interface TailwindV3StyleGenerateOptions extends TailwindStyleCandidateOptions {
+  /**
+   * Tailwind v3 package name or alias. Defaults to `tailwindcss`.
+   */
+  packageName?: string
+  /**
+   * `createRequire` base used to resolve the Tailwind v3 package.
+   */
+  cwd?: string
+  /**
+   * Inline Tailwind v3 config. `content` is injected from collected candidates.
+   */
+  config?: Partial<Config>
+  /**
+   * Generate all layers by default. Pass a subset to emit only selected layers.
+   */
+  layers?: TailwindV3StyleLayer[]
+}
+
+export type TailwindV3StyleLayer = 'base' | 'components' | 'utilities' | 'variants'
+
+export interface TailwindV3RawStyleGenerateOptions extends TailwindStyleCandidateOptions {
+  /**
+   * Tailwind v3 package name or alias. Defaults to `tailwindcss`.
+   */
+  packageName?: string
+  /**
+   * `createRequire` base used to resolve the Tailwind v3 package.
+   */
+  cwd?: string
+  /**
+   * Tailwind v3 entry CSS. Defaults to `@tailwind utilities;`.
+   */
+  css?: string
+  /**
+   * Inline Tailwind v3 config. Candidate content is injected automatically.
+   */
+  config?: Partial<Config>
+  /**
+   * Directly append generated utility rules when the CSS is exactly `@tailwind utilities;`.
+   * This mirrors Tailwind v3's internal fast path and keeps output order aligned.
+   */
+  directUtilitiesOnly?: boolean | 'auto'
+}
+
+export interface TailwindV3RawStyleGenerateResult {
+  version: 3
+  css: string
+  tokens: Set<string>
+  classSet: Set<string>
+  context: TailwindcssRuntimeContext
+  dependencies: string[]
+  sources: TailwindStyleSource[]
+  config: Config
+}
+
+export interface TailwindV3StyleGenerateResult {
+  version: 3
+  css: string
+  tokens: Set<string>
+  classSet: Set<string>
+  sources: TailwindStyleSource[]
+  config: Config
+}
+
+function createPackageRequire(cwd?: string): NodeRequire {
+  return createRequire(path.join(path.resolve(cwd ?? process.cwd()), 'package.json'))
+}
+
+function createDefaultTailwindV3Config(tokens: Set<string>): Config {
+  return {
+    content: [
+      {
+        raw: [...tokens].join(' '),
+        extension: 'html',
+      },
+    ],
+    theme: {
+      extend: {},
+    },
+    plugins: [],
+  }
+}
+
+function getDefaultExport<T>(module: { default?: T } | T): T {
+  if (module && typeof module === 'object' && 'default' in module) {
+    return module.default as T
+  }
+  return module as T
+}
+
+function loadTailwindV3Modules(options: Pick<TailwindV3StyleGenerateOptions, 'cwd' | 'packageName'>) {
+  const packageName = options.packageName ?? 'tailwindcss'
+  const moduleRequire = createPackageRequire(options.cwd)
+  const resolveConfig = getDefaultExport<ResolveConfig>(
+    moduleRequire(`${packageName}/lib/public/resolve-config`) as { default?: ResolveConfig } | ResolveConfig,
+  )
+  const contextModule = moduleRequire(`${packageName}/lib/lib/setupContextUtils`) as TailwindV3CreateContextModule
+  const generateRulesModule = moduleRequire(`${packageName}/lib/lib/generateRules`) as TailwindV3GenerateRulesModule
+  const collapseAdjacentRulesModule = moduleRequire(`${packageName}/lib/lib/collapseAdjacentRules`) as TailwindV3CollapseRulesModule
+  const collapseDuplicateDeclarationsModule = moduleRequire(`${packageName}/lib/lib/collapseDuplicateDeclarations`) as TailwindV3CollapseRulesModule
+  const processTailwindFeaturesModule = moduleRequire(`${packageName}/lib/processTailwindFeatures`) as TailwindV3ProcessTailwindFeaturesModule
+  const resolveDefaultsAtRulesModule = moduleRequire(`${packageName}/lib/lib/resolveDefaultsAtRules`) as TailwindV3ResolveDefaultsAtRulesModule
+  const sharedStateModule = moduleRequire(`${packageName}/lib/lib/sharedState`) as TailwindV3SharedStateModule
+  const validateConfigModule = moduleRequire(`${packageName}/lib/util/validateConfig.js`) as TailwindV3ValidateConfigModule
+  return {
+    collapseAdjacentRules: getDefaultExport(collapseAdjacentRulesModule),
+    collapseDuplicateDeclarations: getDefaultExport(collapseDuplicateDeclarationsModule),
+    createContext: contextModule.createContext,
+    generateRules: generateRulesModule.generateRules,
+    notOnDemandCandidate: sharedStateModule.NOT_ON_DEMAND ?? '*',
+    processTailwindFeatures: getDefaultExport(processTailwindFeaturesModule),
+    resolveDefaultsAtRules: getDefaultExport(resolveDefaultsAtRulesModule),
+    resolveConfig,
+    validateConfig: validateConfigModule.validateConfig,
+  }
+}
+
+function createRawContentEntries(candidates: Iterable<string>, sources: TailwindStyleSource[]) {
+  const entries: Array<{ raw: string, extension: string }> = []
+  const candidateContent = [...candidates].join(' ')
+  if (candidateContent.length > 0) {
+    entries.push({
+      raw: candidateContent,
+      extension: 'html',
+    })
+  }
+  for (const source of sources) {
+    entries.push({
+      raw: source.content,
+      extension: source.extension ?? 'html',
+    })
+  }
+  return entries
+}
+
+function createChangedContentEntries(candidates: Iterable<string>, sources: TailwindStyleSource[]) {
+  return createRawContentEntries(candidates, sources).map(entry => ({
+    content: entry.raw,
+    extension: entry.extension,
+  }))
+}
+
+function createTailwindConfigWithContent(
+  config: Partial<Config> | undefined,
+  tokens: Set<string>,
+  sources: TailwindStyleSource[],
+) {
+  const userContent = config?.content
+  return {
+    ...createDefaultTailwindV3Config(tokens),
+    ...(config ?? {}),
+    content: [
+      ...(Array.isArray(userContent) ? userContent : []),
+      ...createRawContentEntries(tokens, sources),
+    ],
+  } as Config
+}
+
+function isDirectUtilitiesOnlyCss(css: string) {
+  return css.replace(/\s+/g, '') === '@tailwindutilities;'
+}
+
+function sortCandidates(candidates: Iterable<string>) {
+  return [...candidates].sort((a, z) => {
+    if (a === z) {
+      return 0
+    }
+    return a < z ? -1 : 1
+  })
+}
+
+function appendUtilityRules(
+  root: postcss.Root,
+  context: TailwindcssRuntimeContext,
+  rules: Array<[unknown, Node]>,
+) {
+  const sortedRules = (context.offsets as unknown as TailwindV3Offsets).sort(rules)
+  for (const [sort, rule] of sortedRules) {
+    const tailwindRaw = rule.raws.tailwind as { parentLayer?: string } | undefined
+    if (sort.layer === 'utilities' || (sort.layer === 'variants' && tailwindRaw?.parentLayer === 'utilities')) {
+      root.append(rule.clone())
+    }
+  }
+}
+
+function collectClassSet(context: TailwindcssRuntimeContext, notOnDemandCandidate: string) {
+  const classSet = new Set<string>()
+  for (const candidate of context.classCache.keys()) {
+    if (String(candidate) !== String(notOnDemandCandidate)) {
+      classSet.add(candidate)
+    }
+  }
+  return classSet
+}
+
+function collectDependencyMessages(result: TailwindV3ProcessResult) {
+  const dependencies = new Set<string>()
+  for (const message of result.messages) {
+    const file = message.file
+    if (message.type === 'dependency' && typeof file === 'string') {
+      dependencies.add(file)
+    }
+  }
+  return [...dependencies]
+}
+
+function buildStylesheetNodes(
+  rules: Array<[unknown, Node]>,
+  context: TailwindcssRuntimeContext,
+  layers: TailwindV3StyleLayer[],
+) {
+  const sortedRules = (context.offsets as unknown as TailwindV3Offsets).sort(rules)
+  const nodes: Node[] = []
+  const layerSet = new Set<TailwindV3StyleLayer>(layers)
+
+  for (const [sort, rule] of sortedRules) {
+    const layer = sort.layer === 'defaults' ? 'base' : sort.layer
+    if (layerSet.has(layer)) {
+      nodes.push(rule.clone())
+    }
+  }
+  return nodes
+}
+
+function createRootFromNodes(nodes: Node[]) {
+  const root = postcss.root()
+  for (const node of nodes) {
+    root.append(node)
+  }
+  return root
+}
+
+export async function generateTailwindV3Style(
+  options: TailwindV3StyleGenerateOptions = {},
+): Promise<TailwindV3StyleGenerateResult> {
+  const tokens = await collectTailwindStyleCandidates(options)
+  const { createContext, generateRules, resolveConfig } = loadTailwindV3Modules(options)
+  const userContent = options.config?.content
+  const config = resolveConfig({
+    ...createDefaultTailwindV3Config(tokens),
+    ...(options.config ?? {}),
+    content: [
+      ...(Array.isArray(userContent) ? userContent : []),
+      {
+        raw: [...tokens].join(' '),
+        extension: 'html',
+      },
+    ],
+  } as Config)
+  const root = postcss.root()
+  const context = createContext(config, [], root)
+  const rules = generateRules(tokens, context)
+  const nodes = buildStylesheetNodes(rules, context, options.layers ?? ['base', 'components', 'utilities', 'variants'])
+  const css = createRootFromNodes(nodes).toString()
+
+  return {
+    version: 3,
+    css,
+    tokens,
+    classSet: new Set(context.classCache.keys()),
+    sources: options.sources ?? [],
+    config,
+  }
+}
+
+export async function generateTailwindV3RawStyle(
+  options: TailwindV3RawStyleGenerateOptions = {},
+): Promise<TailwindV3RawStyleGenerateResult> {
+  const tokens = await collectTailwindStyleCandidates(options)
+  const {
+    collapseAdjacentRules,
+    collapseDuplicateDeclarations,
+    createContext,
+    generateRules,
+    notOnDemandCandidate,
+    processTailwindFeatures,
+    resolveConfig,
+    resolveDefaultsAtRules,
+    validateConfig,
+  } = loadTailwindV3Modules(options)
+  const css = options.css ?? '@tailwind utilities;'
+  const config = validateConfig(resolveConfig(createTailwindConfigWithContent(options.config, tokens, options.sources ?? [])))
+  const root = postcss.parse(css, {
+    from: undefined,
+  })
+  const result: TailwindV3ProcessResult = {
+    css: '',
+    messages: [],
+  }
+  const changedContent = createChangedContentEntries(tokens, options.sources ?? [])
+  const shouldUseDirectUtilities = options.directUtilitiesOnly === true
+    || (options.directUtilitiesOnly !== false && isDirectUtilitiesOnlyCss(css))
+  let context: TailwindcssRuntimeContext
+
+  if (shouldUseDirectUtilities) {
+    context = createContext(config, changedContent, root)
+    generateRules(new Set(sortCandidates([notOnDemandCandidate, ...tokens])), context)
+    root.removeAll()
+    appendUtilityRules(root, context, [...context.ruleCache])
+    resolveDefaultsAtRules(context)(root, result)
+    collapseAdjacentRules(context)(root, result)
+    collapseDuplicateDeclarations(context)(root, result)
+  }
+  else {
+    const setupContext = () => {
+      return (currentRoot: postcss.Root) => createContext(config, changedContent, currentRoot)
+    }
+    context = await processTailwindFeatures(setupContext)(root, result)
+  }
+
+  return {
+    version: 3,
+    css: root.toString(),
+    tokens,
+    classSet: collectClassSet(context, notOnDemandCandidate),
+    context,
+    dependencies: collectDependencyMessages(result),
+    sources: options.sources ?? [],
+    config,
+  }
+}

package/src/v4/bare-arbitrary-values.ts

@@ -10,6 +10,12 @@ export interface BareArbitraryValueResolveResult {
   canonicalCandidate: string
 }
 
+export interface BareArbitraryValueSourceCandidate {
+  rawCandidate: string
+  start: number
+  end: number
+}
+
 const DEFAULT_BARE_ARBITRARY_VALUE_UNITS = [
   '%',
   'px',
@@ -41,6 +47,8 @@ const DEFAULT_BARE_ARBITRARY_VALUE_UNITS = [
 const NUMBER_RE = /^-?(?:\d+|\d*\.\d+)$/
 const FUNCTION_VALUE_RE = /^[a-z_-][\w-]*\(/i
 const HEX_ESCAPE_RE = /^[\da-f]$/i
+const ASPECT_RATIO_RE = /^\d+\/\d+$/
+const ESCAPED_WHITESPACE_RE = /\\[nrt]/g
 
 function splitVariantPrefix(candidate: string) {
   let depth = 0
@@ -221,6 +229,10 @@ function normalizeBareArbitraryValueOptions(options: boolean | BareArbitraryValu
   }
 }
 
+export function isBareArbitraryValuesEnabled(options: boolean | BareArbitraryValueOptions | undefined) {
+  return normalizeBareArbitraryValueOptions(options) !== undefined
+}
+
 function normalizeEscapedValue(value: string) {
   let result = ''
   for (let index = 0; index < value.length; index++) {
@@ -276,13 +288,17 @@ function resolveValueWithUnit(body: string, units: string[]) {
   }
 }
 
-function resolveArbitraryValue(body: string, units: string[]) {
+function resolveArbitraryValue(utility: string, body: string, units: string[]) {
   const value = normalizeEscapedValue(body)
   const withUnit = resolveValueWithUnit(value, units)
   if (withUnit) {
     return withUnit
   }
 
+  if (utility === 'aspect' && ASPECT_RATIO_RE.test(value)) {
+    return value
+  }
+
   if (isHexColorValue(value)) {
     return value
   }
@@ -292,6 +308,9 @@ function resolveArbitraryValue(body: string, units: string[]) {
   }
 
   if (FUNCTION_VALUE_RE.test(value) && value.endsWith(')') && isBalancedFunctionValue(value)) {
+    if (utility === 'text' && /^var\(/i.test(value)) {
+      return `color:${value}`
+    }
     return value
   }
 }
@@ -339,7 +358,7 @@ function resolveUtilityAndValue(body: string, units: string[]) {
       continue
     }
 
-    const value = resolveArbitraryValue(rawValue, units)
+    const value = resolveArbitraryValue(utility, rawValue, units)
     if (value) {
       return {
         utility,
@@ -380,6 +399,112 @@ export function resolveBareArbitraryValueCandidate(
   }
 }
 
+function isBareArbitrarySourceSplitter(char: string) {
+  return /\s/.test(char)
+}
+
+function isQuoteBoundary(content: string, start: number, index: number) {
+  const tokenPrefix = content.slice(start, index)
+  return tokenPrefix.length === 0 || !tokenPrefix.endsWith('-')
+}
+
+function trimBareArbitrarySourceToken(token: string, start: number) {
+  let nextToken = token
+  let nextStart = start
+  while (nextToken.length > 0 && /^[<{([]$/.test(nextToken[0]!)) {
+    nextToken = nextToken.slice(1)
+    nextStart++
+  }
+  while (nextToken.length > 0 && /^[>\],;]$/.test(nextToken[nextToken.length - 1]!)) {
+    nextToken = nextToken.slice(0, -1)
+  }
+  return {
+    token: nextToken,
+    start: nextStart,
+  }
+}
+
+function pushBareArbitrarySourceCandidate(
+  result: BareArbitraryValueSourceCandidate[],
+  token: string,
+  start: number,
+  options: boolean | BareArbitraryValueOptions | undefined,
+) {
+  const trimmed = trimBareArbitrarySourceToken(token, start)
+  if (!trimmed.token || trimmed.token.includes('=') || trimmed.token.includes('[') || trimmed.token.includes(']')) {
+    return
+  }
+  if (!resolveBareArbitraryValueCandidate(trimmed.token, options)) {
+    return
+  }
+  result.push({
+    rawCandidate: trimmed.token,
+    start: trimmed.start,
+    end: trimmed.start + trimmed.token.length,
+  })
+}
+
+export function extractBareArbitraryValueSourceCandidatesWithPositions(
+  content: string,
+  options?: boolean | BareArbitraryValueOptions,
+): BareArbitraryValueSourceCandidate[] {
+  if (!isBareArbitraryValuesEnabled(options)) {
+    return []
+  }
+
+  const normalized = content.includes('\\') ? content.replace(ESCAPED_WHITESPACE_RE, ' ') : content
+  const result: BareArbitraryValueSourceCandidate[] = []
+  let depth = 0
+  let quote: string | undefined
+  let start = 0
+
+  for (let index = 0; index < normalized.length; index++) {
+    const char = normalized[index]
+    if (char === undefined) {
+      continue
+    }
+    if (char === '\\') {
+      index++
+      continue
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = undefined
+      }
+    }
+    else if ((char === '"' || char === '\'' || char === '`') && !isQuoteBoundary(normalized, start, index)) {
+      quote = char
+    }
+    else if (char === '(' || char === '{' || char === '[') {
+      depth++
+    }
+    else if (char === ')' || char === '}' || char === ']') {
+      depth = Math.max(0, depth - 1)
+    }
+
+    if (!isBareArbitrarySourceSplitter(char) && !((char === '"' || char === '\'' || char === '`') && depth === 0 && isQuoteBoundary(normalized, start, index))) {
+      continue
+    }
+
+    pushBareArbitrarySourceCandidate(result, normalized.slice(start, index), start, options)
+    start = index + 1
+  }
+
+  pushBareArbitrarySourceCandidate(result, normalized.slice(start), start, options)
+  return result
+}
+
+export function extractBareArbitraryValueSourceCandidates(
+  content: string,
+  options?: boolean | BareArbitraryValueOptions,
+) {
+  return [...new Set(
+    extractBareArbitraryValueSourceCandidatesWithPositions(content, options)
+      .map(candidate => candidate.rawCandidate),
+  )]
+}
+
 // Based on the CSS.escape algorithm, scoped to class selector escaping.
 export function escapeCssClassName(value: string) {
   let result = ''

package/src/v4/engine.ts

@@ -37,13 +37,16 @@ async function collectRawCandidates(
   compiledSources: TailwindV4SourcePattern[] = [],
 ) {
   const rawCandidates = new Set<string>()
+  const extractOptions = options?.bareArbitraryValues === undefined
+    ? undefined
+    : { bareArbitraryValues: options.bareArbitraryValues }
 
   for (const candidate of options?.candidates ?? []) {
     rawCandidates.add(candidate)
   }
 
   for (const candidateSource of options?.sources ?? []) {
-    const candidates = await extractRawCandidatesWithPositions(candidateSource.content, candidateSource.extension)
+    const candidates = await extractRawCandidatesWithPositions(candidateSource.content, candidateSource.extension, extractOptions)
     for (const candidate of candidates) {
       rawCandidates.add(candidate.rawCandidate)
     }
@@ -51,7 +54,7 @@ async function collectRawCandidates(
 
   const filesystemSources = resolveScanSources(options, source, compiledRoot, compiledSources)
   if (filesystemSources.length > 0) {
-    for (const candidate of await extractRawCandidates(filesystemSources)) {
+    for (const candidate of await extractRawCandidates(filesystemSources, extractOptions)) {
       rawCandidates.add(candidate)
     }
   }

package/src/v4/index.ts

@@ -1,5 +1,14 @@
 export {
+  escapeCssClassName,
+  extractBareArbitraryValueSourceCandidates,
+  extractBareArbitraryValueSourceCandidatesWithPositions,
+  isBareArbitraryValuesEnabled,
+  resolveBareArbitraryValueCandidate,
+} from './bare-arbitrary-values'
+export {
+  canonicalizeBareArbitraryValueCandidates,
   extractTailwindV4InlineSourceCandidates,
+  replaceBareArbitraryValueSelectors,
   resolveValidTailwindV4Candidates,
 } from './candidates'
 export { createTailwindV4Engine } from './engine'
@@ -8,6 +17,11 @@ export {
   loadTailwindV4DesignSystem,
   loadTailwindV4NodeModule,
 } from './node-adapter'
+export {
+  resolveTailwindV4Source,
+  resolveTailwindV4SourceFromPatchOptions,
+  tailwindV4SourceOptionsFromPatchOptions,
+} from './source'
 export {
   createTailwindV4CompiledSourceEntries,
   createTailwindV4DefaultIgnoreSources,
@@ -30,10 +44,9 @@ export {
   TAILWIND_V4_IGNORED_FILES,
 } from './source-scan'
 export {
-  resolveTailwindV4Source,
-  resolveTailwindV4SourceFromPatchOptions,
-  tailwindV4SourceOptionsFromPatchOptions,
-} from './source'
+  collectTailwindV4StyleCandidates,
+  generateTailwindV4Style,
+} from './style-generator'
 export type {
   TailwindV4CandidateSource,
   TailwindV4CompiledSourceRoot,
@@ -45,4 +58,7 @@ export type {
   TailwindV4ResolvedSource,
   TailwindV4SourceOptions,
   TailwindV4SourcePattern,
+  TailwindV4StyleGenerateOptions,
+  TailwindV4StyleGenerateResult,
+  TailwindV4StyleSource,
 } from './types'

package/src/v4/node-adapter.ts

@@ -1,7 +1,7 @@
 import type {
+  TailwindV4CompiledSourceRoot,
   TailwindV4DesignSystem,
   TailwindV4ResolvedSource,
-  TailwindV4CompiledSourceRoot,
   TailwindV4SourcePattern,
 } from './types'
 import { createRequire } from 'node:module'

package/src/v4/source-scan.ts

@@ -3,8 +3,8 @@ import type { TailwindV4CompiledSourceRoot, TailwindV4SourcePattern } from './ty
 import { realpathSync } from 'node:fs'
 import { stat } from 'node:fs/promises'
 import process from 'node:process'
-import path from 'pathe'
 import micromatch from 'micromatch'
+import path from 'pathe'
 
 export const TAILWIND_V4_IGNORED_CONTENT_DIRS = [
   '.git',

package/src/v4/style-generator.ts

@@ -0,0 +1,44 @@
+import type {
+  TailwindV4SourceOptions,
+  TailwindV4StyleGenerateOptions,
+  TailwindV4StyleGenerateResult,
+} from './types'
+import { collectTailwindStyleCandidates } from '../style-candidates'
+import { createTailwindV4Engine } from './engine'
+import { resolveTailwindV4Source } from './source'
+
+function createSourceOptions(options: TailwindV4StyleGenerateOptions): TailwindV4SourceOptions {
+  return {
+    ...(options.projectRoot === undefined ? {} : { projectRoot: options.projectRoot }),
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    ...(options.base === undefined ? {} : { base: options.base }),
+    ...(options.baseFallbacks === undefined ? {} : { baseFallbacks: options.baseFallbacks }),
+    ...(options.css === undefined ? {} : { css: options.css }),
+    ...(options.cssSources === undefined ? {} : { cssSources: options.cssSources }),
+    ...(options.cssEntries === undefined ? {} : { cssEntries: options.cssEntries }),
+    ...(options.packageName === undefined ? {} : { packageName: options.packageName }),
+  }
+}
+
+export async function collectTailwindV4StyleCandidates(
+  options: Pick<TailwindV4StyleGenerateOptions, 'bareArbitraryValues' | 'candidates' | 'sources'>,
+): Promise<Set<string>> {
+  return collectTailwindStyleCandidates(options)
+}
+
+export async function generateTailwindV4Style(
+  options: TailwindV4StyleGenerateOptions = {},
+): Promise<TailwindV4StyleGenerateResult> {
+  const source = options.source ?? await resolveTailwindV4Source(createSourceOptions(options))
+  const candidates = await collectTailwindV4StyleCandidates(options)
+  const result = await createTailwindV4Engine(source).generate({
+    candidates,
+    ...(options.bareArbitraryValues === undefined ? {} : { bareArbitraryValues: options.bareArbitraryValues }),
+    ...(options.scanSources === undefined ? {} : { scanSources: options.scanSources }),
+  })
+  return {
+    ...result,
+    tokens: result.rawCandidates,
+    source,
+  }
+}