@stacksjs/ts-css 0.1.4 → 0.3.1

package/dist/engine/parser.d.ts

@@ -0,0 +1,68 @@
+import type { AttributifyConfig, BracketSyntaxConfig, ParsedClass } from './types';
+/**
+ * Drop the module-level parse caches. Exposed for long-lived hosts that want
+ * to reclaim the memory between builds; correctness never depends on it.
+ */
+export declare function clearParseCaches(): void;
+/**
+ * Expand bracket/grouped syntax into individual class names
+ * e.g., flex[col jc-center ai-center] -> ['flex-col', 'justify-center', 'items-center']
+ * e.g., text[white 2rem 700] -> ['text-white', 'text-[2rem]', 'font-bold']
+ * e.g., h[min 100vh] -> ['min-h-[100vh]']
+ * e.g., hover:flex[col] -> ['hover:flex-col']
+ * e.g., flex[md:col lg:row] -> ['md:flex-col', 'lg:flex-row']
+ * e.g., -m[4] or m[-4] -> ['-m-4']
+*/
+export declare function expandBracketSyntax(className: string, config?: BracketSyntaxConfig): string[];
+/**
+ * Extract classes from attributify syntax
+ * e.g., <div tc-flex tc-items-center tc-bg="blue-500" tc-p="4">
+ * Returns classes like: flex, items-center, bg-blue-500, p-4
+ *
+ * Also supports variant attributes:
+ * e.g., <div tc-hover:bg="blue-600" tc-dark:text="white">
+ * Returns classes like: hover:bg-blue-600, dark:text-white
+*/
+export declare function extractAttributifyClasses(content: string, config?: AttributifyConfig): Set<string>;
+/**
+ * Parses a utility class string into its components
+ * Examples: "p-4" -> {raw: "p-4", variants: [], utility: "p", value: "4", important: false, arbitrary: false}
+ *          "hover:bg-blue-500" -> {raw: "hover:bg-blue-500", variants: ["hover"], utility: "bg", value: "blue-500", important: false, arbitrary: false}
+ *          "!p-4" -> {raw: "!p-4", variants: [], utility: "p", value: "4", important: true, arbitrary: false}
+ *          "w-[100px]" -> {raw: "w-[100px]", variants: [], utility: "w", value: "100px", important: false, arbitrary: true}
+*/
+export declare function parseClass(className: string): ParsedClass;
+/**
+ * Extracts all utility classes from content
+ * Matches class patterns in HTML/JSX attributes and template strings
+ * Supports bracket syntax (e.g., flex[col jc-center]) and attributify mode
+*/
+export declare function extractClasses(content: string, options?: ExtractClassesOptions): Set<string>;
+/**
+ * Options for class extraction
+*/
+export declare interface ExtractClassesOptions {
+  attributify?: AttributifyConfig
+  bracketSyntax?: BracketSyntaxConfig
+  codeStrings?: CodeStringsConfig
+}
+/**
+ * Extraction from string literals in code, not just from class attributes.
+ *
+ * Utility classes routinely live in code rather than in markup: a helper that
+ * returns a class string, a lookup table of icons keyed by status, a signal
+ * holding the current variant. Attribute-scoped extraction cannot see any of
+ * it, so those classes silently never generate and the element renders
+ * unstyled — with no error, because nothing went wrong as far as the build is
+ * concerned.
+ *
+ * The failure is quiet enough that projects tend to work around it instead of
+ * reporting it: pre-generating a whole icon stylesheet, restating class names
+ * in a dummy attribute, or moving state into `data-` attributes and styling
+ * those instead. All of that goes away if the scanner reads the strings.
+ *
+ * Only *compound* tokens are taken from code — see `isCodeStringCandidate`.
+ */
+export declare interface CodeStringsConfig {
+  enabled?: boolean
+}

package/dist/engine/plugin.d.ts

@@ -0,0 +1,22 @@
+import type { BunPlugin } from 'bun';
+import type { TsCssOptions } from './types';
+/**
+ * Crosswind Bun plugin for processing HTML files
+ *
+ * @example
+ * ```typescript
+ * import { plugin } from '@ts-css/core'
+ *
+ * await Bun.build({
+ *   entrypoints: ['./src/index.ts'],
+ *   outdir: './dist',
+ *   plugins: [plugin()],
+ * })
+ * ```
+*/
+export declare function plugin(options?: TsCssPluginOptions): BunPlugin;
+export declare interface TsCssPluginOptions {
+  config?: TsCssOptions
+  includePreflight?: boolean
+}
+export default plugin;

package/dist/engine/preflight-forms.d.ts

@@ -0,0 +1,6 @@
+import type { Preflight } from './types';
+/**
+ * Tailwind Forms preflight styles
+ * Provides default styling for form elements to make them easy to customize with utilities
+*/
+export declare const tailwindFormsPreflight: Preflight;

package/dist/engine/preflight.d.ts

@@ -0,0 +1,3 @@
+import type { Preflight } from './types';
+export declare const modernNormalize: Preflight;
+export declare const tailwindPreflight: Preflight;

package/dist/engine/rules-advanced.d.ts

@@ -0,0 +1,27 @@
+import type { UtilityRule } from './rules';
+// Min/Max sizing
+export declare const minMaxSizingRule: UtilityRule;
+// Ring utilities
+export declare const ringRule: UtilityRule;
+// Border opacity utility
+export declare const borderOpacityRule: UtilityRule;
+// Space utilities (child spacing)
+export declare const spaceRule: UtilityRule;
+// Border style utilities
+export declare const borderStyleRule: UtilityRule;
+// Divide utilities (borders between children)
+export declare const divideRule: UtilityRule;
+// Gradient color stops
+export declare const gradientStopsRule: UtilityRule;
+// Flex order
+export declare const flexOrderRule: UtilityRule;
+// Flex basis
+export declare const flexBasisRule: UtilityRule;
+// Justify/Align self
+export declare const justifySelfRule: UtilityRule;
+export declare const alignSelfRule: UtilityRule;
+// Container utility with responsive max-widths
+export declare const containerRule: UtilityRule;
+// Arbitrary properties
+export declare const arbitraryPropertyRule: UtilityRule;
+export declare const advancedRules: UtilityRule[];

package/dist/engine/rules-effects.d.ts

@@ -0,0 +1,35 @@
+import type { UtilityRule } from './rules';
+// =============================================================================
+// Backgrounds, Borders, Effects utilities
+// =============================================================================
+// Background utilities
+export declare const backgroundAttachmentRule: UtilityRule;
+export declare const backgroundClipRule: UtilityRule;
+/**
+ * Linear gradients. `bg-linear-*` is Tailwind v4's name for `bg-gradient-*`;
+ * both spellings are accepted so v3 markup keeps working.
+ *
+ * Three shapes reach here with different parses:
+ *   bg-linear-to-r        utility `bg`,        value `linear-to-r`
+ *   -bg-linear-45         utility `bg`,        value `-linear-45`
+ *   bg-linear-[0.25turn]  utility `bg-linear`, value `0.25turn` (arbitrary)
+ */
+export declare const backgroundImageRule: UtilityRule;
+export declare const backgroundOriginRule: UtilityRule;
+export declare const backgroundPositionRule: UtilityRule;
+export declare const backgroundRepeatRule: UtilityRule;
+export declare const backgroundSizeRule: UtilityRule;
+// Border utilities
+export declare const borderStyleRule: UtilityRule;
+export declare const outlineRule: UtilityRule;
+// Effect utilities
+export declare const boxShadowThemeRule: UtilityRule;
+// Shadow color utilities (shadow-{color}, shadow-{color}/{opacity})
+export declare const shadowColorRule: UtilityRule;
+export declare const textShadowRule: UtilityRule;
+export declare const opacityRule: UtilityRule;
+export declare const mixBlendModeRule: UtilityRule;
+export declare const backgroundBlendModeRule: UtilityRule;
+// Mask utilities
+export declare const maskRule: UtilityRule;
+export declare const effectsRules: UtilityRule[];

package/dist/engine/rules-forms.d.ts

@@ -0,0 +1,8 @@
+import type { UtilityRule } from './rules';
+export declare const formInputRule: UtilityRule;
+export declare const formTextareaRule: UtilityRule;
+export declare const formSelectRule: UtilityRule;
+export declare const formMultiselectRule: UtilityRule;
+export declare const formCheckboxRule: UtilityRule;
+export declare const formRadioRule: UtilityRule;
+export declare const formsRules: UtilityRule[];

package/dist/engine/rules-grid.d.ts

@@ -0,0 +1,13 @@
+import type { UtilityRule } from './rules';
+export declare const gridTemplateColumnsRule: UtilityRule;
+export declare const gridColumnRule: UtilityRule;
+export declare const gridTemplateRowsRule: UtilityRule;
+export declare const gridRowRule: UtilityRule;
+export declare const gridAutoFlowRule: UtilityRule;
+export declare const gridAutoColumnsRule: UtilityRule;
+export declare const gridAutoRowsRule: UtilityRule;
+export declare const gapRule: UtilityRule;
+export declare const placeContentRule: UtilityRule;
+export declare const placeItemsRule: UtilityRule;
+export declare const placeSelfRule: UtilityRule;
+export declare const gridRules: UtilityRule[];

package/dist/engine/rules-icons.d.ts

@@ -0,0 +1,2 @@
+import type { UtilityRule } from './rules';
+export declare const iconRule: UtilityRule;

package/dist/engine/rules-interactivity.d.ts

@@ -0,0 +1,41 @@
+import type { UtilityRule } from './rules';
+// Filter utilities
+export declare const filterRule: UtilityRule;
+export declare const backdropFilterRule: UtilityRule;
+// Table utilities
+export declare const borderCollapseRule: UtilityRule;
+export declare const borderSpacingRule: UtilityRule;
+export declare const tableLayoutRule: UtilityRule;
+export declare const captionSideRule: UtilityRule;
+// Interactivity utilities
+export declare const accentColorRule: UtilityRule;
+export declare const appearanceRule: UtilityRule;
+export declare const caretColorRule: UtilityRule;
+export declare const colorSchemeRule: UtilityRule;
+export declare const fieldSizingRule: UtilityRule;
+export declare const cursorRule: UtilityRule;
+export declare const pointerEventsRule: UtilityRule;
+export declare const resizeRule: UtilityRule;
+export declare const scrollBehaviorRule: UtilityRule;
+export declare const scrollMarginRule: UtilityRule;
+export declare const scrollPaddingRule: UtilityRule;
+export declare const scrollSnapRule: UtilityRule;
+export declare const touchActionRule: UtilityRule;
+export declare const userSelectRule: UtilityRule;
+export declare const willChangeRule: UtilityRule;
+// SVG utilities
+export declare const fillRule: UtilityRule;
+export declare const strokeRule: UtilityRule;
+export declare const strokeWidthRule: UtilityRule;
+// SVG stroke-dasharray
+export declare const strokeDasharrayRule: UtilityRule;
+// SVG stroke-dashoffset
+export declare const strokeDashoffsetRule: UtilityRule;
+// SVG stroke-linecap
+export declare const strokeLinecapRule: UtilityRule;
+// SVG stroke-linejoin
+export declare const strokeLinejoinRule: UtilityRule;
+// Accessibility
+export declare const screenReaderRule: UtilityRule;
+export declare const forcedColorAdjustRule: UtilityRule;
+export declare const interactivityRules: UtilityRule[];

package/dist/engine/rules-layout.d.ts

@@ -0,0 +1,28 @@
+import type { UtilityRule } from './rules';
+// Layout utilities
+export declare const aspectRatioRule: UtilityRule;
+export declare const columnsRule: UtilityRule;
+// Column fill
+export declare const columnFillRule: UtilityRule;
+// Column gap (different from grid gap)
+export declare const columnGapRule: UtilityRule;
+// Column rule (border between columns)
+export declare const columnRuleRule: UtilityRule;
+// Column span
+export declare const columnSpanRule: UtilityRule;
+export declare const breakRule: UtilityRule;
+export declare const boxDecorationRule: UtilityRule;
+export declare const boxSizingRule: UtilityRule;
+export declare const floatRule: UtilityRule;
+export declare const clearRule: UtilityRule;
+export declare const isolationRule: UtilityRule;
+export declare const containRule: UtilityRule;
+export declare const objectFitRule: UtilityRule;
+export declare const objectPositionRule: UtilityRule;
+export declare const overflowRule: UtilityRule;
+export declare const overscrollRule: UtilityRule;
+export declare const positionRule: UtilityRule;
+export declare const insetRule: UtilityRule;
+export declare const visibilityRule: UtilityRule;
+export declare const zIndexRule: UtilityRule;
+export declare const layoutRules: UtilityRule[];

package/dist/engine/rules-transforms.d.ts

@@ -0,0 +1,35 @@
+import type { UtilityRule } from './rules';
+export declare const TRANSFORM_2D: string;
+export declare const TRANSFORM_3D: string;
+export declare const transformRule: UtilityRule;
+export declare const scaleRule: UtilityRule;
+export declare const rotateRule: UtilityRule;
+export declare const translateRule: UtilityRule;
+export declare const skewRule: UtilityRule;
+export declare const transformOriginRule: UtilityRule;
+export declare const perspectiveRule: UtilityRule;
+export declare const perspectiveOriginRule: UtilityRule;
+export declare const backfaceVisibilityRule: UtilityRule;
+export declare const transformStyleRule: UtilityRule;
+// Transition utilities
+export declare const transitionPropertyRule: UtilityRule;
+export declare const transitionDurationRule: UtilityRule;
+export declare const transitionTimingRule: UtilityRule;
+export declare const transitionDelayRule: UtilityRule;
+export declare const transitionBehaviorRule: UtilityRule;
+export declare const animationRule: UtilityRule;
+// Animation play state
+export declare const animationPlayStateRule: UtilityRule;
+// Animation direction
+export declare const animationDirectionRule: UtilityRule;
+// Animation fill mode
+export declare const animationFillModeRule: UtilityRule;
+// Animation iteration count
+export declare const animationIterationRule: UtilityRule;
+// Animation duration
+export declare const animationDurationRule: UtilityRule;
+// Animation delay
+export declare const animationDelayRule: UtilityRule;
+// Animation timing function
+export declare const animationTimingRule: UtilityRule;
+export declare const transformsRules: UtilityRule[];

package/dist/engine/rules-typography.d.ts

@@ -0,0 +1,47 @@
+import type { UtilityRule } from './rules';
+// Typography utilities
+export declare const fontFamilyRule: UtilityRule;
+export declare const fontSmoothingRule: UtilityRule;
+export declare const fontStyleRule: UtilityRule;
+export declare const fontStretchRule: UtilityRule;
+export declare const fontVariantNumericRule: UtilityRule;
+export declare const letterSpacingRule: UtilityRule;
+export declare const lineClampRule: UtilityRule;
+export declare const listStyleImageRule: UtilityRule;
+export declare const listStylePositionRule: UtilityRule;
+export declare const listStyleTypeRule: UtilityRule;
+export declare const textDecorationRule: UtilityRule;
+export declare const underlineOffsetRule: UtilityRule;
+export declare const textTransformRule: UtilityRule;
+export declare const textOverflowRule: UtilityRule;
+export declare const textWrapRule: UtilityRule;
+export declare const textIndentRule: UtilityRule;
+export declare const verticalAlignRule: UtilityRule;
+export declare const whiteSpaceRule: UtilityRule;
+export declare const wordBreakRule: UtilityRule;
+export declare const overflowWrapRule: UtilityRule;
+/**
+ * `tab-<integer>` / `tab-[<value>]` — the size of a tab character.
+ * Only integers and lengths are valid; an unknown word is not a tab size.
+ */
+export declare const tabSizeRule: UtilityRule;
+export declare const hyphensRule: UtilityRule;
+export declare const contentRule: UtilityRule;
+export declare const lineHeightRule: UtilityRule;
+// Writing mode
+export declare const writingModeRule: UtilityRule;
+// Text orientation
+export declare const textOrientationRule: UtilityRule;
+// Direction (ltr/rtl)
+export declare const directionRule: UtilityRule;
+// Text emphasis
+export declare const textEmphasisRule: UtilityRule;
+// Text emphasis color
+export declare const textEmphasisColorRule: UtilityRule;
+// Word spacing
+export declare const wordSpacingRule: UtilityRule;
+// Font variant caps
+export declare const fontVariantCapsRule: UtilityRule;
+// Font variant ligatures
+export declare const fontVariantLigaturesRule: UtilityRule;
+export declare const typographyRules: UtilityRule[];

package/dist/engine/rules.d.ts

@@ -0,0 +1,56 @@
+import type { TsCssConfig, ParsedClass, UtilityRuleResult } from './types';
+// Resolve a size/spacing token shared by the sizing utilities: fractions,
+// keyword map, theme spacing, off-scale numbers (0.25rem steps), and
+// arbitrary values. Unknown words return undefined — they previously
+// leaked verbatim (`w-sidebar` emitted `width: sidebar;`).
+export declare function resolveSizeToken(parsed: { value?: string, arbitrary: boolean }, config: { theme: { spacing: Record<string, string> } }, sizeMap: Record<string, string>): string | undefined;
+// Helper to apply opacity to color
+export declare function applyOpacity(color: string, opacity: number): string;
+/**
+ * Shared helper: resolve a color value (with optional opacity) from theme config.
+ * Handles: special keywords, direct colors, color-shade, opacity modifiers (/50, /[0.04]).
+ * Returns the resolved CSS color string or undefined if not found.
+ */
+export declare function resolveColorValue(value: string, config: { theme: { colors: Record<string, any> } }, modifierArbitrary?: boolean): string | undefined;
+/**
+ * Built-in utility rules
+ * Each rule checks if it matches the parsed class and returns CSS properties
+*/
+// Display utilities
+export declare const displayRule: UtilityRule;
+// Scrollbar utilities
+export declare const scrollbarRule: UtilityRule;
+// Content property for pseudo-elements: content-none, content-empty, content-['hello']
+export declare const contentPropertyRule: UtilityRule;
+// Container utilities (for container queries)
+export declare const containerRule: UtilityRule;
+// Flexbox utilities
+export declare const flexDirectionRule: UtilityRule;
+export declare const flexWrapRule: UtilityRule;
+export declare const flexRule: UtilityRule;
+export declare const flexGrowRule: UtilityRule;
+export declare const flexShrinkRule: UtilityRule;
+export declare const justifyContentRule: UtilityRule;
+export declare const alignItemsRule: UtilityRule;
+export declare const justifyItemsRule: UtilityRule;
+export declare const alignContentRule: UtilityRule;
+// Spacing utilities (margin, padding)
+export declare const spacingRule: UtilityRule;
+// Width and height utilities
+export declare const sizingRule: UtilityRule;
+export declare const colorRule: UtilityRule;
+// Placeholder color utilities (placeholder-{color})
+export declare const placeholderColorRule: UtilityRule;
+// Typography utilities
+export declare const fontSizeRule: UtilityRule;
+export declare const fontWeightRule: UtilityRule;
+export declare const leadingRule: UtilityRule;
+export declare const textAlignRule: UtilityRule;
+// Border utilities
+export declare const borderWidthRule: UtilityRule;
+// Border side width utilities (border-t-0, border-r-2, border-x-4, etc.)
+export declare const borderSideWidthRule: UtilityRule;
+export declare const borderRadiusRule: UtilityRule;
+// Export all rules (order matters - more specific rules first)
+export declare const builtInRules: UtilityRule[];
+export type UtilityRule = (_parsed: ParsedClass, _config: TsCssConfig) => Record<string, string> | UtilityRuleResult | undefined;

package/dist/engine/scanner.d.ts

@@ -0,0 +1,16 @@
+import type { CompileClassTransformer } from './transformer-compile-class';
+import type { ExtractClassesOptions } from './parser';
+export declare interface ScanResult {
+  classes: Set<string>
+  transformedFiles: Map<string, string>
+  unmatchedPatterns: string[]
+}
+/**
+ * Scans files for utility classes using Bun's fast Glob API
+*/
+export declare class Scanner {
+  constructor(patterns: string[], transformer?: CompileClassTransformer | null | undefined, extractOptions?: ExtractClassesOptions | undefined);
+  scan(): Promise<ScanResult>;
+  scanFile(filePath: string): Promise<Set<string>>;
+  scanContent(content: string): Set<string>;
+}

package/dist/engine/style/api.d.ts

@@ -0,0 +1,95 @@
+import type { CreatedStyles, KeyframeDefinition, StyleArg, StyleProps, StyleRule, VarGroup, VarValue } from './types';
+/**
+ * Compiles named style objects into atomic class names.
+ *
+ * Every declaration becomes its own class, deduplicated across the whole
+ * program by content hash, so two components that both say `padding: 16`
+ * share one rule.
+ *
+ * @example
+ * ```ts
+ * const styles = css.create({
+ *   card: { padding: 16, ':hover': { transform: 'translateY(-2px)' } },
+ *   danger: { color: 'red' },
+ *   sized: (width: number) => ({ width }),
+ * })
+ * ```
+ */
+export declare function create<T extends Record<string, StyleRule | ((...args: any[]) => StyleRule)>>(styles: T): CreatedStyles<T>;
+/**
+ * Merges compiled styles into the props an element needs.
+ *
+ * Later arguments win, property by property — not class by class — so
+ * `props(base, override)` behaves like object spread rather than like the
+ * cascade. Falsy arguments are skipped, which makes conditional styles read
+ * as `isActive && styles.active`.
+ *
+ * @example
+ * ```ts
+ * <div {...css.props(styles.card, isActive && styles.active)} />
+ * ```
+ */
+export declare function props(...args: StyleArg[]): StyleProps;
+/**
+ * Declares a group of CSS custom properties and returns `var(…)` references
+ * for each, ready to drop into any style object.
+ *
+ * A value may itself be conditional, which is how a theme responds to the
+ * viewer's colour scheme without any style needing to know about it.
+ *
+ * @example
+ * ```ts
+ * export const theme = css.defineVars({
+ *   accent: '#0b7',
+ *   surface: { default: '#fff', '@media (prefers-color-scheme: dark)': '#111' },
+ * })
+ * ```
+ */
+export declare function defineVars<T extends Record<string, VarValue>>(vars: T): VarGroup<T>;
+/**
+ * Re-declares an existing variable group under a generated class name.
+ *
+ * Put the returned class on any element and every style beneath it that reads
+ * those variables picks up the override — theming without threading props.
+ *
+ * @example
+ * ```ts
+ * const dark = css.createTheme(theme, { surface: '#111' })
+ * <section className={dark}>…</section>
+ * ```
+ */
+export declare function createTheme<T extends Record<string, string>>(vars: T, overrides: Partial<Record<keyof T, string | number>>): string;
+/**
+ * Declares an `@keyframes` animation and returns its generated name.
+ *
+ * @example
+ * ```ts
+ * const fade = css.keyframes({ from: { opacity: 0 }, to: { opacity: 1 } })
+ * const styles = css.create({ intro: { animationName: fade } })
+ * ```
+ */
+export declare function keyframes(definition: KeyframeDefinition): string;
+/**
+ * Declares a value with progressive-enhancement fallbacks.
+ *
+ * Returns the values in CSS fallback order — least-supported last — so a
+ * browser that understands `position: sticky` uses it and one that doesn't
+ * keeps the previous declaration.
+ *
+ * @example
+ * ```ts
+ * css.create({ bar: { position: css.firstThatWorks('sticky', '-webkit-sticky', 'fixed') } })
+ * ```
+ */
+export declare function firstThatWorks<T extends string>(...values: T[]): T[];
+/**
+ * Freezes build-time constants — media query strings, spacing scales — that
+ * styles reference but that never become CSS of their own.
+ *
+ * @example
+ * ```ts
+ * const breakpoints = css.defineConsts({ md: '@media (min-width: 768px)' })
+ * css.create({ grid: { [breakpoints.md]: { display: 'grid' } } })
+ * ```
+ */
+export declare function defineConsts<T extends Record<string, string | number>>(consts: T): Readonly<T>;

package/dist/engine/style/collect.d.ts

@@ -0,0 +1,10 @@
+/*.styles.ts'])
+ * await Bun.write('./dist/styles.css', css)
+ * ```
+ */
+export declare function collectStyles(patterns: string[], options?: { minify?: boolean, cwd?: string }): Promise<CollectResult>;
+export declare interface CollectResult {
+  css: string
+  modules: string[]
+  unmatchedPatterns: string[]
+}

package/dist/engine/style/evaluate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Imports a module for its style side effects, defeating the module cache
+ * when — and only when — the result would otherwise be wrong.
+ *
+ * Styles register themselves while their module evaluates, and a module
+ * evaluates once per specifier. Two things therefore have to reach the
+ * specifier: the file's mtime, so an edit re-registers the module's rules
+ * during a watch rebuild; and the registry generation, so a reset re-runs
+ * every module instead of leaving the registry permanently empty.
+ */
+export declare function importStyleModule(path: string): Promise<void>;

package/dist/engine/style/hash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 40-bit hash rendered in base36 (8 chars or fewer).
+ *
+ * 32 bits alone collides at roughly 1-in-300 across 5k atomic rules — well
+ * inside the range a real design system hits — so a second seeded pass adds
+ * another byte, taking that to ~1-in-100,000.
+ */
+export declare function hashString(input: string): string;
+/**
+ * Class names must start with a letter, so every hash is prefixed. The
+ * default `tc` matches the framework's `tc-` class prefix while staying
+ * distinct from it — compiled utility groups are `tc-<hash>`, atomic style
+ * classes are `tc<hash>`, and the two can never collide.
+ */
+export declare function hashedClassName(input: string, prefix?: string): string;

package/dist/engine/style/index.d.ts

@@ -0,0 +1,56 @@
+import { create, createTheme, defineConsts, defineVars, firstThatWorks, keyframes, props } from './api';
+import { renderStyles, resetStyles } from './registry';
+export type { AtomicRule, KeyframesRule, VarRule } from './registry';
+export type {
+  CompiledStyle,
+  CreatedStyles,
+  DynamicStyle,
+  KeyframeDefinition,
+  StyleArg,
+  StyleProps,
+  StyleRule,
+  StyleValue,
+  VarGroup,
+  VarValue,
+} from './types';
+/**
+ * Namespaced entry point, so call sites read as prose.
+ *
+ * @example
+ * ```ts
+ * import { css } from '@ts-css/core'
+ *
+ * const styles = css.create({ card: { padding: 16 } })
+ * <div {...css.props(styles.card)} />
+ * ```
+ */
+export declare const css: {
+  create: typeof create
+  props: typeof props
+  defineVars: typeof defineVars
+  defineConsts: typeof defineConsts
+  createTheme: typeof createTheme
+  keyframes: typeof keyframes
+  firstThatWorks: typeof firstThatWorks
+  render: typeof renderStyles
+  reset: typeof resetStyles
+};
+/**
+ * The style object API — typed, atomic, StyleX-shaped.
+ *
+ * Utility classes are unbeatable for the common case; they run out when a
+ * style has to be computed, shared as a token, or merged predictably across
+ * component boundaries. This is the escape hatch, and it compiles to the same
+ * atomic CSS the utility engine emits.
+ */
+export {
+  create,
+  createTheme,
+  defineConsts,
+  defineVars,
+  firstThatWorks,
+  keyframes,
+  props,
+} from './api';
+export { hashedClassName, hashString } from './hash';
+export { renderStyles, resetStyles, styleCount } from './registry';

package/dist/engine/style/plugin.d.ts

@@ -0,0 +1,27 @@
+import type { BunPlugin } from 'bun';
+/**
+ * Bun plugin that collects `css.create()` styles during a build.
+ *
+ * Style modules register their rules when they evaluate, so the plugin
+ * imports each matching module as the bundler loads it and writes the
+ * accumulated stylesheet out. Sources pass through untouched — the class
+ * names are already plain strings by the time the bundler sees them.
+ *
+ * @example
+ * ```ts
+ * await Bun.build({
+ *   entrypoints: ['./src/index.tsx'],
+ *   outdir: './dist',
+ *   plugins: [stylePlugin({ output: './dist/styles.css', minify: true })],
+ * })
+ * ```
+ */
+export declare function stylePlugin(options?: StylePluginOptions): BunPlugin;
+export declare interface StylePluginOptions {
+  include?: RegExp
+  styleModules?: string[]
+  output?: string
+  minify?: boolean
+  onCSS?: (css: string) => void | Promise<void>
+}
+export default stylePlugin;

package/dist/engine/style/priority.d.ts

@@ -0,0 +1,12 @@
+export declare function propertyPriority(property: string): number;
+/**
+ * A condition is an at-rule (`@media …`), a pseudo-element (`::before`) or a
+ * pseudo-class / nested selector (`:hover`, `&[data-open] &`).
+ */
+export declare function conditionPriority(condition: string): number;
+/**
+ * Property class dominates: a longhand always beats a shorthand, however
+ * deeply the shorthand is nested. Conditions only order rules that set the
+ * same property.
+ */
+export declare function rulePriority(property: string, conditions: readonly string[]): number;