@bamboocss/core 1.12.0 → 1.12.2

package/dist/index.d.cts

@@ -1,1025 +0,0 @@
-import { TokenDictionary } from "@bamboocss/token-dictionary";
-import { ArtifactFilters, AtRuleCondition, AtomicRecipeRule, AtomicRule, AtomicStyleResult, BambooHooks, CascadeLayer, CascadeLayers, ConditionDetails, ConditionQuery, Conditions as Conditions$1, Config, CssKeyframes, CssRule, Dict, EncoderJson, GlobalFontface, GlobalPositionTry, GlobalVarsDefinition, GroupedResult, GroupedRule, HashOptions, ImportMapInput, ImportMapOutput, LoadConfigResult, PartialBy, PatternConfig, PatternHelpers, PatternProperty, PatternRule, PrefixOptions, PropertyConfig, RecipeBaseResult, RecipeConfig, RecipeDefinition, RecipeRule, RecipeVariantsRule, RequiredBy, ResultItem, SlotRecipeConfig, SlotRecipeDefinition, StaticCssOptions, StudioOptions, StyleEntry, StyleProps, StyleResultObject, SystemStyleObject, TSConfig, Theme, ThemeVariantsMap, UserConfig, UtilityConfig } from "@bamboocss/types";
-import postcss, { AtRule, Root } from "postcss";
-import { CssOptions as CssOptions$1, RecipeNode as RecipeNode$1, Stylesheet as Stylesheet$1 } from "@bamboocss/core";
-import { toHash } from "@bamboocss/shared";
-
-//#region \0rolldown/runtime.js
-//#endregion
-//#region src/breakpoints.d.ts
-declare class Breakpoints {
-  private breakpoints;
-  sorted: ReturnType<typeof sortBreakpoints>;
-  values: Record<string, BreakpointEntry>;
-  keys: string[];
-  ranges: Record<string, string>;
-  conditions: Record<string, AtRuleCondition>;
-  constructor(breakpoints: Record<string, string>);
-  get: (name: string) => BreakpointEntry;
-  build: ({
-    min,
-    max
-  }: {
-    min?: string | null;
-    max?: string | null;
-  }) => string;
-  only: (name: string) => string;
-  private getRanges;
-  private getConditions;
-  getCondition: (key: string) => ConditionDetails | undefined;
-  expandScreenAtRule: (root: Root) => void;
-}
-type BreakpointEntry = {
-  name: string;
-  min?: string | null;
-  max?: string | null;
-};
-type Entries = [string, BreakpointEntry][];
-declare function sortBreakpoints(breakpoints: Record<string, string>): Entries;
-//#endregion
-//#region src/conditions.d.ts
-interface Options {
-  conditions?: Conditions$1;
-  breakpoints?: Record<string, string>;
-  containerNames?: string[];
-  containerSizes?: Record<string, string>;
-  themes?: ThemeVariantsMap;
-}
-declare class Conditions {
-  private options;
-  values: Record<string, ConditionDetails>;
-  breakpoints: Breakpoints;
-  constructor(options: Options);
-  private setupContainers;
-  private setupThemes;
-  getThemeSelector: (name: string) => string;
-  getThemeName: (theme: string) => string;
-  finalize: (paths: string[]) => string[];
-  shift: (paths: string[]) => string[];
-  segment: (paths: string[]) => {
-    condition: string[];
-    selector: string[];
-  };
-  has: (key: string) => boolean;
-  isCondition: (key: string) => boolean;
-  isEmpty: () => boolean;
-  get: (key: string) => ConditionQuery | undefined;
-  getRaw: (condNameOrQuery: ConditionQuery) => ConditionDetails | undefined;
-  sort: (conditions: string[]) => ConditionDetails[];
-  normalize: (condition: ConditionQuery | ConditionDetails) => ConditionDetails | undefined;
-  keys: () => string[];
-  saveOne: (key: string, value: string) => void;
-  remove(key: string): void;
-  getSortedKeys: () => string[];
-}
-//#endregion
-//#region src/file.d.ts
-declare class FileEngine {
-  private context;
-  constructor(context: Pick<Context, 'config'>);
-  private get forceConsistentTypeExtension();
-  private get outExtension();
-  ext(file: string): string;
-  extDts(file: string): string;
-  private __extDts;
-  import(mod: string, file: string): string;
-  importType(mod: string, file: string): string;
-  exportType(mod: string, file: string): string;
-  exportStar(file: string): string;
-  exportTypeStar(file: string): string;
-  isTypeFile(file: string): boolean;
-  jsDocComment(comment: string | undefined, options?: {
-    deprecated?: boolean | string;
-    default?: string;
-  }): string;
-  /**
-   * convert import type { CompositionStyleObject } from './system-types'
-   * to import type { CompositionStyleObject } from './system-types.d.ts'
-   */
-  rewriteTypeImport(code: string): string;
-}
-//#endregion
-//#region src/global-fontface.d.ts
-interface GlobalFontfaceOptions$1 {
-  globalFontface?: GlobalFontface;
-}
-declare class GlobalFontface$1 {
-  private options;
-  names: string[];
-  constructor(options: GlobalFontfaceOptions$1);
-  isEmpty(): boolean;
-  toString(): string;
-}
-//#endregion
-//#region src/global-position-try.d.ts
-interface GlobalFontfaceOptions {
-  globalPositionTry?: GlobalPositionTry;
-}
-declare class GlobalPositionTry$1 {
-  private opts;
-  names: string[];
-  constructor(opts: GlobalFontfaceOptions);
-  isEmpty(): boolean;
-  toString(): string;
-}
-//#endregion
-//#region src/global-vars.d.ts
-interface GlobalVarsOptions {
-  globalVars?: GlobalVarsDefinition;
-  cssVarRoot: string;
-}
-declare class GlobalVars {
-  private options;
-  keys: Set<string>;
-  vars: string[];
-  names: string[];
-  constructor(options: GlobalVarsOptions);
-  isEmpty(): boolean;
-  toString(): string;
-}
-//#endregion
-//#region src/style-encoder.d.ts
-declare class StyleEncoder {
-  private context;
-  static separator: string;
-  static conditionSeparator: string;
-  atomic: Set<string>;
-  compound_variants: Set<string>;
-  recipes: Map<string, Set<string>>;
-  recipes_base: Map<string, Set<string>>;
-  grouped: Map<string, Set<string>>;
-  constructor(context: Pick<Context, 'isTemplateLiteralSyntax' | 'isValidProperty' | 'recipes' | 'patterns' | 'conditions' | 'utility'>);
-  filterStyleProps: (props: Dict) => Dict;
-  clone: () => StyleEncoder;
-  isEmpty: () => boolean;
-  get results(): {
-    atomic: Set<string>;
-    recipes: Map<string, Set<string>>;
-    recipes_base: Map<string, Set<string>>;
-    grouped: Map<string, Set<string>>;
-  };
-  /**
-   * Hashes a style object and adds the resulting hashes to a set.
-   * @param set - The set to add the resulting hashes to.
-   * @param obj - The style object to hash.
-   * @param baseEntry - An optional base style entry to use when hashing the style object.
-   */
-  hashStyleObject: (set: Set<string>, obj: ResultItem["data"][number], baseEntry?: Partial<Omit<StyleEntry, "prop" | "value" | "cond">>) => void;
-  processAtomic: (styles: StyleResultObject) => void;
-  processGrouped: (styles: StyleResultObject) => void;
-  processStyleProps: (styleProps: StyleProps, grouped?: boolean) => void;
-  processConfigSlotRecipeBase: (recipeName: string, config: SlotRecipeDefinition) => void;
-  processConfigSlotRecipe: (recipeName: string, variants: Record<string, any>) => void;
-  processConfigRecipeBase: (recipeName: string, config: RecipeConfig) => void;
-  processConfigRecipe: (recipeName: string, variants: Record<string, any>) => void;
-  processRecipe: (recipeName: string, variants: Record<string, any>) => void;
-  processRecipeBase(recipeName: string): void;
-  processPattern: (name: string, patternProps: StyleResultObject, type?: "pattern" | "jsx-pattern", jsxName?: string | undefined) => void;
-  processAtomicRecipe: (recipe: Pick<RecipeConfig, "base" | "variants" | "compoundVariants">) => void;
-  processAtomicSlotRecipe: (recipe: PartialBy<SlotRecipeDefinition, "slots">) => void;
-  getConfigRecipeHash: (recipeName: string) => {
-    atomic: Set<string>;
-    base: Set<string>;
-    variants: Set<string>;
-  };
-  getConfigSlotRecipeHash: (recipeName: string) => {
-    atomic: Set<string>;
-    base: Dict;
-    variants: Set<string>;
-  };
-  getRecipeHash: (recipeName: string) => {
-    atomic: Set<string>;
-    base: Set<string>;
-    variants: Set<string>;
-  } | {
-    atomic: Set<string>;
-    base: Dict;
-    variants: Set<string>;
-  };
-  toJSON: () => {
-    schemaVersion: string;
-    styles: Record<string, any>;
-  };
-  fromJSON: (json: EncoderJson) => this;
-}
-//#endregion
-//#region src/style-decoder.d.ts
-declare class StyleDecoder {
-  private context;
-  constructor(context: Pick<Context, 'conditions' | 'utility' | 'recipes' | 'hash'>);
-  classNames: Map<string, AtomicStyleResult | RecipeBaseResult | GroupedResult>;
-  atomic_cache: Map<string, AtomicStyleResult>;
-  group_cache: Map<string, GroupedResult>;
-  recipe_base_cache: Map<string, RecipeBaseResult>;
-  atomic: Set<AtomicStyleResult>;
-  grouped: Set<GroupedResult>;
-  recipes: Map<string, Set<AtomicStyleResult>>;
-  recipes_base: Map<string, Set<RecipeBaseResult>>;
-  clone: () => StyleDecoder;
-  isEmpty: () => boolean;
-  get results(): {
-    atomic: Set<AtomicStyleResult>;
-    grouped: Set<GroupedResult>;
-    recipes: Map<string, Set<AtomicStyleResult>>;
-    recipes_base: Map<string, Set<RecipeBaseResult>>;
-  };
-  private formatSelector;
-  private getRecipeName;
-  private getTransformResult;
-  resolveCondition: (condition: ConditionDetails) => string | string[];
-  /**
-   * Expands multi-block conditions into separate sets of conditions.
-   * Each block becomes an independent condition set that produces its own CSS block.
-   * When multiple multi-block conditions are stacked (e.g. two custom multi-block
-   * conditions used together), the cartesian product of all blocks is produced.
-   * Returns null if no multi-block condition is found.
-   */
-  private expandMultiBlock;
-  private getAtomic;
-  getGroup: (hashSet: Set<string>, key: string) => GroupedResult;
-  private getRecipeBase;
-  collectAtomic: (encoder: StyleEncoder) => this;
-  private processClassName;
-  collectRecipe: (encoder: StyleEncoder) => void;
-  collectRecipeBase: (encoder: StyleEncoder) => void;
-  collectGrouped: (encoder: StyleEncoder) => void;
-  /**
-   * Collect and re-create all styles and recipes objects from the style encoder
-   * So that we can just iterate over them and transform resulting CSS objects into CSS strings
-   */
-  collect: (encoder: StyleEncoder) => this;
-  getConfigRecipeResult: (recipeName: string) => {
-    atomic: Set<AtomicStyleResult>;
-    base: Set<RecipeBaseResult>;
-    variants: Set<AtomicStyleResult>;
-  };
-  getConfigSlotRecipeResult: (recipeName: string) => {
-    atomic: Set<AtomicStyleResult>;
-    base: Dict;
-    variants: Set<AtomicStyleResult>;
-  };
-  getRecipeResult: (recipeName: string) => {
-    atomic: Set<AtomicStyleResult>;
-    base: Set<RecipeBaseResult>;
-    variants: Set<AtomicStyleResult>;
-  } | {
-    atomic: Set<AtomicStyleResult>;
-    base: Dict;
-    variants: Set<AtomicStyleResult>;
-  };
-}
-//#endregion
-//#region src/rule-processor.d.ts
-declare class RuleProcessor {
-  private context;
-  encoder: StyleEncoder;
-  decoder: StyleDecoder;
-  sheet: Stylesheet$1;
-  constructor(context: Context);
-  getParamsOrThrow(): {
-    encoder: StyleEncoder;
-    decoder: StyleDecoder;
-    sheet: Stylesheet$1;
-  };
-  clone(): this;
-  toCss(options?: CssOptions$1): string;
-  css(styles: SystemStyleObject): AtomicRule;
-  grouped(styles: SystemStyleObject): GroupedRule;
-  cva(recipeConfig: RecipeDefinition<any>): AtomicRecipeRule;
-  sva(recipeConfig: SlotRecipeDefinition<string, any>): AtomicRecipeRule;
-  recipe(name: string, variants?: Record<string, any>): RecipeVariantsRule | undefined;
-}
-//#endregion
-//#region src/hooks-api.d.ts
-declare class HooksApi {
-  private ctx;
-  processor: RuleProcessor;
-  constructor(ctx: Context);
-  get config(): import("@bamboocss/types").UserConfig;
-  get configPath(): string;
-  get configDependencies(): string[];
-  get classNames(): Map<string, string>;
-  get generatedClassNames(): Map<string, import("@bamboocss/types").AtomicStyleResult | import("@bamboocss/types").RecipeBaseResult | import("@bamboocss/types").GroupedResult>;
-}
-//#endregion
-//#region src/file-matcher.d.ts
-interface ImportResult {
-  /** @example 'hstack' */
-  name: string;
-  /** @example 'bambooHStack' */
-  alias: string;
-  /**
-   * @example '../../styled-system/patterns'
-   * @example '@styles/patterns'
-   */
-  mod: string;
-  importMapValue?: string;
-  kind?: 'named' | 'namespace';
-}
-interface FileMatcherOptions {
-  importMap: ImportMapOutput<string>;
-  value: ImportResult[];
-}
-declare class FileMatcher {
-  private context;
-  imports: ImportResult[];
-  namespaces: Map<string, ImportResult>;
-  private importMap;
-  private cssAliases;
-  private cvaAliases;
-  private svaAliases;
-  private tokenAliases;
-  private jsxFactoryAliases;
-  private recipeAliases;
-  private patternAliases;
-  private propertiesMap;
-  private functions;
-  private components;
-  constructor(context: Pick<Context, 'jsx' | 'patterns' | 'recipes' | 'isValidProperty'>, opts: FileMatcherOptions);
-  private assignAliases;
-  private assignProperties;
-  isEmpty: () => boolean;
-  toString: () => string;
-  find: (id: string) => ImportResult | undefined;
-  private createMatch;
-  match: (id: string) => boolean;
-  getName: (id: string) => string;
-  getAliases: (id: string) => string[];
-  private _patternsMatcher;
-  isValidPattern: (id: string) => boolean;
-  private _recipesMatcher;
-  isValidRecipe: (id: string) => boolean;
-  isRawFn: (fnName: string) => boolean;
-  isNamespaced: (fnName: string) => boolean;
-  normalizeFnName: (fnName: string) => string;
-  isAliasFnName: (fnName: string) => boolean | undefined;
-  isTokenAlias: (fnName: string) => boolean;
-  matchFn: (fnName: string) => boolean;
-  isJsxFactory: (tagName: string) => boolean | undefined;
-  isBambooComponent: (tagName: string) => boolean;
-  matchTag: (tagName: string) => boolean;
-  matchTagProp: (tagName: string, propName: string) => boolean;
-}
-//#endregion
-//#region src/import-map.d.ts
-interface ImportMatcher {
-  mods: string[];
-  regex: RegExp;
-  match(value: string): boolean;
-}
-declare class ImportMap {
-  private context;
-  value: ImportMapOutput<string>;
-  matchers: Record<keyof ImportMapOutput, ImportMatcher>;
-  outdir: string;
-  constructor(context: Pick<Context, 'jsx' | 'config' | 'conf' | 'isValidProperty' | 'recipes' | 'patterns'>);
-  /**
-   * Normalize one/many import map inputs to a single import map output with absolute paths.
-   * @example
-   * ```ts
-   * importMap: '@acme/org'
-   * ```
-   *
-   * will be normalized to
-   * ```ts
-   * {
-   *   css: ['@acme/org/css'],
-   *   recipe: ['@acme/org/recipes'],
-   *   pattern: ['@acme/org/patterns'],
-   *   jsx: ['@acme/org/jsx'],
-   *   tokens: ['@acme/org/tokens'],
-   * }
-   * ```
-   *
-   * @exammple
-   * importMap: ['@acme/org', '@foo/org', '@bar/org']
-   * ```
-   *
-   * will be normalized to
-   * ```ts
-   * {
-   *   css: ['@acme/org/css', '@foo/org/css', '@bar/org/css'],
-   *   recipe: ['@acme/org/recipes', '@foo/org/recipes', '@bar/org/recipes'],
-   *   pattern: ['@acme/org/patterns', '@foo/org/patterns', '@bar/org/patterns'],
-   *   jsx: ['@acme/org/jsx', '@foo/org/jsx', '@bar/org/jsx'],
-   *   tokens: ['@acme/org/tokens', '@foo/org/tokens', '@bar/org/tokens'],
-   * }
-   * ```
-   */
-  buildImportMap: (option: UserConfig["importMap"]) => ImportMapOutput<string>;
-  private fromString;
-  private fromInput;
-  private getOutdir;
-  normalize: (map: string | ImportMapInput | undefined) => ImportMapOutput;
-  private createMatcher;
-  match: (result: ImportResult | undefined, resolveTsPath?: (mod: string) => string | undefined) => boolean;
-  file: (results: ImportResult[]) => FileMatcher;
-}
-//#endregion
-//#region src/layers.d.ts
-declare class Layers {
-  private names;
-  root: Root;
-  reset: AtRule;
-  base: AtRule;
-  tokens: AtRule;
-  recipes: AtRule;
-  recipes_base: AtRule;
-  recipes_slots: AtRule;
-  recipes_slots_base: AtRule;
-  utilities: AtRule;
-  compositions: AtRule;
-  private utilityRuleMap;
-  constructor(names: CascadeLayers);
-  getLayerRoot(layer: CascadeLayer): postcss.AtRule | postcss.Root;
-  insert(): postcss.Root;
-  get layerNames(): string[];
-  get params(): string;
-}
-//#endregion
-//#region src/serialize.d.ts
-interface SerializeContext extends Omit<StylesheetContext, 'layers' | 'helpers' | 'hash' | 'cssVarRoot'> {}
-//#endregion
-//#region src/recipes.d.ts
-interface RecipeRecord {
-  [key: string]: RecipeConfig | SlotRecipeConfig;
-}
-declare class Recipes {
-  private recipes;
-  slotSeparator: string;
-  keys: string[];
-  private deprecated;
-  private context;
-  get config(): RecipeRecord;
-  constructor(recipes?: RecipeRecord);
-  private getPropKey;
-  private get separator();
-  private getClassName;
-  prune: () => void;
-  save: (context: SerializeContext) => void;
-  saveOne: (name: string, recipe: RecipeConfig | SlotRecipeConfig) => void;
-  remove(name: string): void;
-  inferJsxSlots: (name: string, recipe: RecipeConfig | SlotRecipeConfig) => (string | RegExp)[];
-  private assignRecipe;
-  getSlotKey: (name: string, slot: string) => string;
-  isEmpty: () => boolean;
-  isDeprecated: (name: string) => boolean;
-  getNames: (name: string) => {
-    baseName: string;
-    upperName: string;
-    dashName: string;
-    jsxName: string;
-  };
-  getRecipe: (name: string) => RecipeNode | undefined;
-  getConfig: (name: string) => RecipeConfig<import("@bamboocss/types").RecipeVariantRecord> | SlotRecipeConfig;
-  getConfigOrThrow: (name: string) => RecipeConfig<import("@bamboocss/types").RecipeVariantRecord> | SlotRecipeConfig;
-  find: (jsxName: string) => RecipeNode | undefined;
-  filter: (jsxName: string) => RecipeNode[];
-  get details(): RecipeNode[];
-  splitProps: (recipeName: string, props: Dict) => Dict[];
-  isSlotRecipe: (name: string) => boolean;
-  static isSlotRecipeConfig: (config: RecipeConfig | SlotRecipeConfig) => config is SlotRecipeConfig;
-  normalize: (name: string, config: RecipeConfig) => Required<RecipeConfig<import("@bamboocss/types").RecipeVariantRecord>>;
-  getTransform: (name: string, slot?: boolean) => (variant: string, value: string) => {
-    layer: string;
-    className: string;
-    styles: SystemStyleObject;
-  } | {
-    className: string;
-    styles: SystemStyleObject;
-    layer?: undefined;
-  };
-  filterDetails: (filters?: ArtifactFilters) => RecipeNode[];
-  static inferSlots: (recipe: PartialBy<SlotRecipeDefinition, "slots">) => string[];
-  static isValidNode: (node: unknown) => node is RecipeNode;
-}
-//#endregion
-//#region src/types.d.ts
-interface TransformResult {
-  layer?: string;
-  className: string;
-  styles: Dict;
-}
-interface StylesheetContext extends Pick<Context, 'utility' | 'conditions' | 'encoder' | 'decoder' | 'isValidProperty' | 'hooks' | 'globalVars' | 'globalFontface' | 'globalPositionTry'> {
-  layers: Layers;
-  helpers: PatternHelpers;
-  hash?: boolean;
-  browserslist?: string[];
-  polyfill?: boolean;
-  cssVarRoot: string;
-}
-interface RecipeNode {
-  /**
-   * The name of the recipe
-   */
-  baseName: string;
-  /**
-   * The class name of the recipe. Defaults to the baseName if not specified.
-   */
-  className: string;
-  /**
-   * Discriminant
-   */
-  type: 'recipe';
-  /**
-   * The keys of the variants
-   */
-  variantKeys: string[];
-  /**
-   * The map of the variant keys to their possible values
-   */
-  variantKeyMap: Record<string, string[]>;
-  /**
-   * The jsx keys or regex to match the recipe
-   */
-  jsx: (string | RegExp)[];
-  /**
-   * The name of the recipe in upper case
-   */
-  upperName: string;
-  /**
-   * The name of the recipe in dash case
-   */
-  dashName: string;
-  /**
-   * The name of the recipe in camel case
-   */
-  jsxName: string;
-  /**
-   * The regex to match the recipe
-   */
-  match: RegExp;
-  /**
-   * The transformed recipe config
-   */
-  config: RecipeConfig | SlotRecipeConfig;
-  /**
-   * The function to split the props
-   */
-  splitProps: (props: Dict) => [Dict, Dict];
-  /**
-   * The props of the recipe
-   */
-  props: string[];
-}
-interface CssOptions extends Pick<UserConfig, 'minify'> {}
-interface ProcessOptions {
-  styles: Dict;
-  layer: LayerName;
-}
-type LayerName = 'base' | 'reset' | 'recipes_slots_base' | 'recipes_base' | 'tokens' | 'recipes' | 'utilities' | 'recipes_slots' | 'compositions';
-interface ParserOptions {
-  hash: HashOptions;
-  imports: ImportMap;
-  jsx: JsxEngine;
-  config: Config;
-  recipes: Recipes;
-  tokens: TokenDictionary;
-  patterns: Patterns;
-  utility: Utility;
-  conditions: Conditions;
-  encoder: StyleEncoder;
-  join: (...paths: string[]) => string;
-  compilerOptions: TSConfig['compilerOptions'];
-  tsOptions: LoadConfigResult['tsOptions'];
-}
-//#endregion
-//#region src/utility.d.ts
-interface UtilityOptions {
-  config?: UtilityConfig;
-  tokens: TokenDictionary;
-  separator?: string;
-  prefix?: string;
-  shorthands?: boolean;
-  strictTokens?: boolean;
-  keyframes?: CssKeyframes;
-}
-declare class Utility {
-  private options;
-  /**
-   * The token map or dictionary of tokens
-   */
-  tokens: TokenDictionary;
-  /**
-   * [cache] The map of property names to their resolved class names
-   */
-  classNames: Map<string, string>;
-  /**
-   * [cache] The map of the property to their resolved styless
-   */
-  styles: Map<string, Dict>;
-  /**
-   * Map of shorthand properties to their longhand properties
-   */
-  shorthands: Map<string, string>;
-  /**
-   * The map of possible values for each property
-   */
-  types: Map<string, Set<string>>;
-  /**
-   * The map of the property keys
-   */
-  propertyTypeKeys: Map<string, Set<string>>;
-  /**
-   * The utility config
-   */
-  config: UtilityConfig;
-  /**
-   * The map of property names to their transform functions
-   */
-  private transforms;
-  /**
-   * The map of property names to their config
-   */
-  private configs;
-  /**
-   * The map of deprecated properties
-   */
-  private deprecated;
-  separator: string;
-  prefix: string;
-  strictTokens: boolean;
-  constructor(options: UtilityOptions);
-  defaultHashFn: typeof toHash;
-  toHash: (path: string[], hashFn: (str: string) => string) => string;
-  private normalizeConfig;
-  private assignDeprecated;
-  register: (property: string, config: PropertyConfig) => void;
-  private assignShorthands;
-  private assignColorPaletteProperty;
-  resolveShorthand: (prop: string) => string;
-  get hasShorthand(): boolean;
-  get isEmpty(): boolean;
-  entries: () => [string, string][];
-  private getPropKey;
-  private hash;
-  /**
-   * Get all the possible values for the defined property
-   */
-  getPropertyValues: (config: PropertyConfig, resolveFn?: (key: string) => string) => {
-    type: string;
-  } | Record<string, string> | {
-    [x: string]: Record<string, string>;
-  } | undefined;
-  getPropertyRawValue(config: PropertyConfig, value: string): string;
-  getToken: (path: string) => string;
-  getTokenCategoryValues: (category: string) => Record<string, string> | undefined;
-  /**
-   * Normalize the property config
-   */
-  normalize: (propertyConfig: PropertyConfig | undefined) => PropertyConfig | undefined;
-  private assignProperty;
-  private assignProperties;
-  assignPropertiesValues: () => this;
-  private assignPropertyValues;
-  getPropertyKeys: (prop: string) => string[];
-  getPropertyTypeKeys: (property: string) => string[];
-  private assignPropertyType;
-  private assignPropertyTypes;
-  addPropertyType: (property: string, type: string[]) => void;
-  /**
-   * Returns the Typescript type for the define properties
-   */
-  getTypes: () => Map<string, string[]>;
-  defaultTransform: (value: string, prop: string) => {
-    [x: string]: string;
-  };
-  private setTransform;
-  private getTokenFn;
-  resolveColorMix: (value: string) => {
-    invalid: boolean;
-    value: string;
-    color?: undefined;
-  } | {
-    invalid: boolean;
-    color: string;
-    value: string;
-  };
-  private getTransformArgs;
-  private setStyles;
-  formatClassName: (className: string) => string;
-  /**
-   * Returns the resolved className for a given property and value
-   */
-  getClassName: (property: string, raw: string) => string;
-  getOrCreateClassName: (property: string, raw: string) => string;
-  /**
-   * Whether a given property exists in the config
-   */
-  has: (prop: string) => boolean;
-  /**
-   * Get or create the resolved styles for a given property and value
-   */
-  private getOrCreateStyle;
-  /**
-   * Returns the resolved className and styles for a given property and value
-   */
-  transform: (prop: string, value: string | undefined) => TransformResult;
-  /**
-   * All keys including shorthand keys
-   */
-  keys: () => string[];
-  /**
-   * Returns a map of the property keys and their shorthands
-   */
-  getPropShorthandsMap: () => Map<string, string[]>;
-  /**
-   * Returns the shorthands for a given property
-   */
-  getPropShorthands: (prop: string) => string[];
-  /**
-   * Whether a given property is deprecated
-   */
-  isDeprecated: (prop: string) => boolean;
-  /**
-   * Returns the token type for a given property
-   */
-  getTokenType: (prop: string) => string | undefined;
-}
-//#endregion
-//#region src/patterns.d.ts
-interface PatternOptions {
-  config: UserConfig;
-  tokens: TokenDictionary;
-  utility: Utility;
-  helpers: PatternHelpers;
-}
-declare class Patterns {
-  private options;
-  patterns: Record<string, PatternConfig>;
-  details: PatternNode[];
-  keys: string[];
-  private utility;
-  private tokens;
-  private deprecated;
-  constructor(options: PatternOptions);
-  private createDetail;
-  getConfig(name: string): PatternConfig;
-  transform(name: string, styles: Dict): Dict;
-  getNames(name: string): PatternNames;
-  find: (jsxName: string) => string;
-  filter: (jsxName: string) => PatternNode[];
-  isEmpty(): boolean;
-  isDeprecated(name: string): boolean;
-  saveOne(name: string, pattern: PatternConfig): void;
-  remove(name: string): void;
-  filterDetails(filters?: ArtifactFilters): PatternNode[];
-  getPropertyValues: (patternName: string, property: string) => string[] | undefined;
-  getPropertyType: (prop: PatternProperty) => string;
-  static isValidNode: (node: unknown) => node is PatternNode;
-}
-interface PatternNames {
-  upperName: string;
-  baseName: string;
-  dashName: string;
-  styleFnName: string;
-  jsxName: string;
-}
-interface PatternNode extends PatternNames {
-  props: string[];
-  blocklistType: string;
-  config: PatternConfig;
-  type: 'pattern';
-  match: RegExp;
-  jsx: NonNullable<PatternConfig['jsx']>;
-}
-//#endregion
-//#region src/jsx.d.ts
-interface JsxMatcher {
-  string: Set<string>;
-  regex: RegExp[];
-}
-declare class JsxEngine {
-  private context;
-  nodes: Array<PatternNode | RecipeNode>;
-  names: string[];
-  recipeMatcher: JsxMatcher;
-  recipePropertiesByJsxName: Map<string, Set<string>>;
-  patternMatcher: JsxMatcher;
-  patternPropertiesByJsxName: Map<string, Set<string>>;
-  constructor(context: Pick<Context, 'patterns' | 'recipes' | 'config'>);
-  assignRecipeMatcher(): void;
-  assignPatternMatcher(): void;
-  private get jsxFactory();
-  get styleProps(): "all" | "minimal" | "none";
-  get framework(): (string & {}) | import("@bamboocss/types").JsxFramework | undefined;
-  get isEnabled(): boolean;
-  get factoryName(): string;
-  get upperName(): string;
-  get typeName(): string;
-  get variantName(): string;
-  get componentName(): string;
-  isJsxFactory: (name: string) => boolean;
-  isJsxTagRecipe: (tagName: string) => boolean;
-  isJsxTagPattern: (tagName: string) => boolean;
-  isRecipeOrPatternProp: (tagName: string, propName: string) => boolean;
-}
-//#endregion
-//#region src/path.d.ts
-declare class PathEngine {
-  private context;
-  constructor(context: Pick<Context, 'config'>);
-  private get cwd();
-  private get outdir();
-  getFilePath(file?: string): string[];
-  get root(): string[];
-  get css(): string[];
-  get token(): string[];
-  get types(): string[];
-  get recipe(): string[];
-  get pattern(): string[];
-  get outCss(): string[];
-  get jsx(): string[];
-  get themes(): string[];
-  get specs(): string[];
-}
-//#endregion
-//#region src/static-css.d.ts
-interface StaticCssResults {
-  css: Record<string, any>[];
-  recipes: Record<string, any>[];
-  patterns: Record<string, any>[];
-}
-type StaticCssContext = Pick<Context, 'encoder' | 'decoder' | 'utility' | 'patterns' | 'recipes' | 'createSheet' | 'config'>;
-interface StaticCssEngine {
-  results: StaticCssResults;
-  sheet: Stylesheet$1;
-}
-declare class StaticCss {
-  private context;
-  encoder: StyleEncoder;
-  decoder: StyleDecoder;
-  private breakpointKeys;
-  private conditionKeys;
-  private wildcardCache;
-  constructor(context: StaticCssContext);
-  clone(): this;
-  private formatCondition;
-  private getConditionalValues;
-  private createRegex;
-  parse: (text: string) => string[];
-  /**
-   * Get property keys with memoization for wildcard expansion
-   * This is the main performance optimization - avoids redundant token lookups
-   */
-  private getCachedPropertyKeys;
-  /**
-   * Get pattern property values with memoization
-   */
-  private getCachedPatternPropertyValues;
-  private getCssObjects;
-  getCssRuleObjects: (rule: CssRule) => {
-    [x: string]: string | number | {
-      base: any;
-    };
-  }[];
-  private getPatternObjects;
-  getPatternRuleObjects: (name: string, pattern: PatternRule) => Dict[];
-  private getRecipeNode;
-  getRecipeRuleObjects: (name: string, recipe: RecipeRule, recipeNode: RecipeNode$1) => Dict[];
-  getRecipeCompoundVariantCssObjects: (recipeNode: RecipeNode$1) => Dict[];
-  /**
-   * This transforms a static css config into the same format as in the ParserResult,
-   * so that it can be processed by the same logic as styles found in app code.
-   *
-   * e.g.
-   * @example { css: [{ color: ['red', 'blue'] }] } => { css: [{ color: 'red }, { color: 'blue }] }
-   * @example { css: [{ color: ['red'], conditions: ['md'] }] } => { css: [{ color: { base: 'red', md: 'red' } }] }
-   *
-   */
-  getStyleObjects(options: StaticCssOptions): StaticCssResults;
-  process: (options: StaticCssOptions, stylesheet?: Stylesheet$1) => StaticCssEngine;
-}
-//#endregion
-//#region src/stylesheet.d.ts
-declare class Stylesheet {
-  private context;
-  constructor(context: StylesheetContext);
-  get layers(): Layers;
-  getLayer(layer: LayerName): postcss.AtRule | undefined;
-  process(options: ProcessOptions): void;
-  serialize: (styles: Dict) => Dict;
-  processResetCss: (styles: Dict) => void;
-  processGlobalCss: (styles: Dict) => void;
-  processCss: (styles: SystemStyleObject | undefined, layer: LayerName) => void;
-  processDecoder: (decoder: StyleDecoder) => void;
-  /**
-   * Process only the styles for a specific recipe from the decoder
-   */
-  processDecoderForRecipe: (decoder: StyleDecoder, recipeName: string) => void;
-  getLayerCss: (...layers: CascadeLayer[]) => string;
-  toCss: ({
-    minify
-  }?: CssOptions) => string;
-}
-//#endregion
-//#region src/context.d.ts
-declare class Context {
-  conf: LoadConfigResult;
-  studio: RequiredBy<NonNullable<StudioOptions['studio']>, 'outdir'>;
-  tokens: TokenDictionary;
-  utility: Utility;
-  recipes: Recipes;
-  conditions: Conditions;
-  patterns: Patterns;
-  staticCss: StaticCss;
-  jsx: JsxEngine;
-  imports: ImportMap;
-  paths: PathEngine;
-  file: FileEngine;
-  globalVars: GlobalVars;
-  globalFontface: GlobalFontface$1;
-  globalPositionTry: GlobalPositionTry$1;
-  encoder: StyleEncoder;
-  decoder: StyleDecoder;
-  hooksApi: HooksApi;
-  properties: Set<string>;
-  isValidProperty: (key: string) => boolean;
-  messages: Messages;
-  parserOptions: ParserOptions;
-  constructor(conf: LoadConfigResult);
-  get config(): UserConfig;
-  get hooks(): Partial<BambooHooks>;
-  get isTemplateLiteralSyntax(): boolean;
-  get hash(): HashOptions;
-  get prefix(): PrefixOptions;
-  createTokenDictionary: (theme: Theme, themeVariants?: ThemeVariantsMap) => TokenDictionary;
-  createUtility: (config: UserConfig) => Utility;
-  createConditions: (config: UserConfig) => Conditions;
-  createLayers: (layers: CascadeLayers) => Layers;
-  setupCompositions: (theme: Theme) => void;
-  private registerAnimationName;
-  private registerFontFamily;
-  setupProperties: () => void;
-  get baseSheetContext(): {
-    conditions: Conditions;
-    utility: Utility;
-    hash: boolean | undefined;
-    encoder: StyleEncoder;
-    decoder: StyleDecoder;
-    hooks: Partial<BambooHooks>;
-    isValidProperty: (key: string) => boolean;
-    browserslist: string[] | undefined;
-    polyfill: boolean | undefined;
-    cssVarRoot: string;
-    helpers: {
-      map: typeof import("@bamboocss/shared").mapObject;
-      isCssFunction: (v: unknown) => boolean;
-      isCssVar: (v: unknown) => boolean;
-      isCssUnit: (v: unknown) => boolean;
-    };
-    globalVars: GlobalVars;
-    globalFontface: GlobalFontface$1;
-    globalPositionTry: GlobalPositionTry$1;
-  };
-  createSheet: () => Stylesheet;
-  createRecipes: (theme: Theme) => Recipes;
-  isValidLayerParams: (params: string) => boolean;
-}
-declare namespace messages_d_exports {
-  export { Messages, artifactsGenerated, buildComplete, codegenComplete, configExists, configWatch, cssArtifactComplete, exclamation, getMessages, noExtract, thankYou, watch };
-}
-declare const artifactsGenerated: (ctx: Pick<Context, "config" | "recipes" | "patterns" | "tokens" | "jsx" | "isTemplateLiteralSyntax">) => () => string;
-declare const configExists: (cmd: string) => string;
-declare const thankYou: () => string;
-declare const codegenComplete: () => string;
-declare const noExtract: () => string;
-declare const watch: () => string;
-declare const configWatch: () => string;
-declare const buildComplete: (count: number) => string;
-declare const exclamation: () => string;
-declare const cssArtifactComplete: (type: string) => string;
-declare const getMessages: (ctx: Pick<Context, "config" | "recipes" | "patterns" | "tokens" | "jsx" | "isTemplateLiteralSyntax">) => {
-  artifactsGenerated: () => string;
-  configExists: (cmd: string) => string;
-  thankYou: () => string;
-  codegenComplete: () => string;
-  noExtract: () => string;
-  watch: () => string;
-  buildComplete: (count: number) => string;
-  configWatch: () => string;
-  cssArtifactComplete: (type: string) => string;
-  exclamation: () => string;
-};
-type Messages = ReturnType<typeof getMessages>;
-//#endregion
-//#region src/optimize.d.ts
-interface OptimizeOptions {
-  minify?: boolean;
-  browserslist?: string[];
-  hooks?: Partial<BambooHooks>;
-}
-declare function optimizeCss(code: string | Root, options?: OptimizeOptions): string;
-declare function expandNestedCss(code: string): string;
-//#endregion
-//#region src/selector.d.ts
-declare function extractParentSelectors(selector: string): string;
-declare function extractTrailingPseudos(selector: string): [string, string] | [null, string];
-//#endregion
-//#region src/stringify.d.ts
-/** Returns a string of CSS from an object of CSS. */
-declare function stringify(/** Style object defintion. */
-
-value: Dict): string;
-//#endregion
-export { Breakpoints, Conditions, Context, type CssOptions, FileMatcher, ImportMap, type ImportResult, JsxEngine, Layers, type ParserOptions, type PatternNode, Patterns, type RecipeNode, Recipes, RuleProcessor, StaticCss, StyleDecoder, StyleEncoder, Stylesheet, type StylesheetContext, type TransformResult, Utility, expandNestedCss, extractParentSelectors, extractTrailingPseudos, messages_d_exports as messages, optimizeCss, stringify };