@pikacss/core 0.0.30 → 0.0.32

package/dist/index.d.cts

@@ -1,391 +1,393 @@
-import * as _pikacss_core from '@pikacss/core';
-import * as CSS from 'csstype';
+import * as CSS from "csstype";
 
+//#region src/internal/plugins/important.d.ts
 interface ImportantConfig {
-    default?: boolean;
+  default?: boolean;
 }
 declare module '@pikacss/core' {
-    interface EngineConfig {
-        important?: ImportantConfig;
-    }
+  interface EngineConfig {
+    important?: ImportantConfig;
+  }
 }
-
+//#endregion
+//#region src/internal/plugins/keyframes.d.ts
 interface Progress {
-    from?: ResolvedProperties;
-    to?: ResolvedProperties;
-    [K: `${number}%`]: ResolvedProperties;
+  from?: ResolvedProperties;
+  to?: ResolvedProperties;
+  [K: `${number}%`]: ResolvedProperties;
 }
 type Keyframes = string | [name: string, frames?: Progress, autocomplete?: string[], pruneUnused?: boolean] | {
-    name: string;
-    frames?: Progress;
-    autocomplete?: string[];
-    pruneUnused?: boolean;
+  name: string;
+  frames?: Progress;
+  autocomplete?: string[];
+  pruneUnused?: boolean;
 };
 interface KeyframesConfig {
-    /**
-     * Define CSS @keyframes animations with support for frame definitions
-     * and autocomplete suggestions.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * {
-     *   keyframes: [
-     *     // Basic animation
-     *     ['fade', {
-     *       from: { opacity: 0 },
-     *       to: { opacity: 1 }
-     *     }],
-     *     // With autocomplete suggestions
-     *     ['slide', {
-     *       from: { transform: 'translateX(-100%)' },
-     *       to: { transform: 'translateX(0)' }
-     *     }, ['slide 0.3s ease']]
-     *   ]
-     * }
-     * ```
-     */
-    keyframes: Keyframes[];
-    /**
-     * Whether to prune unused keyframes from the final CSS.
-     *
-     * @default true
-     */
-    pruneUnused?: boolean;
+  /**
+   * Define CSS @keyframes animations with support for frame definitions
+   * and autocomplete suggestions.
+   *
+   * @default []
+   * @example
+   * ```ts
+   * {
+   *   keyframes: [
+   *     // Basic animation
+   *     ['fade', {
+   *       from: { opacity: 0 },
+   *       to: { opacity: 1 }
+   *     }],
+   *     // With autocomplete suggestions
+   *     ['slide', {
+   *       from: { transform: 'translateX(-100%)' },
+   *       to: { transform: 'translateX(0)' }
+   *     }, ['slide 0.3s ease']]
+   *   ]
+   * }
+   * ```
+   */
+  keyframes: Keyframes[];
+  /**
+   * Whether to prune unused keyframes from the final CSS.
+   *
+   * @default true
+   */
+  pruneUnused?: boolean;
 }
 declare module '@pikacss/core' {
-    interface EngineConfig {
-        keyframes?: KeyframesConfig;
-    }
-    interface Engine {
-        keyframes: {
-            store: Map<string, ResolvedKeyframesConfig>;
-            add: (...list: Keyframes[]) => void;
-        };
-    }
+  interface EngineConfig {
+    keyframes?: KeyframesConfig;
+  }
+  interface Engine {
+    keyframes: {
+      store: Map<string, ResolvedKeyframesConfig>;
+      add: (...list: Keyframes[]) => void;
+    };
+  }
 }
 interface ResolvedKeyframesConfig {
-    name: string;
-    frames: Progress | Nullish;
-    pruneUnused: boolean;
-    autocomplete: string[];
-}
-
-interface ResolvedResult<T> {
-    value: T;
-}
-interface StaticRule<T> {
-    key: string;
-    string: string;
-    resolved: T;
-}
-interface DynamicRule<T> {
-    key: string;
-    stringPattern: RegExp;
-    createResolved: (matched: RegExpMatchArray) => Awaitable<T>;
-}
-declare abstract class AbstractResolver<T> {
-    protected _resolvedResultsMap: Map<string, ResolvedResult<T>>;
-    staticRulesMap: Map<string, StaticRule<T>>;
-    dynamicRulesMap: Map<string, DynamicRule<T>>;
-    onResolved: (string: string, type: 'static' | 'dynamic', result: ResolvedResult<T>) => void;
-    get staticRules(): StaticRule<T>[];
-    get dynamicRules(): DynamicRule<T>[];
-    addStaticRule(rule: StaticRule<T>): this;
-    removeStaticRule(key: string): this;
-    addDynamicRule(rule: DynamicRule<T>): this;
-    removeDynamicRule(key: string): this;
-    _resolve(string: string): Promise<ResolvedResult<T> | Nullish>;
-    _setResolvedResult(string: string, resolved: T): void;
-}
-
+  name: string;
+  frames: Progress | Nullish;
+  pruneUnused: boolean;
+  autocomplete: string[];
+}
+//#endregion
+//#region src/internal/resolver.d.ts
+interface ResolvedResult<T$1> {
+  value: T$1;
+}
+interface StaticRule<T$1> {
+  key: string;
+  string: string;
+  resolved: T$1;
+}
+interface DynamicRule<T$1> {
+  key: string;
+  stringPattern: RegExp;
+  createResolved: (matched: RegExpMatchArray) => Awaitable<T$1>;
+}
+declare abstract class AbstractResolver<T$1> {
+  protected _resolvedResultsMap: Map<string, ResolvedResult<T$1>>;
+  staticRulesMap: Map<string, StaticRule<T$1>>;
+  dynamicRulesMap: Map<string, DynamicRule<T$1>>;
+  onResolved: (string: string, type: 'static' | 'dynamic', result: ResolvedResult<T$1>) => void;
+  get staticRules(): StaticRule<T$1>[];
+  get dynamicRules(): DynamicRule<T$1>[];
+  addStaticRule(rule: StaticRule<T$1>): this;
+  removeStaticRule(key: string): this;
+  addDynamicRule(rule: DynamicRule<T$1>): this;
+  removeDynamicRule(key: string): this;
+  _resolve(string: string): Promise<ResolvedResult<T$1> | Nullish>;
+  _setResolvedResult(string: string, resolved: T$1): void;
+}
+//#endregion
+//#region src/internal/plugins/selectors.d.ts
 type Selector = string | [selector: RegExp, value: (matched: RegExpMatchArray) => Awaitable<Arrayable<UnionString | ResolvedSelector>>, autocomplete?: Arrayable<string>] | [selector: string, value: Arrayable<UnionString | ResolvedSelector>] | {
-    selector: RegExp;
-    value: (matched: RegExpMatchArray) => Awaitable<Arrayable<UnionString | ResolvedSelector>>;
-    autocomplete?: Arrayable<string>;
+  selector: RegExp;
+  value: (matched: RegExpMatchArray) => Awaitable<Arrayable<UnionString | ResolvedSelector>>;
+  autocomplete?: Arrayable<string>;
 } | {
-    selector: string;
-    value: Arrayable<UnionString | ResolvedSelector>;
+  selector: string;
+  value: Arrayable<UnionString | ResolvedSelector>;
 };
 interface SelectorsConfig {
-    /**
-     * Define custom selectors with support for dynamic and static selectors.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * {
-     *   selectors: [
-     *     // Static selector
-     *     ['hover', '$:hover'],
-     *     // Dynamic selector
-     *     [/^screen-(\d+)$/, m => `@media (min-width: ${m[1]}px)`,
-     *       ['screen-768', 'screen-1024']], // Autocomplete suggestions
-     *   ]
-     * }
-     * ```
-     */
-    selectors: Selector[];
+  /**
+   * Define custom selectors with support for dynamic and static selectors.
+   *
+   * @default []
+   * @example
+   * ```ts
+   * {
+   *   selectors: [
+   *     // Static selector
+   *     ['hover', '$:hover'],
+   *     // Dynamic selector
+   *     [/^screen-(\d+)$/, m => `@media (min-width: ${m[1]}px)`,
+   *       ['screen-768', 'screen-1024']], // Autocomplete suggestions
+   *   ]
+   * }
+   * ```
+   */
+  selectors: Selector[];
 }
 declare module '@pikacss/core' {
-    interface EngineConfig {
-        selectors?: SelectorsConfig;
-    }
-    interface Engine {
-        selectors: {
-            resolver: SelectorResolver;
-            add: (...list: Selector[]) => void;
-        };
-    }
+  interface EngineConfig {
+    selectors?: SelectorsConfig;
+  }
+  interface Engine {
+    selectors: {
+      resolver: SelectorResolver;
+      add: (...list: Selector[]) => void;
+    };
+  }
 }
 declare class SelectorResolver extends AbstractResolver<string[]> {
-    resolve(selector: string): Promise<string[]>;
+  resolve(selector: string): Promise<string[]>;
 }
-
+//#endregion
+//#region src/internal/plugins/shortcuts.d.ts
 type Shortcut = string | [shortcut: RegExp, value: (matched: RegExpMatchArray) => Awaitable<Arrayable<ResolvedStyleItem>>, autocomplete?: Arrayable<string>] | {
-    shortcut: RegExp;
-    value: (matched: RegExpMatchArray) => Awaitable<Arrayable<ResolvedStyleItem>>;
-    autocomplete?: Arrayable<string>;
+  shortcut: RegExp;
+  value: (matched: RegExpMatchArray) => Awaitable<Arrayable<ResolvedStyleItem>>;
+  autocomplete?: Arrayable<string>;
 } | [shortcut: string, value: Arrayable<ResolvedStyleItem>] | {
-    shortcut: string;
-    value: Arrayable<ResolvedStyleItem>;
+  shortcut: string;
+  value: Arrayable<ResolvedStyleItem>;
 };
 interface ShortcutsConfig {
-    /**
-     * Define style shortcuts for reusable style combinations.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * {
-     *   shortcuts: [
-     *     // Static shortcut
-     *     ['flex-center', {
-     *       display: 'flex',
-     *       alignItems: 'center',
-     *       justifyContent: 'center'
-     *     }],
-     *     // Dynamic shortcut
-     *     [/^m-(\d+)$/, m => ({ margin: `${m[1]}px` }),
-     *       ['m-4', 'm-8']] // Autocomplete suggestions
-     *   ]
-     * }
-     * ```
-     */
-    shortcuts: Shortcut[];
+  /**
+   * Define style shortcuts for reusable style combinations.
+   *
+   * @default []
+   * @example
+   * ```ts
+   * {
+   *   shortcuts: [
+   *     // Static shortcut
+   *     ['flex-center', {
+   *       display: 'flex',
+   *       alignItems: 'center',
+   *       justifyContent: 'center'
+   *     }],
+   *     // Dynamic shortcut
+   *     [/^m-(\d+)$/, m => ({ margin: `${m[1]}px` }),
+   *       ['m-4', 'm-8']] // Autocomplete suggestions
+   *   ]
+   * }
+   * ```
+   */
+  shortcuts: Shortcut[];
 }
 declare module '@pikacss/core' {
-    interface EngineConfig {
-        shortcuts?: ShortcutsConfig;
-    }
-    interface Engine {
-        shortcuts: {
-            resolver: ShortcutResolver;
-            add: (...list: Shortcut[]) => void;
-        };
-    }
+  interface EngineConfig {
+    shortcuts?: ShortcutsConfig;
+  }
+  interface Engine {
+    shortcuts: {
+      resolver: ShortcutResolver;
+      add: (...list: Shortcut[]) => void;
+    };
+  }
 }
 declare class ShortcutResolver extends AbstractResolver<StyleItem$1[]> {
-    resolve(shortcut: string): Promise<StyleItem$1[]>;
+  resolve(shortcut: string): Promise<StyleItem$1[]>;
 }
-
+//#endregion
+//#region src/internal/plugins/variables.d.ts
 type ResolvedCSSProperty = keyof ResolvedCSSProperties;
 type ResolvedCSSVarProperty = ResolvedCSSProperty extends infer T ? T extends `--${string}` ? T : never : never;
 interface VariableAutocomplete {
-    /**
-     * Specify the properties that the variable can be used as a value of.
-     *
-     * @default ['*']
-     */
-    asValueOf?: Arrayable<UnionString | '*' | '-' | ResolvedCSSProperty>;
-    /**
-     * Whether to add the variable as a CSS property.
-     *
-     * @default true
-     */
-    asProperty?: boolean;
+  /**
+   * Specify the properties that the variable can be used as a value of.
+   *
+   * @default ['*']
+   */
+  asValueOf?: Arrayable<UnionString | '*' | '-' | ResolvedCSSProperty>;
+  /**
+   * Whether to add the variable as a CSS property.
+   *
+   * @default true
+   */
+  asProperty?: boolean;
 }
 interface VariableObject {
-    value?: ResolvedCSSProperties[`--${string}`];
-    autocomplete?: VariableAutocomplete;
-    pruneUnused?: boolean;
+  value?: ResolvedCSSProperties[`--${string}`];
+  autocomplete?: VariableAutocomplete;
+  pruneUnused?: boolean;
 }
 type Variable = ResolvedCSSProperties[`--${string}`] | VariableObject;
-type VariablesDefinition = {
-    [key in UnionString | ResolvedSelector | (`--${string}` & {}) | ResolvedCSSVarProperty]?: Variable | VariablesDefinition;
-};
+type VariablesDefinition = { [key in UnionString | ResolvedSelector | (`--${string}` & {}) | ResolvedCSSVarProperty]?: Variable | VariablesDefinition };
 interface VariablesConfig {
-    /**
-     * Define CSS variables with support for static values and autocomplete configuration.
-     *
-     * @default {}
-     * @example
-     * ```ts
-     * {
-     *   variables: {
-     *     // The variable with value "null" will not be included in the final CSS, but can be used in autocompletion.
-     *     '--external-var': null,
-     *
-     *     '--color-bg': '#fff',
-     *     '--color-text': '#000',
-     *
-     *     '[data-theme="dark"]': {
-     *       '--color-bg': '#000',
-     *       '--color-text': '#fff',
-     *     },
-     *   },
-     * }
-     * ```
-     */
-    variables: VariablesDefinition;
-    /**
-     * Whether to prune unused variables from the final CSS.
-     *
-     * @default true
-     */
-    pruneUnused?: boolean;
-    /**
-     * A list of CSS variables that should always be included in the final CSS, you can use this to prevent certain variables from being pruned.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * {
-     *   variables: {
-     *     safeList: ['--external-var', '--color-bg', '--color-text'],
-     *   },
-     * }
-     * ```
-     */
-    safeList?: ((`--${string}` & {}) | ResolvedCSSVarProperty)[];
+  /**
+   * Define CSS variables with support for static values and autocomplete configuration.
+   *
+   * @default {}
+   * @example
+   * ```ts
+   * {
+   *   variables: {
+   *     // The variable with value "null" will not be included in the final CSS, but can be used in autocompletion.
+   *     '--external-var': null,
+   *
+   *     '--color-bg': '#fff',
+   *     '--color-text': '#000',
+   *
+   *     '[data-theme="dark"]': {
+   *       '--color-bg': '#000',
+   *       '--color-text': '#fff',
+   *     },
+   *   },
+   * }
+   * ```
+   */
+  variables: VariablesDefinition;
+  /**
+   * Whether to prune unused variables from the final CSS.
+   *
+   * @default true
+   */
+  pruneUnused?: boolean;
+  /**
+   * A list of CSS variables that should always be included in the final CSS, you can use this to prevent certain variables from being pruned.
+   *
+   * @default []
+   * @example
+   * ```ts
+   * {
+   *   variables: {
+   *     safeList: ['--external-var', '--color-bg', '--color-text'],
+   *   },
+   * }
+   * ```
+   */
+  safeList?: ((`--${string}` & {}) | ResolvedCSSVarProperty)[];
 }
 declare module '@pikacss/core' {
-    interface EngineConfig {
-        variables?: VariablesConfig;
-    }
-    interface Engine {
-        variables: {
-            store: Map<string, ResolvedVariable[]>;
-            add: (variables: VariablesDefinition) => void;
-        };
-    }
-}
-interface ResolvedVariable {
-    name: string;
-    value: PropertyValue;
-    selector: string[];
-    pruneUnused: boolean;
-    autocomplete: {
-        asValueOf: string[];
-        asProperty: boolean;
+  interface EngineConfig {
+    variables?: VariablesConfig;
+  }
+  interface Engine {
+    variables: {
+      store: Map<string, ResolvedVariable[]>;
+      add: (variables: VariablesDefinition) => void;
     };
+  }
 }
-
+interface ResolvedVariable {
+  name: string;
+  value: PropertyValue;
+  selector: string[];
+  pruneUnused: boolean;
+  autocomplete: {
+    asValueOf: string[];
+    asProperty: boolean;
+  };
+}
+//#endregion
+//#region src/internal/types/utils.d.ts
 type Nullish = null | undefined;
 type UnionString = string & {};
 type UnionNumber = number & {};
-type Arrayable<T> = T | T[];
-type Awaitable<T> = T | Promise<T>;
+type Arrayable<T$1> = T$1 | T$1[];
+type Awaitable<T$1> = T$1 | Promise<T$1>;
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-type IsNever<T> = [T] extends [never] ? true : false;
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type ToKebab<T extends string> = T extends `${infer A}${infer B}` ? [A extends Uppercase<A> ? 1 : 0, A extends Lowercase<A> ? 1 : 0] extends [1, 0] ? `-${Lowercase<A>}${ToKebab<`${B}`>}` : `${A}${ToKebab<`${B}`>}` : T;
-type FromKebab<T extends string> = T extends `--${string}` ? T : T extends `-${infer A}${infer B}` ? `${Uppercase<A>}${FromKebab<`${B}`>}` : T extends `${infer A}${infer B}` ? `${A}${FromKebab<`${B}`>}` : T;
-type GetValue<Obj extends Record<string, any>, K extends string> = (IsEqual<Obj, object> | IsEqual<Obj, {}> | IsEqual<Obj[K], unknown>) extends false ? Obj[K] : never;
-type ResolveFrom<T, Key extends string, I, Fallback extends I> = Key extends keyof T ? T[Key] extends I ? T[Key] : Fallback : Fallback;
-
+type IsEqual<X, Y> = (<T$1>() => T$1 extends X ? 1 : 2) extends (<T$1>() => T$1 extends Y ? 1 : 2) ? true : false;
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
+type Simplify<T$1> = { [K in keyof T$1]: T$1[K] } & {};
+type ToKebab<T$1 extends string> = T$1 extends `${infer A}${infer B}` ? [A extends Uppercase<A> ? 1 : 0, A extends Lowercase<A> ? 1 : 0] extends [1, 0] ? `-${Lowercase<A>}${ToKebab<`${B}`>}` : `${A}${ToKebab<`${B}`>}` : T$1;
+type FromKebab<T$1 extends string> = T$1 extends `--${string}` ? T$1 : T$1 extends `-${infer A}${infer B}` ? `${Uppercase<A>}${FromKebab<`${B}`>}` : T$1 extends `${infer A}${infer B}` ? `${A}${FromKebab<`${B}`>}` : T$1;
+type GetValue<Obj extends Record<string, any>, K$1 extends string> = (IsEqual<Obj, object> | IsEqual<Obj, {}> | IsEqual<Obj[K$1], unknown>) extends false ? Obj[K$1] : never;
+type ResolveFrom<T$1, Key$1 extends string, I$1, Fallback extends I$1> = Key$1 extends keyof T$1 ? T$1[Key$1] extends I$1 ? T$1[Key$1] : Fallback : Fallback;
+//#endregion
+//#region src/internal/types/autocomplete.d.ts
 interface ResolvedAutocompleteConfig {
-    selectors: Set<string>;
-    styleItemStrings: Set<string>;
-    extraProperties: Set<string>;
-    extraCssProperties: Set<string>;
-    properties: Map<string, string[]>;
-    cssProperties: Map<string, (string | number)[]>;
+  selectors: Set<string>;
+  styleItemStrings: Set<string>;
+  extraProperties: Set<string>;
+  extraCssProperties: Set<string>;
+  properties: Map<string, string[]>;
+  cssProperties: Map<string, (string | number)[]>;
 }
 interface _Autocomplete {
-    Selector: UnionString;
-    StyleItemString: UnionString;
-    ExtraProperty: UnionString;
-    ExtraCssProperty: UnionString;
-    PropertiesValue: Record<string, unknown>;
-    CssPropertiesValue: Record<string, UnionString | UnionNumber>;
-}
-type DefineAutocomplete<A extends _Autocomplete> = A;
+  Selector: UnionString;
+  StyleItemString: UnionString;
+  ExtraProperty: UnionString;
+  ExtraCssProperty: UnionString;
+  PropertiesValue: Record<string, unknown>;
+  CssPropertiesValue: Record<string, UnionString | UnionNumber>;
+}
+type DefineAutocomplete<A$1 extends _Autocomplete> = A$1;
 type EmptyAutocomplete = DefineAutocomplete<{
-    Selector: never;
-    StyleItemString: never;
-    ExtraProperty: never;
-    ExtraCssProperty: never;
-    PropertiesValue: never;
-    CssPropertiesValue: never;
+  Selector: never;
+  StyleItemString: never;
+  ExtraProperty: never;
+  ExtraCssProperty: never;
+  PropertiesValue: never;
+  CssPropertiesValue: never;
 }>;
-
+//#endregion
+//#region src/internal/plugin.d.ts
 type DefineHooks<Hooks extends Record<string, [type: 'sync' | 'async', payload: any, returnValue?: any]>> = Hooks;
 type EngineHooksDefinition = DefineHooks<{
-    configureRawConfig: ['async', config: EngineConfig];
-    rawConfigConfigured: ['sync', config: EngineConfig, void];
-    configureResolvedConfig: ['async', resolvedConfig: ResolvedEngineConfig];
-    configureEngine: ['async', engine: Engine];
-    transformSelectors: ['async', selectors: string[]];
-    transformStyleItems: ['async', styleItems: ResolvedStyleItem[]];
-    transformStyleDefinitions: ['async', styleDefinitions: ResolvedStyleDefinition[]];
-    preflightUpdated: ['sync', void];
-    atomicStyleAdded: ['sync', AtomicStyle];
-    autocompleteConfigUpdated: ['sync', void];
+  configureRawConfig: ['async', config: EngineConfig];
+  rawConfigConfigured: ['sync', config: EngineConfig, void];
+  configureResolvedConfig: ['async', resolvedConfig: ResolvedEngineConfig];
+  configureEngine: ['async', engine: Engine];
+  transformSelectors: ['async', selectors: string[]];
+  transformStyleItems: ['async', styleItems: ResolvedStyleItem[]];
+  transformStyleDefinitions: ['async', styleDefinitions: ResolvedStyleDefinition[]];
+  preflightUpdated: ['sync', void];
+  atomicStyleAdded: ['sync', AtomicStyle];
+  autocompleteConfigUpdated: ['sync', void];
 }>;
-type EnginePluginHooksOptions = {
-    [K in keyof EngineHooksDefinition]?: EngineHooksDefinition[K][0] extends 'async' ? (...params: EngineHooksDefinition[K][1] extends void ? [] : [payload: EngineHooksDefinition[K][1]]) => Awaitable<EngineHooksDefinition[K][1] | void> : (...params: EngineHooksDefinition[K][1] extends void ? [] : [payload: EngineHooksDefinition[K][1]]) => EngineHooksDefinition[K][1] | void;
-};
+type EnginePluginHooksOptions = { [K in keyof EngineHooksDefinition]?: EngineHooksDefinition[K][0] extends 'async' ? (...params: EngineHooksDefinition[K][1] extends void ? [] : [payload: EngineHooksDefinition[K][1]]) => Awaitable<EngineHooksDefinition[K][1] | void> : (...params: EngineHooksDefinition[K][1] extends void ? [] : [payload: EngineHooksDefinition[K][1]]) => EngineHooksDefinition[K][1] | void };
 interface EnginePlugin extends EnginePluginHooksOptions {
-    name: string;
-    order?: 'pre' | 'post';
+  name: string;
+  order?: 'pre' | 'post';
 }
 declare function defineEnginePlugin(plugin: EnginePlugin): EnginePlugin;
-
-interface PikaAugment {
-}
+//#endregion
+//#region src/internal/types/shared.d.ts
+interface PikaAugment {}
 type PropertyValue = string | number | [value: string | number, fallback: (string | number)[]] | Nullish;
 type Properties$1 = Record<string, PropertyValue>;
 interface StyleDefinition$1 {
-    [K: string]: PropertyValue | StyleDefinition$1 | StyleItem$1[];
+  [K: string]: PropertyValue | StyleDefinition$1 | StyleItem$1[];
 }
 type StyleItem$1 = string | StyleDefinition$1;
 interface ExtractedStyleContent {
-    selector: string[];
-    property: string;
-    value: string[] | Nullish;
+  selector: string[];
+  property: string;
+  value: string[] | Nullish;
 }
 interface StyleContent {
-    selector: string[];
-    property: string;
-    value: string[];
+  selector: string[];
+  property: string;
+  value: string[];
 }
 interface AtomicStyle {
-    id: string;
-    content: StyleContent;
+  id: string;
+  content: StyleContent;
 }
 interface CSSStyleBlockBody {
-    properties: {
-        property: string;
-        value: string;
-    }[];
-    children?: CSSStyleBlocks;
+  properties: {
+    property: string;
+    value: string;
+  }[];
+  children?: CSSStyleBlocks;
 }
 type CSSStyleBlocks = Map<string, CSSStyleBlockBody>;
-
+//#endregion
+//#region src/internal/types/resolved.d.ts
 type ResolvedAutocomplete = ResolveFrom<PikaAugment, 'Autocomplete', _Autocomplete, EmptyAutocomplete>;
 type ResolvedSelector = ResolveFrom<PikaAugment, 'Selector', string, string>;
 type ResolvedProperties = ResolveFrom<PikaAugment, 'Properties', any, Properties$1>;
 type ResolvedCSSProperties = Omit<ResolvedProperties, ResolvedAutocomplete['ExtraProperty']>;
 type ResolvedStyleDefinition = ResolveFrom<PikaAugment, 'StyleDefinition', any, StyleDefinition$1>;
 type ResolvedStyleItem = ResolveFrom<PikaAugment, 'StyleItem', any, StyleItem$1>;
-
-type PreflightDefinition = {
-    [selector in UnionString | ResolvedSelector]?: ResolvedCSSProperties | PreflightDefinition;
-};
+//#endregion
+//#region src/internal/types/preflight.d.ts
+type PreflightDefinition = { [selector in UnionString | ResolvedSelector]?: ResolvedCSSProperties | PreflightDefinition };
 type PreflightFn = (engine: Engine, isFormatted: boolean) => Awaitable<string | PreflightDefinition>;
 /**
  * PreflightConfig can be a string or a function that returns a string.
@@ -394,118 +396,122 @@ type PreflightFn = (engine: Engine, isFormatted: boolean) => Awaitable<string |
  * 2. A function is a dynamic preflight style that can use the engine instance to generate styles.
  */
 type Preflight = string | PreflightDefinition | PreflightFn;
-
+//#endregion
+//#region src/internal/types/engine.d.ts
 interface EngineConfig {
-    /**
-     * Register plugins to extend PikaCSS functionality.
-     *
-     * @example
-     * ```ts
-     * {
-     *   plugins: [
-     *     icons(), // Add icon support
-     *     customPlugin() // Custom plugin
-     *   ]
-     * }
-     * ```
-     */
-    plugins?: EnginePlugin[];
-    /**
-     * Set the prefix for generated atomic style id.
-     *
-     * @default ''
-     * @example
-     * ```ts
-     * {
-     *   prefix: 'pika-' // Generated atomic id will be 'pika-xxx'
-     * }
-     * ```
-     */
-    prefix?: string;
-    /**
-     * Set the default selector format. '%' will be replaced with the atomic style id.
-     *
-     * @default '.%'
-     * @example
-     * ```ts
-     * {
-     *   defaultSelector: '.%' // Use with class attribute: <div class="a b c">
-     *   // or
-     *   defaultSelector: '[data-pika~="%"]' // Use with attribute selector: <div data-pika="a b c">
-     * }
-     * ```
-     */
-    defaultSelector?: string;
-    /**
-     * Define global CSS styles that will be injected before atomic styles.
-     * Can be used for CSS variables, global animations, base styles, etc.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * {
-     *   preflights: [
-     *     // Use CSS string directly
-     *     ':root { --color: blue }',
-     *     // Or use function to generate dynamically
-     *     (engine) => ':root { --theme: dark }'
-     *   ]
-     * }
-     * ```
-     */
-    preflights?: Preflight[];
+  /**
+   * Register plugins to extend PikaCSS functionality.
+   *
+   * @example
+   * ```ts
+   * {
+   *   plugins: [
+   *     icons(), // Add icon support
+   *     customPlugin() // Custom plugin
+   *   ]
+   * }
+   * ```
+   */
+  plugins?: EnginePlugin[];
+  /**
+   * Set the prefix for generated atomic style id.
+   *
+   * @default ''
+   * @example
+   * ```ts
+   * {
+   *   prefix: 'pika-' // Generated atomic id will be 'pika-xxx'
+   * }
+   * ```
+   */
+  prefix?: string;
+  /**
+   * Set the default selector format. '%' will be replaced with the atomic style id.
+   *
+   * @default '.%'
+   * @example
+   * ```ts
+   * {
+   *   defaultSelector: '.%' // Use with class attribute: <div class="a b c">
+   *   // or
+   *   defaultSelector: '[data-pika~="%"]' // Use with attribute selector: <div data-pika="a b c">
+   * }
+   * ```
+   */
+  defaultSelector?: string;
+  /**
+   * Define global CSS styles that will be injected before atomic styles.
+   * Can be used for CSS variables, global animations, base styles, etc.
+   *
+   * @default []
+   * @example
+   * ```ts
+   * {
+   *   preflights: [
+   *     // Use CSS string directly
+   *     ':root { --color: blue }',
+   *     // Or use function to generate dynamically
+   *     (engine) => ':root { --theme: dark }'
+   *   ]
+   * }
+   * ```
+   */
+  preflights?: Preflight[];
 }
 interface ResolvedEngineConfig {
-    rawConfig: EngineConfig;
-    prefix: string;
-    defaultSelector: string;
-    plugins: EnginePlugin[];
-    preflights: PreflightFn[];
-    autocomplete: ResolvedAutocompleteConfig;
-}
-
+  rawConfig: EngineConfig;
+  prefix: string;
+  defaultSelector: string;
+  plugins: EnginePlugin[];
+  preflights: PreflightFn[];
+  autocomplete: ResolvedAutocompleteConfig;
+}
+//#endregion
+//#region src/internal/extractor.d.ts
 type ExtractFn = (styleDefinition: StyleDefinition$1) => Promise<ExtractedStyleContent[]>;
-
+//#endregion
+//#region src/internal/engine.d.ts
 declare function defineEngineConfig(config: EngineConfig): EngineConfig;
 declare function createEngine(config?: EngineConfig): Promise<Engine>;
 declare class Engine {
-    config: ResolvedEngineConfig;
-    pluginHooks: {
-        configureRawConfig: (plugins: _pikacss_core.EnginePlugin[], payload: EngineConfig) => Promise<EngineConfig>;
-        rawConfigConfigured: (plugins: _pikacss_core.EnginePlugin[], payload: EngineConfig) => void;
-        configureResolvedConfig: (plugins: _pikacss_core.EnginePlugin[], payload: ResolvedEngineConfig) => Promise<ResolvedEngineConfig>;
-        configureEngine: (plugins: _pikacss_core.EnginePlugin[], payload: Engine) => Promise<Engine>;
-        transformSelectors: (plugins: _pikacss_core.EnginePlugin[], payload: string[]) => Promise<string[]>;
-        transformStyleItems: (plugins: _pikacss_core.EnginePlugin[], payload: StyleItem$1[]) => Promise<StyleItem$1[]>;
-        transformStyleDefinitions: (plugins: _pikacss_core.EnginePlugin[], payload: StyleDefinition$1[]) => Promise<StyleDefinition$1[]>;
-        preflightUpdated: (plugins: _pikacss_core.EnginePlugin[]) => void;
-        atomicStyleAdded: (plugins: _pikacss_core.EnginePlugin[], payload: AtomicStyle) => AtomicStyle;
-        autocompleteConfigUpdated: (plugins: _pikacss_core.EnginePlugin[]) => void;
-    };
-    extract: ExtractFn;
-    store: {
-        atomicStyleIds: Map<string, string>;
-        atomicStyles: Map<string, AtomicStyle>;
-    };
-    constructor(config: ResolvedEngineConfig);
-    notifyPreflightUpdated(): void;
-    notifyAtomicStyleAdded(atomicStyle: AtomicStyle): void;
-    notifyAutocompleteConfigUpdated(): void;
-    appendAutocompleteSelectors(...selectors: string[]): void;
-    appendAutocompleteStyleItemStrings(...styleItemStrings: string[]): void;
-    appendAutocompleteExtraProperties(...properties: string[]): void;
-    appendAutocompleteExtraCssProperties(...properties: string[]): void;
-    appendAutocompletePropertyValues(property: string, ...tsTypes: string[]): void;
-    appendAutocompleteCssPropertyValues(property: string, ...values: (string | number)[]): void;
-    addPreflight(preflight: Preflight): void;
-    use(...itemList: StyleItem$1[]): Promise<string[]>;
-    renderPreflights(isFormatted: boolean): Promise<string>;
-    renderAtomicStyles(isFormatted: boolean, options?: {
-        atomicStyleIds?: string[];
-        isPreview?: boolean;
-    }): Promise<string>;
-}
-
+  config: ResolvedEngineConfig;
+  pluginHooks: {
+    configureRawConfig: (plugins: EnginePlugin[], payload: EngineConfig) => Promise<EngineConfig>;
+    rawConfigConfigured: (plugins: EnginePlugin[], payload: EngineConfig) => void;
+    configureResolvedConfig: (plugins: EnginePlugin[], payload: ResolvedEngineConfig) => Promise<ResolvedEngineConfig>;
+    configureEngine: (plugins: EnginePlugin[], payload: Engine) => Promise<Engine>;
+    transformSelectors: (plugins: EnginePlugin[], payload: string[]) => Promise<string[]>;
+    transformStyleItems: (plugins: EnginePlugin[], payload: StyleItem$1[]) => Promise<StyleItem$1[]>;
+    transformStyleDefinitions: (plugins: EnginePlugin[], payload: StyleDefinition$1[]) => Promise<StyleDefinition$1[]>;
+    preflightUpdated: (plugins: EnginePlugin[]) => void;
+    atomicStyleAdded: (plugins: EnginePlugin[], payload: AtomicStyle) => AtomicStyle;
+    autocompleteConfigUpdated: (plugins: EnginePlugin[]) => void;
+  };
+  extract: ExtractFn;
+  store: {
+    atomicStyleIds: Map<string, string>;
+    atomicStyles: Map<string, AtomicStyle>;
+  };
+  constructor(config: ResolvedEngineConfig);
+  notifyPreflightUpdated(): void;
+  notifyAtomicStyleAdded(atomicStyle: AtomicStyle): void;
+  notifyAutocompleteConfigUpdated(): void;
+  appendAutocompleteSelectors(...selectors: string[]): void;
+  appendAutocompleteStyleItemStrings(...styleItemStrings: string[]): void;
+  appendAutocompleteExtraProperties(...properties: string[]): void;
+  appendAutocompleteExtraCssProperties(...properties: string[]): void;
+  appendAutocompletePropertyValues(property: string, ...tsTypes: string[]): void;
+  appendAutocompleteCssPropertyValues(property: string, ...values: (string | number)[]): void;
+  addPreflight(preflight: Preflight): void;
+  use(...itemList: StyleItem$1[]): Promise<string[]>;
+  renderPreflights(isFormatted: boolean): Promise<string>;
+  renderAtomicStyles(isFormatted: boolean, options?: {
+    atomicStyleIds?: string[];
+    isPreview?: boolean;
+  }): Promise<string>;
+}
+//#endregion
+//#region src/internal/utils.d.ts
 declare function setWarnFn(fn: (...args: any[]) => void): void;
 declare function warn(...args: any[]): void;
 declare function appendAutocompleteSelectors(config: Pick<ResolvedEngineConfig, 'autocomplete'>, ...selectors: string[]): void;
@@ -515,25 +521,21 @@ declare function appendAutocompleteExtraCssProperties(config: Pick<ResolvedEngin
 declare function appendAutocompletePropertyValues(config: Pick<ResolvedEngineConfig, 'autocomplete'>, property: string, ...tsTypes: string[]): void;
 declare function appendAutocompleteCssPropertyValues(config: Pick<ResolvedEngineConfig, 'autocomplete'>, property: string, ...values: (string | number)[]): void;
 declare function renderCSSStyleBlocks(blocks: CSSStyleBlocks, isFormatted: boolean, depth?: number): string;
-
+//#endregion
+//#region src/types.d.ts
 interface CSSVariables {
-    [K: (`--${string}` & {})]: UnionString | UnionNumber;
-}
-interface CSSProperties extends CSS.Properties, CSS.PropertiesHyphen, CSSVariables {
+  [K: (`--${string}` & {})]: UnionString | UnionNumber;
 }
+interface CSSProperties extends CSS.Properties, CSS.PropertiesHyphen, CSSVariables {}
 type CSSProperty = keyof CSSProperties;
-type MakePropertyValue<T> = T | [value: T, fallback: T[]] | Nullish;
-type Properties = {
-    [Key in keyof CSSProperties | ResolvedAutocomplete['ExtraCssProperty'] | ResolvedAutocomplete['ExtraProperty']]?: Key extends ResolvedAutocomplete['ExtraProperty'] ? GetValue<ResolvedAutocomplete['PropertiesValue'], Key> : MakePropertyValue<Exclude<UnionString | UnionNumber | GetValue<CSSProperties, Key> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], ToKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], FromKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], '*'>, Nullish>>;
-};
+type MakePropertyValue<T$1> = T$1 | [value: T$1, fallback: T$1[]] | Nullish;
+type Properties = { [Key in keyof CSSProperties | ResolvedAutocomplete['ExtraCssProperty'] | ResolvedAutocomplete['ExtraProperty']]?: Key extends ResolvedAutocomplete['ExtraProperty'] ? GetValue<ResolvedAutocomplete['PropertiesValue'], Key> : MakePropertyValue<Exclude<UnionString | UnionNumber | GetValue<CSSProperties, Key> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], ToKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], FromKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], '*'>, Nullish>> };
 type CSSPseudos = `${'$'}${CSS.Pseudos}`;
 type CSSBlockAtRules = Exclude<CSS.AtRules, '@charset' | 'import' | '@namespace'>;
 type CSSSelectors = CSSBlockAtRules | CSSPseudos;
-type WrapWithSelector<T> = {
-    [S in UnionString | ResolvedAutocomplete['Selector'] | CSSSelectors]?: T | StyleItem[];
-};
+type WrapWithSelector<T$1> = { [S in UnionString | ResolvedAutocomplete['Selector'] | CSSSelectors]?: T$1 | StyleItem[] };
 type MakeStyleDefinition<MaxDepth extends number, Tuple extends any[] = []> = Tuple['length'] extends MaxDepth ? Tuple[number] : Tuple['length'] extends 0 ? MakeStyleDefinition<MaxDepth, [Properties]> : MakeStyleDefinition<MaxDepth, [...Tuple, WrapWithSelector<[0, ...Tuple][Tuple['length']]>]>;
 type StyleDefinition = MakeStyleDefinition<5>;
 type StyleItem = UnionString | ResolvedAutocomplete['StyleItemString'] | StyleDefinition;
-
-export { type Arrayable, type Awaitable, type CSSProperty, type CSSSelectors, type CSSStyleBlockBody, type CSSStyleBlocks, type DefineAutocomplete, Engine, type EngineConfig, type EnginePlugin, type FromKebab, type GetValue, type IsEqual, type IsNever, type Nullish, type PikaAugment, type Properties, type ResolveFrom, type Simplify, type StyleDefinition, type StyleItem, type ToKebab, type UnionNumber, type UnionString, type UnionToIntersection, appendAutocompleteCssPropertyValues, appendAutocompleteExtraCssProperties, appendAutocompleteExtraProperties, appendAutocompletePropertyValues, appendAutocompleteSelectors, appendAutocompleteStyleItemStrings, createEngine, defineEngineConfig, defineEnginePlugin, renderCSSStyleBlocks, setWarnFn, warn };
+//#endregion
+export { Arrayable, Awaitable, type CSSProperty, type CSSSelectors, type CSSStyleBlockBody, type CSSStyleBlocks, type DefineAutocomplete, type Engine, type EngineConfig, type EnginePlugin, FromKebab, GetValue, IsEqual, IsNever, Nullish, type PikaAugment, type Properties, ResolveFrom, Simplify, type StyleDefinition, type StyleItem, ToKebab, UnionNumber, UnionString, UnionToIntersection, appendAutocompleteCssPropertyValues, appendAutocompleteExtraCssProperties, appendAutocompleteExtraProperties, appendAutocompletePropertyValues, appendAutocompleteSelectors, appendAutocompleteStyleItemStrings, createEngine, defineEngineConfig, defineEnginePlugin, renderCSSStyleBlocks, setWarnFn, warn };