@teacss/core 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,1555 @@
+//#region src/condition.d.ts
+/**
+ * The `@` condition axis — the spine of the v0 language.
+ *
+ * In TeaCSS, `@` unifies every "selector / condition relative to `&` (the classed
+ * element)": pseudo-classes, pseudo-elements, target combinators, relations, media,
+ * and arbitrary selectors are all the same axis. A token may carry many `@cond`
+ * segments; they are always AND (there is no OR), and the rightmost element is the
+ * one styled. See `docs/proposals/v00-teacss.md` for the current language contract.
+ *
+ * This module is the **core parsing primitive**, consistent with `parseClassToken`:
+ * it classifies each condition by first-character dispatch, resolves the
+ * purely-structural kinds (self-class/id, pseudo-element, target combinator) itself,
+ * and routes everything it cannot resolve — named conditions (`hover`, `md`,
+ * `group-hover`, `media(...)`) and arbitrary selectors (`[…]`) — through a
+ * **resolver hook** so presets can register named and arbitrary-selector
+ * vocabulary without moving that vocabulary into core.
+ *
+ * Core owns the mechanism (classification, the hook registry, canonical assembly);
+ * presets own the vocabulary.
+ */
+/** How an `@cond` segment is classified by its first character (after a NOT `!`). */
+type ConditionKind =
+/** `@.cls` / `@#id` — a class/id on the subject itself. */
+"self" |
+/** `@::after` — a pseudo-element on the subject. */
+"pseudo-element" |
+/** `@>li` `@_p` `@+span` `@~span` `@>*` — a combinator + target; the target is styled. */
+"target" |
+/** `@[…]` — an arbitrary selector (`&` implicit). Resolved by a hook. */
+"arbitrary" |
+/** Letter-first: a named condition (pseudo-class / media / relation / breakpoint / at-rule). Resolved by hooks. */
+"named";
+/** A single `@cond` segment parsed into structured form (no CSS resolved yet). */
+interface ParsedCondition {
+  /** The segment without its leading `@`, exactly as written (e.g. `hover`, `.is-dragging`, `>li:hover`, `!disabled`). */
+  raw: string;
+  kind: ConditionKind;
+  /** True when the segment began with `!` (NOT). The `!` is stripped from `value`. */
+  negate: boolean;
+  /** The classification payload, after stripping a leading `!` (e.g. `hover`, `.is-dragging`, `>li:hover`, `[…]`). */
+  value: string;
+}
+/**
+ * Classify a single condition segment (without its leading `@`).
+ *
+ * Pure and total. A leading `!` sets `negate` and is stripped before dispatch.
+ * First-character dispatch follows the current condition grammar:
+ *   `::` → pseudo-element · `.`/`#` → self · `> _ + ~` → target · `[` → arbitrary · else → named.
+ */
+declare function parseCondition(raw: string): ParsedCondition;
+/** Classify a list of condition segments (e.g. `ParsedClassToken.conditions`). */
+declare function parseConditions(conditions: string[]): ParsedCondition[];
+/**
+ * The contribution of one resolved condition to the final rule, split by role so
+ * assembly can place each part canonically (selector-first), independent of the
+ * order conditions were written in.
+ */
+interface ResolvedCondition {
+  /** Ancestor prepended before the subject, e.g. `.group:hover `. */
+  prefix?: string;
+  /** Combinator + target appended after the subject, shifting the styled element, e.g. ` > li`. */
+  combinator?: string;
+  /** Appended directly to the subject, e.g. `:hover`, `.is-dragging`, `[data-open]`. */
+  suffix?: string;
+  /** Pseudo-element on the styled element, e.g. `::after`. At most one per token. */
+  pseudoElement?: string;
+  /** At-rule wrapping the whole rule, e.g. `@media (min-width: 48rem)`. */
+  parent?: string;
+}
+/** Context handed to resolver hooks. */
+interface ConditionResolveContext {
+  /** The full parsed condition list, for hooks that need siblings (e.g. named container). */
+  conditions: ParsedCondition[];
+  /** The resolved theme, for hooks whose vocabulary is theme-driven (e.g. breakpoints). */
+  theme?: object;
+}
+/**
+ * A resolver hook. Returns a {@link ResolvedCondition} when it handles `cond`,
+ * or `undefined` to defer to the next hook. Presets register hooks for named
+ * and arbitrary conditions.
+ */
+type ConditionResolver = (cond: ParsedCondition, ctx: ConditionResolveContext) => ResolvedCondition | undefined;
+interface ResolveConditionsResult {
+  /** Conditions resolved to structured contributions (by core or a hook). */
+  resolved: ResolvedCondition[];
+  /** Conditions no hook handled — surfaced so callers/tests can detect missing vocabulary. */
+  unresolved: ParsedCondition[];
+}
+/**
+ * Resolve a list of parsed conditions. Core resolves the structural kinds; the
+ * arbitrary and named kinds are offered to `resolvers` in order (first match wins).
+ * Anything left over is returned in `unresolved` (it stays unresolved until a
+ * feature registers a hook for it).
+ *
+ * Enforces at most one pseudo-element per token.
+ */
+declare function resolveConditions(conditions: ParsedCondition[], resolvers?: ConditionResolver[], theme?: object): ResolveConditionsResult;
+interface BuiltConditionSelector {
+  /** The assembled selector, e.g. `.group:hover .bg\:red:hover > li`. */
+  selector: string;
+  /** At-rule parents wrapping the rule, outermost-last (e.g. `["@media (min-width: 48rem)"]`). */
+  parents: string[];
+}
+/**
+ * Assemble resolved conditions onto a subject selector, canonically (selector-first):
+ *
+ *   `<prefixes><subject><suffixes><combinators><pseudoElement>`, wrapped by `<parents>`.
+ *
+ * Assembly canonicalizes conditions that contribute different roles, so
+ * `a@_svg@group-hover@md` and `a@md@group-hover@_svg` produce the same selector
+ * + parents. Conditions within the same role retain their authored order.
+ */
+declare function buildConditionSelector(subject: string, resolved: ResolvedCondition[]): BuiltConditionSelector;
+//#endregion
+//#region src/utils/basic.d.ts
+type ToArrayResult<T> = T extends any[] ? T[number][] : T extends readonly (infer U)[] ? readonly U[] : T[];
+declare function toArray<T = never>(): T[];
+declare function toArray(value: undefined): [];
+declare function toArray<T>(value: T): ToArrayResult<T>;
+declare function uniq<T>(value: T[]): T[];
+declare function uniqueBy<T>(array: readonly T[], equalFn: (a: T, b: T) => boolean): T[];
+declare function isString(s: any): s is string;
+//#endregion
+//#region src/utils/countable-set.d.ts
+declare class CountableSet<K> extends Set<K> {
+  _map: Map<K, number>;
+  constructor(values?: Iterable<K>);
+  add(key: K): this;
+  delete(key: K): boolean;
+  clear(): void;
+  getCount(key: K): number;
+  setCount(key: K, count: number): this;
+}
+declare function isCountableSet<T = string>(value: any): value is CountableSet<T>;
+//#endregion
+//#region src/utils/escape.d.ts
+declare function escapeRegExp(string: string): string;
+/**
+ * CSS Selector Escape
+ */
+declare function escapeSelector(str: string): string;
+declare const e: typeof escapeSelector;
+//#endregion
+//#region src/utils/events.d.ts
+type EventsMap = Record<string, any>;
+interface DefaultEvents extends EventsMap {
+  [event: string]: (...args: any) => void;
+}
+type Unsubscribe = () => void;
+interface Emitter<Events extends EventsMap = DefaultEvents> {
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * ```js
+   * emitter1.events = emitter2.events
+   * emitter2.events = { }
+   * ```
+   */
+  events: Partial<{ [E in keyof Events]: Events[E][]; }>;
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on<K extends keyof Events>(this: this, event: K, cb: Events[K]): Unsubscribe;
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit<K extends keyof Events>(this: this, event: K, ...args: Parameters<Events[K]>): void;
+}
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import { createNanoEvents } from 'nanoevents'
+ *
+ * class Ticker {
+ *   constructor() {
+ *     this.emitter = createNanoEvents()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ */
+declare function createNanoEvents<Events extends EventsMap = DefaultEvents>(): Emitter<Events>;
+//#endregion
+//#region src/utils/helpers.d.ts
+declare const attributifyRE: RegExp;
+declare const cssIdRE: RegExp;
+declare const validateFilterRE: RegExp;
+declare function isAttributifySelector(selector: string): RegExpMatchArray | null;
+declare function isValidSelector(selector?: string): selector is string;
+declare function normalizeVariant(variant: Variant<any>): VariantObject<any>;
+declare function isRawUtil(util: ParsedUtil | RawUtil | StringifiedUtil): util is RawUtil;
+declare function notNull<T>(value: T | null | undefined): value is T;
+/**
+ * A value is a thenable (promise-like) — used to take a synchronous fast path on
+ * the per-token hot path: only genuinely-async handler/variant results are
+ * `await`ed, so the common all-synchronous case never allocates a microtask.
+ */
+declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
+declare function noop(): void;
+//#endregion
+//#region src/utils/layer.d.ts
+declare function withLayer<T extends object>(layer: string, rules: Rule<T>[]): Rule<T>[];
+//#endregion
+//#region src/utils/map.d.ts
+declare class TwoKeyMap<K1, K2, V> {
+  _map: Map<K1, Map<K2, V>>;
+  get(key1: K1, key2: K2): V | undefined;
+  getFallback(key1: K1, key2: K2, fallback: V): V;
+  set(key1: K1, key2: K2, value: V): this;
+  has(key1: K1, key2: K2): boolean;
+  delete(key1: K1, key2: K2): boolean;
+  deleteTop(key1: K1): boolean;
+  map<T>(fn: (v: V, k1: K1, k2: K2) => T): T[];
+}
+declare class BetterMap<K, V> extends Map<K, V> {
+  getFallback(key: K, fallback: V): V;
+  map<R>(mapFn: (value: V, key: K) => R): R[];
+  flatMap<R extends readonly unknown[]>(mapFn: (value: V, key: K) => R): R[number][];
+}
+//#endregion
+//#region src/utils/object.d.ts
+declare function normalizeCSSEntries(obj: string | CSSEntriesInput | CSSObjectInput): string | CSSEntriesInput;
+declare function normalizeCSSValues(obj: CSSValueInput | string | (CSSValueInput | string)[]): (string | CSSEntriesInput)[];
+declare function clearIdenticalEntries(entry: CSSEntriesInput): CSSEntries;
+declare const VirtualKey = "__virtual_key__";
+declare function entriesToCss(arr?: CSSEntriesInput): string;
+declare function isObject(item: any): item is Record<string, any>;
+/**
+ * Marker key on a patch object that forces a full replacement of the
+ * corresponding original value instead of a deep merge. An explicit
+ * `{ $reset: true, … }` replaces an entire category.
+ * The marker is stripped from output.
+ */
+declare const RESET_KEY = "$reset";
+/**
+ * Deep merge two objects.
+ *
+ * A patch object whose own `$reset` is truthy is treated as a *replacement*: the
+ * original value at that position is discarded and the patch (minus the `$reset`
+ * marker) is used as-is. This applies recursively, so a single theme category can
+ * opt out of deep-merging (`theme.colors = { $reset: true, ... }`).
+ */
+declare function mergeDeep<T>(original: T, patch: DeepPartial<T>, mergeArray?: boolean): T;
+declare function clone<T>(val: T): T;
+declare function isStaticRule(rule: Rule<any>): rule is StaticRule;
+declare function isStaticShortcut(sc: Shortcut<any>): sc is StaticShortcut;
+//#endregion
+//#region src/utils/source.d.ts
+declare function getPath(id: string): string;
+declare function isCssId(id: string): boolean;
+declare function hash(str: string): string;
+declare function transformSkipCode(code: string, map: Map<string, string>, SKIP_RULES_RE: RegExp, keyFlag: string): string;
+declare function restoreSkipCode(code: string, map: Map<string, string>): string;
+declare function replaceAsync(string: string, searchValue: RegExp, replacer: (substring: string, ...args: any[]) => Promise<string>): Promise<string>;
+//#endregion
+//#region src/utils/variant-group.d.ts
+declare function makeRegexClassGroup(separators?: string[]): RegExp;
+interface VariantGroup {
+  length: number;
+  items: HighlightAnnotation[];
+}
+declare function parseVariantGroup(str: string | MagicStringLike, separators?: string[], depth?: number): {
+  prefixes: string[];
+  hasChanged: boolean;
+  groupsByOffset: Map<number, VariantGroup>;
+  readonly expanded: string;
+};
+declare function collapseVariantGroup(str: string, prefixes: string[]): string;
+declare function expandVariantGroup(str: string, separators?: string[], depth?: number): string;
+declare function expandVariantGroup(str: MagicStringLike, separators?: string[], depth?: number): MagicStringLike;
+//#endregion
+//#region src/utils/warn.d.ts
+declare function warnOnce(msg: string): void;
+//#endregion
+//#region src/generator.d.ts
+declare const symbols: ControlSymbols;
+type ExpansionEntry<Theme extends object = object> = Shortcut<Theme>;
+type ExpansionResult = [(string | ExpansionInlineValue)[], RuleMeta | undefined];
+type ExpansionPrefixes = readonly (string | undefined)[];
+interface PreparedGeneratorConfig<Theme extends object = object> {
+  readonly config: ResolvedConfig<Theme>;
+  readonly defaults: UserConfigDefaults<Theme>;
+  /** Isolated generator for validating work against `config` before commit. */
+  readonly generator: TeacssGenerator<Theme>;
+  readonly userConfig: UserConfig<Theme>;
+  readonly version: number;
+}
+declare class TeacssGeneratorInternal<Theme extends object = object> {
+  userConfig: UserConfig<Theme>;
+  defaults: UserConfigDefaults<Theme>;
+  readonly version: string;
+  readonly events: Emitter<{
+    config: (config: ResolvedConfig<Theme>) => void;
+  }>;
+  config: ResolvedConfig<Theme>;
+  cache: Map<string, StringifiedUtil<Theme>[] | null>;
+  blocked: Set<string>;
+  parentOrders: Map<string, number>;
+  activatedRules: Set<Rule<Theme>>;
+  /** Property-prefix dispatch index for `config.rulesDynamic`, rebuilt when the config changes. */
+  private _dynamicIndex?;
+  private _contextConfigs;
+  private _expansionPrefixes;
+  private _generationContexts;
+  private _configVersion;
+  private _collectionGeneration;
+  private _preparedConfigs;
+  private _indexedRules?;
+  private _indexedRuleSnapshot?;
+  private _preparedCacheSnapshot?;
+  private _preparedConfigMutable;
+  private _preparedCacheReliable;
+  private _startingGenerationParse;
+  private _runtimeRevision;
+  private _variantCacheOwner;
+  private _initialization?;
+  private _constructedCSSResults;
+  private _constructedCSSSequence;
+  private _parsedOutputOrders;
+  private _rawUtilMetadata;
+  private _stringifiedCurrentSelectors;
+  private _stringifiedOutputOrders;
+  private _stringifiedParentOrders;
+  private _shortcutMergeOrders;
+  private _utilParentOrders;
+  private reportConfigObserverErrors;
+  private dispatchConfig;
+  private clearRuntimeCaches;
+  private ensureRuleIndexesCurrent;
+  private collectParentOrders;
+  private transferOutputOrder;
+  private recordStringifiedContext;
+  private copyStringifiedUtil;
+  private copyStringifiedUtils;
+  private getDynamicIndex;
+  protected constructor(userConfig?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>);
+  protected ensureInitialized(): Promise<void>;
+  private static constructPublic;
+  static create<Theme extends object = object>(userConfig?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): Promise<TeacssGeneratorInternal<Theme>>;
+  setConfig(userConfig?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): Promise<void>;
+  /** Resolve a candidate configuration without mutating this live generator. */
+  prepareConfig(userConfig: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): Promise<PreparedGeneratorConfig<Theme>>;
+  /** Commit a prepared configuration if no newer configuration request superseded it. */
+  commitConfig(prepared: PreparedGeneratorConfig<Theme>): boolean;
+  applyExtractors(code: string, id?: string, extracted?: Set<string>): Promise<Set<string>>;
+  applyExtractors(code: string, id?: string, extracted?: CountableSet<string>): Promise<CountableSet<string>>;
+  private applyExtractorsCurrent;
+  private applyExtractorsForConfig;
+  private requireInitialized;
+  private makeContextForConfig;
+  makeContext(raw: string, applied: VariantMatchedResult<Theme>): RuleContext<Theme>;
+  private getContextConfig;
+  parseToken(raw: string, alias?: string): Promise<StringifiedUtil<Theme>[] | undefined | null>;
+  private parseTokenInternal;
+  private parseTokenForGeneration;
+  /**
+   * Returns cached token names that currently emit the same declaration bodies as
+   * `raw`. Tooling uses this after generation has populated the parse cache, so
+   * references can include aliases without reading the cache's tuple shape.
+   */
+  getCachedEquivalentTokens(raw: string): string[];
+  generate(input: string | Set<string> | CountableSet<string> | string[], options?: GenerateOptions<false>): Promise<GenerateResult<Set<string>>>;
+  generate(input: string | Set<string> | CountableSet<string> | string[], options?: GenerateOptions<true>): Promise<GenerateResult<Map<string, ExtendedTokenInfo<Theme>>>>;
+  private generateInternal;
+  matchVariants(raw: string, current?: string): Promise<readonly VariantMatchedResult<Theme>[]>;
+  private matchVariantsCurrent;
+  private matchVariantsForConfig;
+  private applyVariants;
+  constructCustomCSS(context: Readonly<RuleContext<Theme>>, body: CSSObjectInput | CSSEntriesInput, overrideSelector?: string): string;
+  private constructNormalizedCSS;
+  parseUtil(input: string | VariantMatchedResult<Theme>, context: RuleContext<Theme>, internal?: boolean, shortcutPrefix?: string | string[] | undefined): Promise<(ParsedUtil | RawUtil)[] | undefined>;
+  private resolveCSSResult;
+  stringifyUtil(parsed?: ParsedUtil | RawUtil, context?: RuleContext<Theme>): StringifiedUtil<Theme>[] | undefined;
+  expandShortcut(input: string, context: RuleContext<Theme>, depth?: number): Promise<ExpansionResult | undefined>;
+  private expandMatchedShortcut;
+  expandConfiguredExpansions(input: string, context: RuleContext<Theme>, depth: number, entries: ExpansionEntry<Theme>[], label: "shortcut", fallback?: (input: string, context: RuleContext<Theme>, depth: number) => Promise<ExpansionResult | undefined>, inheritedPrefix?: string): Promise<ExpansionResult | undefined>;
+  private expandConfiguredExpansionsForInput;
+  stringifyShortcuts(parent: VariantMatchedResult<Theme>, context: RuleContext<Theme>, expanded: (string | ExpansionInlineValue)[], meta?: RuleMeta, matchedPrefixes?: ExpansionPrefixes): Promise<StringifiedUtil<Theme>[] | undefined>;
+  isBlocked(raw: string): boolean;
+  getBlocked(raw: string): [BlocklistValue, BlocklistMeta | undefined] | undefined;
+  private matchesBlocklist;
+}
+declare class TeacssGenerator<Theme extends object = object> extends TeacssGeneratorInternal<Theme> {
+  /**
+   * @deprecated `new TeacssGenerator` is deprecated, please use `createGenerator()` instead
+   */
+  constructor(userConfig?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>);
+}
+declare function createGenerator<Theme extends object = object>(config?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): Promise<TeacssGenerator<Theme>>;
+declare const regexScopePlaceholder: RegExp;
+declare function hasScopePlaceholder(css: string): boolean;
+declare function toEscapedSelector(raw: string): string;
+//#endregion
+//#region src/types.d.ts
+/**
+ * The subset of `magic-string`'s API that the transformer contract and variant-group
+ * expansion actually use. Typing against this keeps `magic-string` out of
+ * `@teacss/core`'s public types — a real `MagicString` satisfies it structurally,
+ * so the integration layer (which constructs one) still passes it directly, but
+ * consumers of `@teacss/core` don't inherit a dependency on `magic-string`.
+ */
+interface MagicStringLike {
+  readonly original: string;
+  slice(start?: number, end?: number): string;
+  toString(): string;
+  overwrite(start: number, end: number, content: string): MagicStringLike;
+  update(start: number, end: number, content: string): MagicStringLike;
+  remove(start: number, end: number): MagicStringLike;
+  appendLeft(index: number, content: string): MagicStringLike;
+  appendRight(index: number, content: string): MagicStringLike;
+}
+/** The result of resolving config from the CSS entry: the config + its source file(s). */
+interface LoadConfigResult<Config = any> {
+  config: Config;
+  sources: string[];
+}
+type Awaitable<T> = T | Promise<T>;
+type Arrayable<T> = T | T[];
+type ToArray<T> = T extends any[] ? T[number][] : T extends readonly (infer U)[] ? readonly U[] : T[];
+type ArgumentType<T> = T extends ((...args: infer A) => any) ? A : never;
+type Shift<T> = T extends [_: any, ...args: infer A] ? A : never;
+type RestArgs<T> = Shift<ArgumentType<T>>;
+type DeepPartial<T> = { [P in keyof T]?: DeepPartial<T[P]>; };
+type FlatObjectTuple<T> = { [K in keyof T]: T[K]; };
+type PartialByKeys<T, K extends keyof T = keyof T> = FlatObjectTuple<Partial<Pick<T, Extract<keyof T, K>>> & Omit<T, K>>;
+type RequiredByKey<T, K extends keyof T = keyof T> = FlatObjectTuple<Required<Pick<T, Extract<keyof T, K>>> & Omit<T, K>>;
+type CSSObject = Record<string, string | number | undefined>;
+/**
+ * [property, value, operators?]
+ *
+ * - operators: Used to perform specific operations on value or property.
+ */
+type CSSEntry = [string, string | number | undefined, Arrayable<string>?];
+type CSSEntries = CSSEntry[];
+type CSSObjectInput = CSSObject | Partial<ControlSymbolsValue>;
+type CSSEntriesInput = (CSSEntry | ControlSymbolsEntry)[];
+type CSSValueInput = CSSObjectInput | CSSEntriesInput | CSSValue;
+interface PresetOptions {
+  [key: string]: any;
+}
+interface RuleContext<Theme extends object = object> {
+  /**
+   * Unprocessed selector from user input.
+   * Useful for generating CSS rule.
+   */
+  rawSelector: string;
+  /**
+   * Current selector for rule matching
+   */
+  currentSelector: string;
+  /**
+   * Generator instance
+   */
+  generator: TeacssGenerator<Theme>;
+  /**
+   * Symbols for special handling
+   */
+  symbols: ControlSymbols;
+  /**
+   * The theme object
+   */
+  theme: Theme;
+  /**
+   * Matched variants handlers for this rule.
+   */
+  variantHandlers: VariantHandler[];
+  /**
+   * The result of variant matching.
+   */
+  variantMatch: VariantMatchedResult<Theme>;
+  /**
+   * Construct a custom CSS rule.
+   * Variants and selector escaping will be handled automatically.
+   */
+  constructCSS: (body: CSSEntriesInput | CSSObjectInput, overrideSelector?: string) => string;
+  /**
+   * Available only when `details` option is enabled.
+   */
+  rules?: Rule<Theme>[];
+  /**
+   * Available only when `details` option is enabled.
+   */
+  shortcuts?: Shortcut<Theme>[];
+  /**
+   * Available only when `details` option is enabled.
+   */
+  variants?: Variant<Theme>[];
+}
+declare const SymbolShortcutsNoMerge: unique symbol;
+declare const SymbolNoMerge: unique symbol;
+declare const SymbolNoScope: unique symbol;
+declare const SymbolVariants: unique symbol;
+declare const SymbolParent: unique symbol;
+declare const SymbolSelector: unique symbol;
+declare const SymbolLayer: unique symbol;
+declare const SymbolSort: unique symbol;
+declare const SymbolBody: unique symbol;
+interface ControlSymbols {
+  /**
+   * Prevent merging in shortcuts
+   */
+  readonly shortcutsNoMerge: typeof SymbolShortcutsNoMerge;
+  /**
+   * Prevent merging in rules
+   */
+  readonly noMerge: typeof SymbolNoMerge;
+  /**
+   * Prevent applying the `scope` option to this rule/selector
+   */
+  readonly noScope: typeof SymbolNoScope;
+  /**
+   * Additional variants applied to this rule
+   */
+  readonly variants: typeof SymbolVariants;
+  /**
+   * Parent selector (`@media`, `@supports`, etc.)
+   */
+  readonly parent: typeof SymbolParent;
+  /**
+   * Selector modifier
+   */
+  readonly selector: typeof SymbolSelector;
+  /**
+   * Layer modifier
+   */
+  readonly layer: typeof SymbolLayer;
+  /**
+   * Sort modifier
+   */
+  readonly sort: typeof SymbolSort;
+  /**
+   * Custom css body modifier
+   */
+  readonly body: typeof SymbolBody;
+}
+interface ControlSymbolsValue {
+  [SymbolShortcutsNoMerge]: boolean;
+  [SymbolNoMerge]: boolean;
+  [SymbolNoScope]: boolean;
+  [SymbolVariants]: VariantHandler[] | ((handlers: VariantHandler[]) => VariantHandler[]);
+  [SymbolParent]: string;
+  [SymbolSelector]: (selector: string) => string;
+  [SymbolLayer]: string;
+  [SymbolSort]: number;
+  [SymbolBody]: string;
+}
+type ObjectToEntry<T> = { [K in keyof T]: [K, T[K]]; }[keyof T];
+type ControlSymbolsEntry = ObjectToEntry<ControlSymbolsValue>;
+interface VariantContext<Theme extends object = object> {
+  /**
+   * Unprocessed selector from user input.
+   */
+  rawSelector: string;
+  /**
+   * Generator instance
+   */
+  generator: TeacssGenerator<Theme>;
+  /**
+   * The theme object
+   */
+  theme: Theme;
+}
+interface ExtractorContext {
+  readonly original: string;
+  code: string;
+  id?: string;
+  extracted: Set<string> | CountableSet<string>;
+  envMode?: "dev" | "build";
+}
+interface BaseContext<Theme extends object = object> {
+  /**
+   * Generator instance
+   */
+  generator: TeacssGenerator<Theme>;
+  /**
+   * The theme object
+   */
+  theme: Theme;
+}
+interface PreflightContext<Theme extends object = object> extends BaseContext<Theme> {
+  /** Utilities produced for this generate() call after postprocessing, including cache hits and excluding preflights. */
+  generated?: readonly StringifiedUtil<Theme>[];
+}
+interface SafeListContext<Theme extends object = object> extends BaseContext<Theme> {}
+interface Extractor {
+  name: string;
+  order?: number;
+  /**
+   * Extract the code and return a list of selectors.
+   *
+   * Return `undefined` to skip this extractor.
+   */
+  extract?: (ctx: ExtractorContext) => Awaitable<Set<string> | CountableSet<string> | string[] | undefined | void>;
+}
+interface RuleMeta {
+  /**
+   * The layer name of this rule.
+   * @default 'default'
+   */
+  layer?: string;
+  /**
+   * Option to not merge this selector even if the body are the same.
+   * @default false
+   */
+  noMerge?: boolean;
+  /**
+   * Option to not apply scope to this selector.
+   * @default false
+   */
+  noScope?: boolean;
+  /**
+   * Fine tune sort
+   */
+  sort?: number;
+  /**
+   * Templates to provide autocomplete suggestions
+   */
+  autocomplete?: Arrayable<AutoCompleteTemplate>;
+  /**
+   * Matching prefix before this util
+   */
+  prefix?: string | string[];
+  /**
+   * Internal rules will only be matched from expansions but not the user code.
+   * @default false
+   */
+  internal?: boolean;
+  /**
+   * Store the hash of the rule boy
+   *
+   * @internal
+   * @private
+   */
+  __hash?: string;
+  /**
+   * Internal index of the rulelist
+   * @internal
+   * @private
+   */
+  __index?: number;
+  /**
+   * Custom metadata
+   */
+  custom?: Record<string, any>;
+}
+type CSSValue = CSSObject | CSSEntries;
+type CSSValues = CSSValue | CSSValue[];
+type DynamicMatcher<Theme extends object = object> = (match: RegExpMatchArray, context: Readonly<RuleContext<Theme>>) => Awaitable<CSSValueInput | string | (CSSValueInput | string)[] | undefined> | Generator<CSSValueInput | string | undefined> | AsyncGenerator<CSSValueInput | string | undefined>;
+type DynamicRule<Theme extends object = object> = [RegExp, DynamicMatcher<Theme>, RuleMeta?];
+type StaticRule = [string, CSSObjectInput | CSSEntriesInput | (CSSValueInput | string)[], RuleMeta?];
+type Rule<Theme extends object = object> = DynamicRule<Theme> | StaticRule;
+type ExpansionValue = string | CSSValue;
+interface ExpansionInlineValue {
+  handles: VariantHandler[];
+  value: ExpansionValue;
+}
+type DynamicExpansionMatcher<Theme extends object = object> = (match: RegExpMatchArray, context: Readonly<RuleContext<Theme>>) => string | ExpansionValue[] | undefined;
+type DynamicShortcutMatcher<Theme extends object = object> = DynamicExpansionMatcher<Theme>;
+type StaticShortcut = [string, string | ExpansionValue[], RuleMeta?];
+type StaticShortcutMap = Record<string, string | ExpansionValue[]>;
+type DynamicShortcut<Theme extends object = object> = [RegExp, DynamicShortcutMatcher<Theme>, RuleMeta?];
+type UserShortcuts<Theme extends object = object> = StaticShortcutMap | (StaticShortcut | DynamicShortcut<Theme> | StaticShortcutMap)[];
+type Shortcut<Theme extends object = object> = StaticShortcut | DynamicShortcut<Theme>;
+type ShortcutInlineValue = ExpansionInlineValue;
+type ShortcutValue = ExpansionValue;
+type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+interface Preflight<Theme extends object = object> {
+  getCSS: (context: PreflightContext<Theme>) => Promise<string | undefined> | string | undefined;
+  layer?: string;
+}
+interface BlocklistMeta {
+  /**
+   * Custom message to show why this selector is blocked.
+   */
+  message?: string | ((selector: string) => string);
+}
+type BlocklistValue = string | RegExp | ((selector: string) => boolean | null | undefined);
+type BlocklistRule = BlocklistValue | [BlocklistValue, BlocklistMeta];
+interface VariantHandlerContext {
+  /**
+   * Rewrite the output selector. Often be used to append parents.
+   */
+  prefix: string;
+  /**
+   * Rewrite the output selector. Often be used to append pseudo classes.
+   */
+  selector: string;
+  /**
+   * Rewrite the output selector. Often be used to append pseudo elements.
+   */
+  pseudo: string;
+  /**
+   * Rewrite the output css body. The input come in [key,value][] pairs.
+   */
+  entries: CSSEntriesInput;
+  /**
+   * Provide a parent selector(e.g. media query) to the output css.
+   */
+  parent?: string;
+  /**
+   * Provide order to the `parent` parent selector within layer.
+   */
+  parentOrder?: number;
+  /**
+   * Override layer to the output css.
+   */
+  layer?: string;
+  /**
+   * Order in which the variant is sorted within single rule.
+   */
+  sort?: number;
+  /**
+   * Option to not merge the resulting entries even if the body are the same.
+   * @default false
+   */
+  noMerge?: boolean;
+}
+interface VariantHandler {
+  /**
+   * Callback to process the handler.
+   */
+  handle?: (input: VariantHandlerContext, next: (input: VariantHandlerContext) => VariantHandlerContext) => VariantHandlerContext;
+  /**
+   * The result rewritten selector for the next round of matching
+   */
+  matcher?: string;
+  /**
+   * Order in which the variant is applied to selector.
+   */
+  order?: number;
+  /**
+   * Rewrite the output selector. Often be used to append pseudo classes or parents.
+   */
+  selector?: (input: string, body: CSSEntriesInput) => string | undefined;
+  /**
+   * Rewrite the output css body. The input come in [key,value][] pairs.
+   */
+  body?: (body: CSSEntriesInput) => CSSEntriesInput | undefined;
+  /**
+   * Provide a parent selector(e.g. media query) to the output css.
+   */
+  parent?: string | [string, number] | undefined;
+  /**
+   * Order in which the variant is sorted within single rule.
+   */
+  sort?: number;
+  /**
+   * Override layer to the output css.
+   */
+  layer?: string | undefined;
+}
+type VariantFunction<Theme extends object = object> = (matcher: string, context: Readonly<VariantContext<Theme>>) => Awaitable<string | VariantHandler | VariantHandler[] | undefined>;
+interface VariantObject<Theme extends object = object> {
+  /**
+   * The name of the variant.
+   */
+  name?: string;
+  /**
+   * The entry function to match and rewrite the selector for further processing.
+   */
+  match: VariantFunction<Theme>;
+  /**
+   * Sort for when the match is applied.
+   */
+  order?: number;
+  /**
+   * Allows this variant to be used more than once in matching a single rule
+   *
+   * @default false
+   */
+  multiPass?: boolean;
+  /**
+   * Custom function for auto complete
+   */
+  autocomplete?: Arrayable<AutoCompleteFunction | AutoCompleteTemplate>;
+}
+type Variant<Theme extends object = object> = VariantFunction<Theme> | VariantObject<Theme>;
+type Preprocessor = (matcher: string) => string | undefined;
+type Postprocessor = (util: UtilObject) => void | UtilObject | (UtilObject | null | undefined)[];
+type ThemeExtender<Theme extends object = object> = (theme: Theme, config: Readonly<ResolvedConfig<Theme>>) => Theme | void;
+interface ConfigBase<Theme extends object = object> {
+  /**
+   * Rules to generate CSS utilities.
+   *
+   * Later entries have higher priority.
+   */
+  rules?: Rule<Theme>[];
+  /**
+   * Variant separator
+   *
+   * @default [':', '-']
+   */
+  separators?: Arrayable<string>;
+  /**
+   * Variants that preprocess the selectors,
+   * having the ability to rewrite the CSS object.
+   */
+  variants?: Variant<Theme>[];
+  /**
+   * Similar to Windi CSS's shortcuts,
+   * allows you have create new utilities by combining existing ones.
+   *
+   * Later entries have higher priority.
+   */
+  shortcuts?: UserShortcuts<Theme>;
+  /**
+   * Rules to exclude the selectors for your design system (to narrow down the possibilities).
+   * Combining `warnExcluded` options it can also help you identify wrong usages.
+   */
+  blocklist?: BlocklistRule[];
+  /**
+   * Utilities that always been included
+   */
+  safelist?: (string | ((context: SafeListContext<Theme>) => Arrayable<string>))[];
+  /**
+   * Extractors to handle the source file and outputs possible classes/selectors
+   * Can be language-aware.
+   */
+  extractors?: Extractor[];
+  /**
+   * Default extractor that are always applied.
+   * By default it split the source code by whitespace and quotes.
+   *
+   * It maybe be replaced by preset or user config,
+   * only one default extractor can be presented,
+   * later one will override the previous one.
+   *
+   * Pass `null` or `false` to disable the default extractor.
+   *
+   */
+  extractorDefault?: Extractor | null | false;
+  /**
+   * Raw CSS injections.
+   */
+  preflights?: Preflight<Theme>[];
+  /**
+   * Theme object for shared configuration between rules
+   */
+  theme?: Theme;
+  /**
+   * Layer orders. Default to 0.
+   */
+  layers?: Record<string, number>;
+  /**
+   * Output the internal layers as CSS Cascade Layers.
+   */
+  outputToCssLayers?: boolean | OutputCssLayersOptions;
+  /**
+   * Custom function to sort layers.
+   */
+  sortLayers?: (layers: string[]) => string[];
+  /**
+   * Preprocess the incoming utilities, return falsy value to exclude
+   */
+  preprocess?: Arrayable<Preprocessor>;
+  /**
+   * Postprocess the generate utils object
+   */
+  postprocess?: Arrayable<Postprocessor>;
+  /**
+   * Custom functions mutate the theme object.
+   *
+   * It's also possible to return a new theme object to completely replace the original one.
+   */
+  extendTheme?: Arrayable<ThemeExtender<Theme>>;
+  /**
+   * Presets
+   */
+  presets?: (PresetOrFactoryAwaitable<Theme> | PresetOrFactoryAwaitable<Theme>[])[];
+  /**
+   * Additional options for auto complete
+   */
+  autocomplete?: {
+    /**
+     * Custom functions / templates to provide autocomplete suggestions
+     */
+    templates?: Arrayable<AutoCompleteFunction | AutoCompleteTemplate>;
+    /**
+     * Custom extractors to pickup possible classes and
+     * transform class-name style suggestions to the correct format
+     */
+    extractors?: Arrayable<AutoCompleteExtractor>;
+    /**
+     * Custom shorthands to provide autocomplete suggestions.
+     * if values is an array, it will be joined with `|` and wrapped with `()`
+     */
+    shorthands?: Record<string, string | string[]>;
+  };
+  /**
+   * Hook to modify the resolved config.
+   *
+   * First presets runs first and the user config
+   */
+  configResolved?: (config: ResolvedConfig<Theme>) => void;
+  /**
+   * Expose internal details for debugging / inspecting
+   *
+   * Added `rules`, `shortcuts`, `variants` to the context and expose the context object in `StringifiedUtil`
+   *
+   * You don't usually need to set this.
+   *
+   * @default `true` when `envMode` is `dev`, otherwise `false`
+   */
+  details?: boolean;
+  /**
+   * Options for sources to be extracted as utilities usages.
+   *
+   */
+  content?: ContentOptions;
+  /**
+   * Custom transformers to the source code.
+   */
+  transformers?: SourceCodeTransformer[];
+}
+interface OutputCssLayersOptions {
+  /**
+   * Specify the css layer that the internal layer should be output to.
+   *
+   * Return `null` to specify that the layer should not be output to any css layer.
+   */
+  cssLayerName?: (internalLayer: string) => string | undefined | null;
+  /**
+   * Force output all css layers, even if they are not used.
+   *
+   * @example `@layer theme, preflights, [unused-layer], utilities;`
+   */
+  allLayers?: boolean;
+}
+type AutoCompleteTemplate = string;
+type AutoCompleteFunction = (input: string) => Awaitable<string[]>;
+interface AutoCompleteExtractorContext {
+  content: string;
+  cursor: number;
+}
+interface Replacement {
+  /**
+   * The range of the original text
+   */
+  start: number;
+  end: number;
+  /**
+   * The text used to replace
+   */
+  replacement: string;
+}
+interface SuggestResult {
+  /**
+   * The generated suggestions
+   *
+   * `[original, formatted]`
+   */
+  suggestions: [string, string][];
+  /**
+   * The function to convert the selected suggestion back.
+   * Needs to pass in the original one.
+   */
+  resolveReplacement: (suggestion: string) => Replacement;
+}
+interface AutoCompleteExtractorResult {
+  /**
+   * The extracted string
+   */
+  extracted: string;
+  /**
+   * The function to convert the selected suggestion back
+   */
+  resolveReplacement: (suggestion: string) => Replacement;
+  /**
+   * The function to format suggestions
+   */
+  transformSuggestions?: (suggestions: string[]) => string[];
+}
+interface AutoCompleteExtractor {
+  name: string;
+  extract: (context: AutoCompleteExtractorContext) => Awaitable<AutoCompleteExtractorResult | null>;
+  order?: number;
+}
+interface Preset<Theme extends object = object> extends ConfigBase<Theme> {
+  name: string;
+  /**
+   * Enforce the preset to be applied before or after other presets
+   */
+  enforce?: "pre" | "post";
+  /**
+   * Preset options for other tools like IDE to consume
+   */
+  options?: PresetOptions;
+  /**
+   * Apply prefix to all utilities and shortcuts
+   */
+  prefix?: string | string[];
+  /**
+   * Apply layer to all utilities and shortcuts
+   */
+  layer?: string;
+  /**
+   * Custom API endpoint for cross-preset communication
+   */
+  api?: any;
+  /**
+   * Custom metadata for the preset
+   */
+  meta?: Record<string, any>;
+}
+type PresetFactory<Theme extends object = object, PresetOptions extends object | undefined = undefined> = (options?: PresetOptions) => Preset<Theme>;
+type PresetFactoryAwaitable<Theme extends object = object, PresetOptions extends object | undefined = undefined> = (options?: PresetOptions) => Awaitable<Preset<Theme>>;
+type PresetOrFactory<Theme extends object = object> = Preset<Theme> | PresetFactory<Theme, any>;
+type PresetOrFactoryAwaitable<Theme extends object = object> = PresetOrFactory<Theme> | Promise<Preset<Theme>> | PresetFactoryAwaitable<Theme>;
+interface GeneratorOptions {
+  /**
+   * Merge utilities with the exact same body to save the file size
+   *
+   * @default true
+   */
+  mergeSelectors?: boolean;
+  /**
+   * Emit warning when matched selectors are presented in blocklist
+   *
+   * @default true
+   */
+  warn?: boolean;
+}
+interface UserOnlyOptions<Theme extends object = object> {
+  /**
+   * Plain theme objects are deep-merged with preset themes. Non-plain themes
+   * are atomic; use `$reset` to replace one with a plain object or
+   * `extendTheme` for class-aware composition.
+   */
+  theme?: Theme;
+  /**
+   * Layer name for shortcuts
+   *
+   * @default 'shortcuts'
+   */
+  shortcutsLayer?: string;
+  /**
+   * Environment mode
+   *
+   * @default 'build'
+   */
+  envMode?: "dev" | "build";
+  /**
+   * Custom prefix for virtual modules
+   *
+   * @default '__tea'
+   */
+  virtualModulePrefix?: string;
+}
+/**
+ * For cli config
+ */
+interface CliOptions {
+  cli?: {
+    entry?: Arrayable<CliEntryItem>;
+  };
+}
+interface TeacssPluginContext<Config extends UserConfig = UserConfig> {
+  /**
+   * Singleton promise for config loading
+   */
+  ready: Promise<LoadConfigResult<Config>>;
+  /**
+   * The generator instance. Should be used after `ready` resolved.
+   */
+  generator: TeacssGenerator;
+  /**
+   * All tokens scanned
+   */
+  tokens: Set<string>;
+  /**
+   * Current transformed or extracted content keyed by module ID
+   */
+  modules: BetterMap<string, string>;
+  /**
+   * Module IDs
+   */
+  affectedModules: Set<string>;
+  /**
+   *  Pending promises
+   */
+  tasks: Promise<any>[];
+  /**
+   * Await all pending tasks
+   */
+  flushTasks: () => Promise<any>;
+  filter: (code: string, id: string) => boolean;
+  extract: (code: string, id?: string) => Promise<void>;
+  reloadConfig: () => Promise<LoadConfigResult<Config>>;
+  getConfig: () => Promise<Config>;
+  /** Subscribe to config reloads. Returns a function that removes the listener. */
+  onReload: (fn: () => void) => () => void;
+  invalidate: () => void;
+  /** Subscribe to generated-output invalidations. Returns a function that removes the listener. */
+  onInvalidate: (fn: () => void) => () => void;
+  root: string;
+  updateRoot: (root: string) => Promise<LoadConfigResult<Config>>;
+  getConfigFileList: () => string[];
+  /**
+   * Get regexes to match virtual module ids
+   */
+  getVMPRegexes: () => Promise<{
+    prefix: string;
+    RESOLVED_ID_WITH_QUERY_RE: RegExp;
+    RESOLVED_ID_RE: RegExp;
+  }>;
+}
+interface SourceMap {
+  file?: string;
+  mappings?: string;
+  names?: string[];
+  sources?: string[];
+  sourcesContent?: string[];
+  version?: number;
+}
+interface HighlightAnnotation {
+  offset: number;
+  length: number;
+  className: string;
+}
+type SourceCodeTransformerEnforce = "pre" | "post" | "default";
+interface SourceCodeTransformer {
+  name: string;
+  /**
+   * The order of transformer
+   */
+  enforce?: SourceCodeTransformerEnforce;
+  /**
+   * Custom id filter, if not provided, the extraction filter will be applied
+   */
+  idFilter?: (id: string) => boolean;
+  /**
+   * The transform function
+   */
+  transform: (code: MagicStringLike, id: string, ctx: TeacssPluginContext) => Awaitable<{
+    highlightAnnotations?: HighlightAnnotation[];
+  } | void>;
+  /**
+   * Release state owned by a module after the integration removes it.
+   */
+  onModuleRemoved?: (id: string, ctx: TeacssPluginContext) => Awaitable<void>;
+}
+interface ContentOptions {
+  /**
+   * Glob patterns to extract from the file system, in addition to other content sources.
+   *
+   * In dev mode, the files will be watched and trigger HMR.
+   *
+   * @default []
+   */
+  filesystem?: string[];
+  /**
+   * Inline text to be extracted
+   */
+  inline?: (string | {
+    code: string;
+    id?: string;
+  } | (() => Awaitable<string | {
+    code: string;
+    id?: string;
+  }>))[];
+  /**
+   * Filters to determine whether to extract certain modules from the build tools' transformation pipeline.
+   *
+   * Used by integrations that receive source modules from a build pipeline.
+   *
+   * Set `false` to disable.
+   */
+  pipeline?: false | {
+    /**
+     * Patterns that filter the files being extracted.
+     * Supports regular expressions and `picomatch` glob patterns.
+     *
+     * By default, `.ts` and `.js` files are NOT extracted.
+     *
+     * @see https://www.npmjs.com/package/picomatch
+     * @default [/\.(vue|svelte|[jt]sx|vine.ts|mdx?|astro|elm|php|phtml|marko|html)($|\?)/]
+     */
+    include?: FilterPattern;
+    /**
+     * Patterns that filter the files NOT being extracted.
+     * Supports regular expressions and `picomatch` glob patterns.
+     *
+     * By default, `node_modules` and `dist` are also extracted.
+     *
+     * @see https://www.npmjs.com/package/picomatch
+     * @default [/\.(css|postcss|sass|scss|less|stylus|styl)($|\?)/]
+     */
+    exclude?: FilterPattern;
+  };
+}
+/**
+ * For other modules to aggregate the options
+ */
+interface PluginOptions {
+  /**
+   * Custom transformers to the source code
+   */
+  transformers?: SourceCodeTransformer[];
+  /**
+   * Options for sources to be extracted as utilities usages
+   *
+   * Supported sources:
+   * - `filesystem` - extract from file system
+   * - `inline` - extract from plain inline text
+   * - `pipeline` - extract from a build tool's transformation pipeline
+   *
+   * The usage extracted from each source will be **merged** together.
+   */
+  content?: ContentOptions;
+}
+interface UserConfig<Theme extends object = object> extends ConfigBase<Theme>, UserOnlyOptions<Theme>, GeneratorOptions, PluginOptions, CliOptions {}
+interface UserConfigDefaults<Theme extends object = object> extends ConfigBase<Theme>, UserOnlyOptions<Theme> {}
+interface ResolvedConfig<Theme extends object = object> extends Omit<RequiredByKey<UserConfig<Theme>, "mergeSelectors" | "theme" | "rules" | "variants" | "layers" | "extractors" | "blocklist" | "safelist" | "preflights" | "sortLayers">, "rules" | "shortcuts" | "autocomplete" | "presets"> {
+  presets: Preset<Theme>[];
+  shortcuts: Shortcut<Theme>[];
+  variants: VariantObject<Theme>[];
+  preprocess: Preprocessor[];
+  postprocess: Postprocessor[];
+  rulesSize: number;
+  rules: readonly Rule<Theme>[];
+  rulesDynamic: readonly DynamicRule<Theme>[];
+  rulesStaticMap: Record<string, StaticRule | undefined>;
+  autocomplete: {
+    templates: (AutoCompleteFunction | AutoCompleteTemplate)[];
+    extractors: AutoCompleteExtractor[];
+    shorthands: Record<string, string>;
+  };
+  separators: string[];
+}
+interface GenerateResult<T = Set<string>> {
+  css: string;
+  layers: string[];
+  getLayer: (name?: string) => string | undefined;
+  getLayers: (includes?: string[], excludes?: string[]) => string;
+  setLayer: (layer: string, callback: (content: string) => Awaitable<string>) => Promise<string>;
+  matched: T;
+}
+type VariantMatchedResult<Theme extends object = object> = [raw: string, current: string, variantHandlers: VariantHandler[], variants: Set<Variant<Theme>>];
+type ParsedUtil = readonly [index: number, raw: string, entries: CSSEntriesInput, meta: RuleMeta | undefined, variantHandlers: VariantHandler[]];
+type RawUtil = readonly [index: number, rawCSS: string, meta: RuleMeta | undefined];
+type StringifiedUtil<Theme extends object = object> = readonly [index: number, selector: string | undefined, body: string, parent: string | undefined, meta: RuleMeta | undefined, context: RuleContext<Theme> | undefined, noMerge: boolean | undefined];
+type PreparedRule = readonly [selector: [string, number][], body: string, noMerge: boolean];
+interface CliEntryItem {
+  patterns: string[];
+  outFile: string;
+  /**
+   * Whether to rewrite the transformed utilities.
+   *
+   * - For css: if rewrite is true, it will not generate a new file, but directly modify the original file content.
+   * - For other files: if rewrite is true, it replaces the original file with the transformed content.
+   *
+   * @default false
+   */
+  rewrite?: boolean;
+  /**
+   * Whether to output CSS files scanned from patterns to outFile
+   *
+   * - false: Do not output CSS files
+   * - true: Transform and output scanned CSS file contents to outFile
+   * - 'multi': Output each CSS file separately with filename format `${originFile}-[hash]`
+   * - 'single': Merge multiple CSS files into one output file named `outFile-merged.css`
+   *
+   * @default true
+   */
+  splitCss?: boolean | "multi" | "single";
+}
+interface UtilObject {
+  selector: string;
+  entries: CSSEntriesInput;
+  parent: string | undefined;
+  layer: string | undefined;
+  sort: number | undefined;
+  noMerge: boolean | undefined;
+}
+/**
+ * Returned from `tea.generate()` when `extendedInfo` option is enabled.
+ */
+interface ExtendedTokenInfo<Theme extends object = object> {
+  /**
+   * Stringified util data
+   */
+  data: StringifiedUtil<Theme>[];
+  /**
+   * Return -1 if the data structure is not countable
+   */
+  count: number;
+}
+interface GenerateOptions<T extends boolean> {
+  /**
+   * Filepath of the file being processed.
+   */
+  id?: string;
+  /**
+   * Generate preflights (if defined)
+   *
+   * @default true
+   */
+  preflights?: boolean;
+  /**
+   * Includes safelist
+   */
+  safelist?: boolean;
+  /**
+   * Generate minified CSS
+   * @default false
+   */
+  minify?: boolean;
+  /**
+   * Maximum number of tokens parsed concurrently. Omit to preserve unbounded
+   * scheduling; set a positive integer to cap peak work for large inputs.
+   */
+  tokenConcurrency?: number;
+  /**
+   * @experimental
+   */
+  scope?: string;
+  /**
+   * If return extended "matched" with payload and count
+   */
+  extendedInfo?: T;
+}
+//#endregion
+//#region src/condition-variant.d.ts
+interface ConditionVariantOptions {
+  /**
+   * Variant name (for debugging / `details`).
+   * @default "at-condition"
+   */
+  name?: string;
+}
+/**
+ * Build the `@` condition-axis variant from a vocabulary of {@link ConditionResolver}s.
+ *
+ * When a token carries trailing `@cond` segments, the variant:
+ * - parses + resolves them with the supplied `resolvers`,
+ * - strips the `@cond` from the `matcher` so the remaining declaration (plus an
+ *   optional `!`) still matches a rule, and
+ * - in `handle`, appends the resolved selector parts around the styled element.
+ *
+ * If any condition is unrecognized by the resolvers, the token is left unclaimed
+ * (`undefined`), preserving the generator's behavior for unknown tokens.
+ */
+declare function createConditionVariant<Theme extends object = object>(resolvers: ConditionResolver[], options?: ConditionVariantOptions): VariantObject<Theme>;
+//#endregion
+//#region src/config.d.ts
+declare function resolveShortcuts<Theme extends object = object>(shortcuts: UserShortcuts<Theme>): Shortcut<Theme>[];
+/**
+ * Resolve a single preset, nested presets are ignored
+ */
+declare function resolvePreset<Theme extends object = object>(presetInput: PresetOrFactoryAwaitable<Theme>): Promise<Preset<Theme>>;
+/**
+ * Resolve presets with nested presets
+ */
+declare function resolvePresets<Theme extends object = object>(preset: PresetOrFactoryAwaitable<Theme>): Promise<Preset<Theme>[]>;
+declare function resolveConfig<Theme extends object = object>(userConfig?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): Promise<ResolvedConfig<Theme>>;
+declare function mergeConfigs<Theme extends object = object>(configs: UserConfig<Theme>[]): UserConfig<Theme>;
+declare function definePreset<Options extends object | undefined = undefined, Theme extends object = object>(preset: PresetFactory<Theme, Options>): PresetFactory<Theme, Options>;
+declare function definePreset<Options extends object | undefined = undefined, Theme extends object = object>(preset: PresetFactoryAwaitable<Theme, Options>): PresetFactoryAwaitable<Theme, Options>;
+declare function definePreset<Theme extends object = object>(preset: Preset<Theme>): Preset<Theme>;
+//#endregion
+//#region src/constants.d.ts
+declare const LAYER_IMPORTS = "imports";
+declare const LAYER_PRIMITIVES = "primitives";
+declare const LAYER_PROPERTIES = "properties";
+declare const LAYER_PREFLIGHTS = "preflights";
+declare const LAYER_SHORTCUTS = "shortcuts";
+declare const LAYER_UTILITIES = "utilities";
+declare const DEFAULT_LAYERS: Readonly<{
+  imports: -200;
+  properties: -150;
+  preflights: -100;
+  shortcuts: -50;
+  primitives: -10;
+  utilities: 0;
+}>;
+//#endregion
+//#region src/env.d.ts
+declare function getEnvFlags(): {
+  isNode: boolean;
+  isVSCode: boolean;
+  isESLint: boolean;
+};
+//#endregion
+//#region src/extractors/split.d.ts
+declare const defaultSplitRE: RegExp;
+declare const splitWithVariantGroupRE: RegExp;
+declare const extractorSplit: Extractor;
+//#endregion
+//#region src/group.d.ts
+/** Expand groups in host source, including groups nested in strings/arrays. */
+declare function expandGroups(code: string): string;
+/** Expand groups in a class list while preserving braces inside attached literals. */
+declare function expandClassGroups(code: string): string;
+//#endregion
+//#region src/hash.d.ts
+declare function getHash(input: string, length?: number): string;
+//#endregion
+//#region src/literal.d.ts
+/**
+ * Literal regions — `()` and `[]`.
+ *
+ * Inside `()` (a CSS function) and `[]` (an arbitrary value / selector), characters
+ * are taken literally and operators do not participate in symbol parsing — they only
+ * act at depth 0 in the token and condition parsers. This module turns the
+ * *contents* of those regions into their final CSS form:
+ *
+ * - `()` = CSS function: `_` stays literal (`var(--my_var)`), and `calc` / `clamp` /
+ *   `min` / `max` operators get surrounding spaces the engine fills in.
+ * - `[]` = arbitrary value / selector: `_` means a space, `\_` means a literal
+ *   underscore (`|` is NOT used for spaces). `_` inside a nested `()` stays literal.
+ *
+ * These are pure string utilities, consistent with `parseClassToken` and the
+ * condition parser. They do not resolve rules, theme, or bracket *type hints*
+ * (`[color:red]` etc.) — that interpretation belongs to the rule/preset layer.
+ */
+/**
+ * Split a class list on whitespace outside attached `[]` literal regions.
+ *
+ * Unlike the source extractor, this does not treat quotes, semicolons, braces,
+ * or backticks as delimiters. It is for already-isolated class-list surfaces
+ * such as shortcuts, `cn()`, and `@apply`.
+ */
+declare function splitClassTokens(input: string): string[];
+/**
+ * Expand `_` to a space inside an arbitrary `[]` region.
+ *
+ * - `\_` → a literal underscore.
+ * - `_` at paren depth 0 → a space.
+ * - `_` inside `(…)` → kept literal (so `var(--my_var)` survives).
+ */
+declare function expandUnderscores(content: string): string;
+/**
+ * Add surrounding spaces to `+ - * /` operators inside balanced `calc()` /
+ * `clamp()` / `min()` / `max()` functions without rewriting adjacent values,
+ * quoted text, URLs, custom-property names, or numeric exponent signs.
+ */
+declare function spaceCalcOperators(str: string): string;
+/** True when `value` is a single `[…]` arbitrary region. */
+declare function isArbitrary(value: string): boolean;
+interface NormalizeArbitraryOptions {
+  /**
+   * Apply `calc` / `clamp` / `min` / `max` operator spacing.
+   * @default true
+   */
+  calc?: boolean;
+}
+/**
+ * Normalize a value's literal regions to final CSS.
+ *
+ * - A `[…]` arbitrary value has its brackets stripped and underscores expanded
+ *   (`_`→space, `\_`→`_`, `_` inside `()` kept).
+ * - `calc` / `clamp` / `min` / `max` operators get spacing (in both arbitrary and
+ *   raw function values).
+ * - A raw value (no brackets) keeps `_` literal — only `[]` uses `_` for spaces.
+ *
+ * Bracket *type hints* (`[color:red]`, `[length:4px]`) are intentionally not
+ * interpreted here; that is the rule/preset layer's job.
+ *
+ * @example normalizeArbitraryValue("[1px_solid_red]") // "1px solid red"
+ * @example normalizeArbitraryValue("calc(100%-1rem)") // "calc(100% - 1rem)"
+ * @example normalizeArbitraryValue("var(--my_var)")   // "var(--my_var)"
+ */
+declare function normalizeArbitraryValue(value: string, options?: NormalizeArbitraryOptions): string;
+//#endregion
+//#region src/markers.d.ts
+declare const INCLUDE_COMMENT = "@teacss-include";
+declare const IGNORE_COMMENT = "@teacss-ignore";
+declare const INCLUDE_COMMENT_IDE = "@teacss-ide-include";
+declare const CSS_PLACEHOLDER = "@teacss-placeholder";
+declare const SKIP_START_COMMENT = "@teacss-skip-start";
+declare const SKIP_END_COMMENT = "@teacss-skip-end";
+declare const SKIP_COMMENT_RE: RegExp;
+declare const VIRTUAL_ENTRY_ALIAS: RegExp[];
+declare const LAYER_MARK_ALL = "__ALL__";
+//#endregion
+//#region src/token.d.ts
+/**
+ * Token parsing primitives.
+ *
+ * Splits a single TeaCSS class token into its stable structural parts so every
+ * later stage (the `@` condition axis, escaping, rules) can build on one source
+ * of truth. This module is pure structure: it does not resolve rules, variants,
+ * or CSS. The current token shape is documented in
+ * `docs/proposals/v00-teacss.md`.
+ *
+ * Token shape:
+ *
+ * ```txt
+ * (property:value | keyword)[!](@cond)*
+ * ```
+ *
+ * - A declaration is either `property:value` (split on the first depth-0 `:`) or
+ *   a bare keyword (no depth-0 `:`, e.g. `relative`, `sticky`, `truncate`).
+ * - `()` and `[]` are literal regions; operators inside them (`:` `!` `@` …) do
+ *   not participate in parsing.
+ * - `!` immediately after the value (before any `@`) is `!important`.
+ * - The value extends up to the first depth-0 `!` or `@`.
+ * - Zero or more `@cond` segments follow; each is captured verbatim (without its
+ *   leading `@`). Interpreting a condition (pseudo / target / media / NOT `!…` …)
+ *   belongs to the condition pipeline.
+ */
+interface ParsedClassToken {
+  /** The full original token, unchanged. */
+  raw: string;
+  /** Declaration body without the trailing `!` or any `@cond` (e.g. `bg:red`, `d:flex`, `content:[""]`). */
+  body: string;
+  /** Property side, present only when the declaration has a depth-0 `:`. */
+  property?: string;
+  /** Value side, present only when the declaration has a depth-0 `:`. */
+  value?: string;
+  /** True when the declaration is a bare keyword (no depth-0 `:`). */
+  keyword: boolean;
+  /** True when a depth-0 `!` immediately follows the value (`!important`). */
+  important: boolean;
+  /** Ordered `@cond` segments, each without its leading `@` (e.g. `["hover"]`, `[">li::after"]`). */
+  conditions: string[];
+}
+/**
+ * Parse a single class token into its structural parts.
+ *
+ * Pure and total: any non-empty string yields a result. Malformed tokens (e.g.
+ * unbalanced brackets) are parsed leniently rather than throwing — validation is
+ * left to the rule layer.
+ */
+declare function parseClassToken(raw: string): ParsedClassToken;
+//#endregion
+export { ArgumentType, Arrayable, AutoCompleteExtractor, AutoCompleteExtractorContext, AutoCompleteExtractorResult, AutoCompleteFunction, AutoCompleteTemplate, Awaitable, BaseContext, BetterMap, BlocklistMeta, BlocklistRule, BlocklistValue, BuiltConditionSelector, CSSEntries, CSSEntriesInput, CSSEntry, CSSObject, CSSObjectInput, CSSValue, CSSValueInput, CSSValues, CSS_PLACEHOLDER, CliEntryItem, CliOptions, ConditionKind, ConditionResolveContext, ConditionResolver, ConditionVariantOptions, ConfigBase, ContentOptions, ControlSymbols, ControlSymbolsEntry, ControlSymbolsValue, CountableSet, DEFAULT_LAYERS, DeepPartial, DynamicExpansionMatcher, DynamicMatcher, DynamicRule, DynamicShortcut, DynamicShortcutMatcher, Emitter, ExpansionInlineValue, ExpansionValue, ExtendedTokenInfo, Extractor, ExtractorContext, FilterPattern, FlatObjectTuple, GenerateOptions, GenerateResult, GeneratorOptions, HighlightAnnotation, IGNORE_COMMENT, INCLUDE_COMMENT, INCLUDE_COMMENT_IDE, LAYER_IMPORTS, LAYER_MARK_ALL, LAYER_PREFLIGHTS, LAYER_PRIMITIVES, LAYER_PROPERTIES, LAYER_SHORTCUTS, LAYER_UTILITIES, LoadConfigResult, MagicStringLike, NormalizeArbitraryOptions, ObjectToEntry, OutputCssLayersOptions, ParsedClassToken, ParsedCondition, ParsedUtil, PartialByKeys, PluginOptions, Postprocessor, Preflight, PreflightContext, PreparedGeneratorConfig, PreparedRule, Preprocessor, Preset, PresetFactory, PresetFactoryAwaitable, PresetOptions, PresetOrFactory, PresetOrFactoryAwaitable, RESET_KEY, RawUtil, Replacement, RequiredByKey, ResolveConditionsResult, ResolvedCondition, ResolvedConfig, RestArgs, Rule, RuleContext, RuleMeta, SKIP_COMMENT_RE, SKIP_END_COMMENT, SKIP_START_COMMENT, SafeListContext, Shift, Shortcut, ShortcutInlineValue, ShortcutValue, SourceCodeTransformer, SourceCodeTransformerEnforce, SourceMap, StaticRule, StaticShortcut, StaticShortcutMap, StringifiedUtil, SuggestResult, TeacssGenerator, TeacssPluginContext, ThemeExtender, ToArray, TwoKeyMap, Unsubscribe, UserConfig, UserConfigDefaults, UserOnlyOptions, UserShortcuts, UtilObject, VIRTUAL_ENTRY_ALIAS, Variant, VariantContext, VariantFunction, VariantHandler, VariantHandlerContext, VariantMatchedResult, VariantObject, VirtualKey, attributifyRE, buildConditionSelector, clearIdenticalEntries, clone, collapseVariantGroup, createConditionVariant, createGenerator, createNanoEvents, cssIdRE, defaultSplitRE, definePreset, e, entriesToCss, escapeRegExp, escapeSelector, expandClassGroups, expandGroups, expandUnderscores, expandVariantGroup, extractorSplit as extractorDefault, extractorSplit, getEnvFlags, getHash, getPath, hasScopePlaceholder, hash, isArbitrary, isAttributifySelector, isCountableSet, isCssId, isObject, isRawUtil, isStaticRule, isStaticShortcut, isString, isThenable, isValidSelector, makeRegexClassGroup, mergeConfigs, mergeDeep, noop, normalizeArbitraryValue, normalizeCSSEntries, normalizeCSSValues, normalizeVariant, notNull, parseClassToken, parseCondition, parseConditions, parseVariantGroup, regexScopePlaceholder, replaceAsync, resolveConditions, resolveConfig, resolvePreset, resolvePresets, resolveShortcuts, restoreSkipCode, spaceCalcOperators, splitClassTokens, splitWithVariantGroupRE, symbols, toArray, toEscapedSelector, transformSkipCode, uniq, uniqueBy, validateFilterRE, warnOnce, withLayer };