tailwindcss 4.1.4 → 4.1.18

package/dist/lib.d.mts

@@ -1,4 +1,4 @@
-import { U as UserConfig, P as Plugin } from './types-B254mqw1.mjs';
+import { S as SourceLocation, U as UserConfig, P as Plugin } from './types-CJYAW1ql.mjs';
 import { V as Variant, C as Candidate } from './resolve-config-QUZ9b-Gn.mjs';
 import './colors.mjs';
 
@@ -18,8 +18,10 @@ declare class Theme {
     constructor(values?: Map<string, {
         value: string;
         options: ThemeOptions;
+        src: Declaration["src"];
     }>, keyframes?: Set<AtRule>);
-    add(key: string, value: string, options?: ThemeOptions): void;
+    get size(): number;
+    add(key: string, value: string, options?: ThemeOptions, src?: Declaration['src']): void;
     keysInNamespaces(themeKeys: Iterable<ThemeKey>): string[];
     get(themeKeys: ThemeKey[]): string | null;
     hasDefault(key: string): boolean;
@@ -27,9 +29,11 @@ declare class Theme {
     entries(): IterableIterator<[string, {
         value: string;
         options: ThemeOptions;
+        src: Declaration["src"];
     }]> | [string, {
         value: string;
         options: ThemeOptions;
+        src: Declaration["src"];
     }][];
     prefixKey(key: string): string;
     clearNamespace(namespace: string, clearOptions: ThemeOptions): void;
@@ -77,7 +81,7 @@ declare class Variants {
         compounds?: Compounds;
         order?: number;
     }): void;
-    fromAst(name: string, ast: AstNode[]): void;
+    fromAst(name: string, ast: AstNode[], designSystem: DesignSystem): void;
     functional(name: string, applyFn: VariantFn<'functional'>, { compounds, order }?: {
         compounds?: Compounds;
         order?: number;
@@ -95,7 +99,7 @@ declare class Variants {
         compoundsWith: Compounds;
         compounds: Compounds;
     } | undefined;
-    kind(name: string): "static" | "arbitrary" | "functional" | "compound";
+    kind(name: string): "arbitrary" | "static" | "functional" | "compound";
     compoundsWith(parent: string, child: string | Variant): boolean;
     suggest(name: string, suggestions: () => string[]): void;
     getCompletions(name: string): string[];
@@ -112,7 +116,7 @@ declare class Variants {
     private nextOrder;
 }
 
-declare function compileAstNodes(candidate: Candidate, designSystem: DesignSystem): {
+declare function compileAstNodes(candidate: Candidate, designSystem: DesignSystem, flags: CompileAstFlags): {
     node: AstNode;
     propertySort: {
         order: number[];
@@ -120,6 +124,29 @@ declare function compileAstNodes(candidate: Candidate, designSystem: DesignSyste
     };
 }[];
 
+interface CanonicalizeOptions {
+    /**
+     * The root font size in pixels. If provided, `rem` values will be normalized
+     * to `px` values.
+     *
+     * E.g.: `mt-[16px]` with `rem: 16` will become `mt-4` (assuming `--spacing: 0.25rem`).
+     */
+    rem?: number;
+    /**
+     * Whether to collapse multiple utilities into a single utility if possible.
+     *
+     * E.g.: `mt-2 mr-2 mb-2 ml-2` → `m-2`
+     */
+    collapse?: boolean;
+    /**
+     * Whether to convert between logical and physical properties when collapsing
+     * utilities.
+     *
+     * E.g.: `mr-2 ml-2` → `mx-2`
+     */
+    logicalToPhysical?: boolean;
+}
+
 interface ClassMetadata {
     modifiers: string[];
 }
@@ -164,6 +191,10 @@ declare class Utilities {
     keys(kind: 'static' | 'functional'): string[];
 }
 
+declare const enum CompileAstFlags {
+    None = 0,
+    RespectImportant = 1
+}
 type DesignSystem = {
     theme: Theme;
     utilities: Utilities;
@@ -175,46 +206,114 @@ type DesignSystem = {
     getVariants(): VariantEntry[];
     parseCandidate(candidate: string): Readonly<Candidate>[];
     parseVariant(variant: string): Readonly<Variant> | null;
-    compileAstNodes(candidate: Candidate): ReturnType<typeof compileAstNodes>;
+    compileAstNodes(candidate: Candidate, flags?: CompileAstFlags): ReturnType<typeof compileAstNodes>;
+    printCandidate(candidate: Candidate): string;
+    printVariant(variant: Variant): string;
     getVariantOrder(): Map<Variant, number>;
     resolveThemeValue(path: string, forceInline?: boolean): string | undefined;
     trackUsedVariables(raw: string): void;
+    canonicalizeCandidates(candidates: string[], options?: CanonicalizeOptions): string[];
     candidatesToCss(classes: string[]): (string | null)[];
+    candidatesToAst(classes: string[]): AstNode[][];
+    storage: Record<symbol, unknown>;
 };
 
 type StyleRule = {
     kind: 'rule';
     selector: string;
     nodes: AstNode[];
+    src?: SourceLocation;
+    dst?: SourceLocation;
 };
 type AtRule = {
     kind: 'at-rule';
     name: string;
     params: string;
     nodes: AstNode[];
+    src?: SourceLocation;
+    dst?: SourceLocation;
 };
 type Declaration = {
     kind: 'declaration';
     property: string;
     value: string | undefined;
     important: boolean;
+    src?: SourceLocation;
+    dst?: SourceLocation;
 };
 type Comment = {
     kind: 'comment';
     value: string;
+    src?: SourceLocation;
+    dst?: SourceLocation;
 };
 type Context = {
     kind: 'context';
     context: Record<string, string | boolean>;
     nodes: AstNode[];
+    src?: undefined;
+    dst?: undefined;
 };
 type AtRoot = {
     kind: 'at-root';
     nodes: AstNode[];
+    src?: undefined;
+    dst?: undefined;
 };
 type Rule = StyleRule | AtRule;
 type AstNode = StyleRule | AtRule | Declaration | Comment | Context | AtRoot;
 
+/**
+ * Line offset tables are the key to generating our source maps. They allow us
+ * to store indexes with our AST nodes and later convert them into positions as
+ * when given the source that the indexes refer to.
+ */
+/**
+ * A position in source code
+ *
+ * https://tc39.es/ecma426/#sec-position-record-type
+ */
+interface Position {
+    /** The line number, one-based */
+    line: number;
+    /** The column/character number, one-based */
+    column: number;
+}
+
+interface OriginalPosition extends Position {
+    source: DecodedSource;
+}
+/**
+ * A "decoded" sourcemap
+ *
+ * @see https://tc39.es/ecma426/#decoded-source-map-record
+ */
+interface DecodedSourceMap {
+    file: string | null;
+    sources: DecodedSource[];
+    mappings: DecodedMapping[];
+}
+/**
+ * A "decoded" source
+ *
+ * @see https://tc39.es/ecma426/#decoded-source-record
+ */
+interface DecodedSource {
+    url: string | null;
+    content: string | null;
+    ignore: boolean;
+}
+/**
+ * A "decoded" mapping
+ *
+ * @see https://tc39.es/ecma426/#decoded-mapping-record
+ */
+interface DecodedMapping {
+    originalPosition: OriginalPosition | null;
+    generatedPosition: Position;
+    name: string | null;
+}
+
 type Config = UserConfig;
 declare const enum Polyfills {
     None = 0,
@@ -224,14 +323,17 @@ declare const enum Polyfills {
 }
 type CompileOptions = {
     base?: string;
+    from?: string;
     polyfills?: Polyfills;
     loadModule?: (id: string, base: string, resourceHint: 'plugin' | 'config') => Promise<{
-        module: Plugin | Config;
+        path: string;
         base: string;
+        module: Plugin | Config;
     }>;
     loadStylesheet?: (id: string, base: string) => Promise<{
-        content: string;
+        path: string;
         base: string;
+        content: string;
     }>;
 };
 type Root = null | 'none' | {
@@ -245,7 +347,8 @@ declare const enum Features {
     JsPluginCompat = 4,
     ThemeFunction = 8,
     Utilities = 16,
-    Variants = 32
+    Variants = 32,
+    AtTheme = 64
 }
 declare function compileAst(input: AstNode[], opts?: CompileOptions): Promise<{
     sources: {
@@ -257,6 +360,7 @@ declare function compileAst(input: AstNode[], opts?: CompileOptions): Promise<{
     features: Features;
     build(candidates: string[]): AstNode[];
 }>;
+
 declare function compile(css: string, opts?: CompileOptions): Promise<{
     sources: {
         base: string;
@@ -266,8 +370,9 @@ declare function compile(css: string, opts?: CompileOptions): Promise<{
     root: Root;
     features: Features;
     build(candidates: string[]): string;
+    buildSourceMap(): DecodedSourceMap;
 }>;
 declare function __unstable__loadDesignSystem(css: string, opts?: CompileOptions): Promise<DesignSystem>;
 declare function postcssPluginWarning(): void;
 
-export { type Config, Features, Polyfills, __unstable__loadDesignSystem, compile, compileAst, postcssPluginWarning as default };
+export { type Config, type DecodedSourceMap, Features, Polyfills, __unstable__loadDesignSystem, compile, compileAst, postcssPluginWarning as default };