@pikacss/core 0.0.42 → 0.0.44

package/dist/index.d.cts

@@ -1,637 +0,0 @@
-import * as CSS from "csstype";
-
-//#region src/internal/plugins/important.d.ts
-interface ImportantConfig {
-  default?: boolean;
-}
-declare module '@pikacss/core' {
-  interface EngineConfig {
-    important?: ImportantConfig;
-  }
-}
-declare function important(): EnginePlugin;
-//#endregion
-//#region src/internal/resolver.d.ts
-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> {
-  _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;
-}
-//#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: 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[];
-}
-declare module '@pikacss/core' {
-  interface EngineConfig {
-    selectors?: SelectorsConfig;
-  }
-  interface Engine {
-    selectors: {
-      resolver: SelectorResolver;
-      add: (...list: Selector[]) => void;
-    };
-  }
-}
-declare function selectors$1(): EnginePlugin;
-type StaticSelectorRule = StaticRule<string[]>;
-type DynamicSelectorRule = DynamicRule<string[]>;
-declare class SelectorResolver extends AbstractResolver<string[]> {
-  resolve(selector: string): Promise<string[]>;
-}
-type ResolvedSelectorConfig = {
-  type: 'static';
-  rule: StaticSelectorRule;
-  autocomplete: string[];
-} | {
-  type: 'dynamic';
-  rule: DynamicSelectorRule;
-  autocomplete: string[];
-};
-declare function resolveSelectorConfig(config: Selector): ResolvedSelectorConfig | string | Nullish;
-//#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: 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[];
-}
-declare module '@pikacss/core' {
-  interface EngineConfig {
-    shortcuts?: ShortcutsConfig;
-  }
-  interface Engine {
-    shortcuts: {
-      resolver: ShortcutResolver;
-      add: (...list: Shortcut[]) => void;
-    };
-  }
-}
-declare function shortcuts(): EnginePlugin;
-declare class ShortcutResolver extends AbstractResolver<InternalStyleItem[]> {
-  resolve(shortcut: string): Promise<InternalStyleItem[]>;
-}
-//#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;
-}
-interface VariableObject {
-  value?: ResolvedCSSProperties[`--${string}`];
-  autocomplete?: VariableAutocomplete;
-  pruneUnused?: boolean;
-}
-type Variable = ResolvedCSSProperties[`--${string}`] | VariableObject;
-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: Arrayable<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;
-    };
-  }
-}
-declare function variables(): EnginePlugin;
-interface ResolvedVariable {
-  name: string;
-  value: InternalPropertyValue;
-  selector: string[];
-  pruneUnused: boolean;
-  autocomplete: {
-    asValueOf: string[];
-    asProperty: boolean;
-  };
-}
-declare function extractUsedVarNames(input: string): string[];
-declare function normalizeVariableName(name: string): string;
-//#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 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$1 extends string> = (IsEqual<Obj, object> | IsEqual<Obj, {}> | IsEqual<Obj[K$1], unknown>) extends false ? Obj[K$1] : never;
-type ResolveFrom<T, Key$1 extends string, I, Fallback extends I> = Key$1 extends keyof T ? T[Key$1] extends I ? T[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)[]>;
-}
-interface _Autocomplete {
-  Selector: UnionString;
-  StyleItemString: UnionString;
-  ExtraProperty: UnionString;
-  ExtraCssProperty: UnionString;
-  Layer: 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;
-  Layer: never;
-  PropertiesValue: never;
-  CssPropertiesValue: never;
-}>;
-//#endregion
-//#region src/internal/extractor.d.ts
-type ExtractFn = (styleDefinition: InternalStyleDefinition) => Promise<ExtractedStyleContent[]>;
-//#endregion
-//#region src/internal/engine.d.ts
-declare function createEngine(config?: EngineConfig$1): Promise<Engine>;
-declare class Engine {
-  config: ResolvedEngineConfig;
-  pluginHooks: {
-    configureRawConfig: (plugins: EnginePlugin[], payload: EngineConfig$1) => Promise<EngineConfig$1>;
-    rawConfigConfigured: (plugins: EnginePlugin[], payload: EngineConfig$1) => 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[]) => Promise<StyleItem[]>;
-    transformStyleDefinitions: (plugins: EnginePlugin[], payload: StyleDefinition[]) => Promise<StyleDefinition[]>;
-    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: InternalStyleItem[]): Promise<string[]>;
-  renderPreflights(isFormatted: boolean): Promise<string>;
-  renderAtomicStyles(isFormatted: boolean, options?: {
-    atomicStyleIds?: string[];
-    isPreview?: boolean;
-  }): Promise<string>;
-  renderLayerOrderDeclaration(): string;
-}
-declare function sortLayerNames(layers: Record<string, number>): string[];
-//#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$1];
-  rawConfigConfigured: ['sync', config: EngineConfig$1, 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 };
-interface EnginePlugin extends EnginePluginHooksOptions {
-  name: string;
-  order?: 'pre' | 'post';
-}
-declare function defineEnginePlugin(plugin: EnginePlugin): EnginePlugin;
-//#endregion
-//#region src/types.d.ts
-interface CSSVariables {
-  [K: (`--${string}` & {})]: UnionString | UnionNumber;
-}
-interface CSSProperties extends CSS.Properties, CSS.PropertiesHyphen, CSSVariables {}
-type CSSProperty = keyof CSSProperties;
-type PropertyValue<T> = T | [value: T, fallback: T[]] | Nullish;
-type Properties_CSS = { [Key in keyof CSSProperties]?: PropertyValue<Exclude<UnionString | UnionNumber | GetValue<CSSProperties, Key> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], ToKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], FromKebab<Key>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], '*'>, Nullish>> };
-type Properties_ExtraCSS = { [Key in keyof ResolvedAutocomplete['ExtraCssProperty']]?: PropertyValue<Exclude<UnionString | UnionNumber | GetValue<CSSProperties, Key & string> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], ToKebab<Key & string>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], FromKebab<Key & string>> | GetValue<ResolvedAutocomplete['CssPropertiesValue'], '*'>, Nullish>> };
-type Properties_Extra = { [Key in ResolvedAutocomplete['ExtraProperty']]?: GetValue<ResolvedAutocomplete['PropertiesValue'], Key & string> };
-interface Properties extends Properties_CSS, Properties_ExtraCSS, Properties_Extra {}
-type CSSPseudos = `${'$'}${CSS.Pseudos}`;
-type CSSBlockAtRules = Exclude<CSS.AtRules, '@charset' | 'import' | '@namespace'>;
-type CSSSelector = CSSBlockAtRules | CSSPseudos;
-type Selector$1 = UnionString | ResolvedAutocomplete['Selector'] | CSSSelector;
-type StyleDefinition = Properties | { [K in Selector$1]?: Properties | StyleDefinition | StyleItem[] };
-type StyleItem = UnionString | ResolvedAutocomplete['StyleItemString'] | StyleDefinition;
-//#endregion
-//#region src/internal/types/shared.d.ts
-interface PikaAugment {}
-type InternalPropertyValue = PropertyValue<string | number>;
-type InternalProperties = Properties;
-type InternalStyleDefinition = StyleDefinition;
-type InternalStyleItem = StyleItem;
-interface ExtractedStyleContent {
-  selector: string[];
-  property: string;
-  value: string[] | Nullish;
-  layer?: string;
-}
-interface StyleContent {
-  selector: string[];
-  property: string;
-  value: string[];
-  layer?: string;
-}
-interface AtomicStyle {
-  id: string;
-  content: StyleContent;
-}
-interface CSSStyleBlockBody {
-  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 ResolvedLayerName = IsNever<ResolvedAutocomplete['Layer']> extends true ? UnionString : ResolvedAutocomplete['Layer'];
-type ResolvedSelector = ResolveFrom<PikaAugment, 'Selector', string, string>;
-type ResolvedProperties = ResolveFrom<PikaAugment, 'Properties', any, InternalProperties>;
-type ResolvedCSSProperties = Omit<ResolvedProperties, ResolvedAutocomplete['ExtraProperty']>;
-type ResolvedStyleDefinition = ResolveFrom<PikaAugment, 'StyleDefinition', any, InternalStyleDefinition>;
-type ResolvedStyleItem = ResolveFrom<PikaAugment, 'StyleItem', any, InternalStyleItem>;
-//#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>;
-interface WithLayer<T extends string | PreflightDefinition | PreflightFn> {
-  layer: string;
-  preflight: T;
-}
-interface ResolvedPreflight {
-  layer?: string;
-  fn: PreflightFn;
-}
-/**
- * Preflight can be a string, object, function, or a layer-wrapped variant.
- *
- * 1. A `string` is a static preflight style injected verbatim.
- * 2. A `PreflightDefinition` is a JS object describing CSS rules.
- * 3. A `PreflightFn` is a dynamic preflight that receives the engine instance.
- * 4. A `WithLayer` wrapper assigns any of the above to a specific CSS `@layer`.
- */
-type Preflight = string | PreflightDefinition | PreflightFn | WithLayer<string | PreflightDefinition | PreflightFn>;
-//#endregion
-//#region src/internal/types/engine.d.ts
-interface EngineConfig$1 {
-  /**
-   * 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[];
-  /**
-   * Configure CSS @layer order. Keys are layer names, values are order numbers (lower = earlier).
-   * Merged on top of the default layers `{ preflights: 1, utilities: 10 }`, so any keys not
-   * specified here will keep their default order values.
-   *
-   * @default { preflights: 1, utilities: 10 }
-   * @example
-   * ```ts
-   * {
-   *   layers: { base: 0, components: 5, utilities: 10 }
-   * }
-   * ```
-   */
-  layers?: Record<string, number>;
-  /**
-   * The layer name that unlayered preflights are automatically wrapped into.
-   *
-   * @default 'preflights'
-   */
-  defaultPreflightsLayer?: string;
-  /**
-   * The layer name that atomic styles without an explicit `__layer` are placed into.
-   *
-   * @default 'utilities'
-   */
-  defaultUtilitiesLayer?: string;
-}
-interface ResolvedEngineConfig {
-  rawConfig: EngineConfig$1;
-  prefix: string;
-  defaultSelector: string;
-  plugins: EnginePlugin[];
-  preflights: ResolvedPreflight[];
-  autocomplete: ResolvedAutocompleteConfig;
-  /** Always contains at least the default layers (`preflights` and `utilities`). */
-  layers: Record<string, number>;
-  defaultPreflightsLayer: string;
-  defaultUtilitiesLayer: string;
-}
-//#endregion
-//#region src/internal/plugins/keyframes.d.ts
-interface KeyframesProgress {
-  from?: ResolvedProperties;
-  to?: ResolvedProperties;
-  [K: `${number}%`]: ResolvedProperties;
-}
-type Keyframes = string | [name: string, frames?: KeyframesProgress, autocomplete?: string[], pruneUnused?: boolean] | {
-  name: string;
-  frames?: KeyframesProgress;
-  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;
-}
-declare module '@pikacss/core' {
-  interface EngineConfig {
-    keyframes?: KeyframesConfig;
-  }
-  interface Engine {
-    keyframes: {
-      store: Map<string, ResolvedKeyframesConfig>;
-      add: (...list: Keyframes[]) => void;
-    };
-  }
-}
-declare function keyframes(): EnginePlugin;
-interface ResolvedKeyframesConfig {
-  name: string;
-  frames: KeyframesProgress | Nullish;
-  pruneUnused: boolean;
-  autocomplete: string[];
-}
-//#endregion
-//#region src/internal/utils.d.ts
-declare function createLogger(prefix: string): {
-  debug: (...args: any[]) => void;
-  info: (...args: any[]) => void;
-  warn: (...args: any[]) => void;
-  error: (...args: any[]) => void;
-  toggleDebug: () => void;
-  setPrefix: (newPrefix: string) => void;
-  setDebugFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setInfoFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setWarnFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setErrorFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-};
-declare const log: {
-  debug: (...args: any[]) => void;
-  info: (...args: any[]) => void;
-  warn: (...args: any[]) => void;
-  error: (...args: any[]) => void;
-  toggleDebug: () => void;
-  setPrefix: (newPrefix: string) => void;
-  setDebugFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setInfoFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setWarnFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-  setErrorFn: (fn: (prefix: string, ...args: any[]) => void) => void;
-};
-declare function appendAutocompleteSelectors(config: Pick<ResolvedEngineConfig, 'autocomplete'>, ...selectors: string[]): void;
-declare function appendAutocompleteStyleItemStrings(config: Pick<ResolvedEngineConfig, 'autocomplete'>, ...styleItemStrings: string[]): void;
-declare function appendAutocompleteExtraProperties(config: Pick<ResolvedEngineConfig, 'autocomplete'>, ...properties: string[]): void;
-declare function appendAutocompleteExtraCssProperties(config: Pick<ResolvedEngineConfig, 'autocomplete'>, ...properties: string[]): void;
-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/index.d.ts
-declare function defineEngineConfig(config: EngineConfig): EngineConfig;
-declare function defineStyleDefinition(styleDefinition: StyleDefinition): StyleDefinition;
-declare function definePreflight(preflight: Preflight): Preflight;
-declare function defineKeyframes(keyframes: Keyframes): Keyframes;
-declare function defineSelector(selector: Selector): Selector;
-declare function defineShortcut(shortcut: Shortcut): Shortcut;
-declare function defineVariables(variables: VariablesDefinition): VariablesDefinition;
-//#endregion
-export { Arrayable, Awaitable, type CSSProperty, type CSSSelector, type CSSStyleBlockBody, type CSSStyleBlocks, type DefineAutocomplete, type Engine, type EngineConfig$1 as EngineConfig, type EnginePlugin, FromKebab, GetValue, IsEqual, IsNever, Keyframes, KeyframesConfig, KeyframesProgress, Nullish, type PikaAugment, type Preflight, type PreflightDefinition, type PreflightFn, type Properties, ResolveFrom, type ResolvedLayerName, type ResolvedPreflight, Selector, SelectorsConfig, Shortcut, ShortcutsConfig, Simplify, type StyleDefinition, type StyleItem, ToKebab, UnionNumber, UnionString, UnionToIntersection, Variable, VariableAutocomplete, VariableObject, VariablesConfig, VariablesDefinition, type WithLayer, appendAutocompleteCssPropertyValues, appendAutocompleteExtraCssProperties, appendAutocompleteExtraProperties, appendAutocompletePropertyValues, appendAutocompleteSelectors, appendAutocompleteStyleItemStrings, createEngine, createLogger, defineEngineConfig, defineEnginePlugin, defineKeyframes, definePreflight, defineSelector, defineShortcut, defineStyleDefinition, defineVariables, extractUsedVarNames, important, keyframes, log, normalizeVariableName, renderCSSStyleBlocks, resolveSelectorConfig, selectors$1 as selectors, shortcuts, sortLayerNames, variables };