import { W as WalkObjectStopFn, C as CreateCssContext, M as MappedObject } from './shared-DHsOF1Vt.js';
export { z as WalkObjectOptions, h as compact, f as createCss, g as createMergeCss, k as filterBaseConditions, s as getPatternStyles, v as getSlotCompoundVariant, u as getSlotRecipes, l as hypenateProperty, j as isBaseCondition, a as isBoolean, b as isFunction, m as isImportant, c as isObject, e as isObjectOrArray, i as isString, d as isSymbol, B as mapObject, o as markImportant, p as memo, q as mergeProps, r as patternFns, x as splitProps, t as toHash, y as uniq, A as walkObject, w as withoutImportant, n as withoutSpace } from './shared-DHsOF1Vt.js';
export { astish } from './astish.js';

declare const getArbitraryValue: (_value: string) => string;

declare function assign(target: any, ...sources: any[]): any;

declare class CacheMap<K, V> implements Map<K, V> {
    private cache;
    private keysInUse;
    private maxCacheSize;
    constructor(maxCacheSize?: number);
    get(key: K): V | undefined;
    set(key: K, value: V): this;
    delete(key: K): boolean;
    private updateKeyUsage;
    private evictLeastRecentlyUsed;
    clear(): void;
    has(key: K): boolean;
    get size(): number;
    forEach(callback: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
    keys(): MapIterator<K>;
    values(): MapIterator<V>;
    entries(): MapIterator<[K, V]>;
    getOrInsert(key: K, defaultValue: V): V;
    getOrInsertComputed(key: K, callback: (key: K) => V): V;
    [Symbol.iterator](): MapIterator<[K, V]>;
    [Symbol.toStringTag]: string;
    toJSON: () => Map<K, V>;
}

type Operand = string | number | {
    ref: string;
};
declare const calc: {
    negate(x: Operand): string;
};

declare const camelCaseProperty: (property: string) => string;

declare const capitalize: (s: string) => string;
declare const dashCase: (s: string) => string;
declare const uncapitalize: (s: string) => string;

interface CssVar {
    var: `--${string}`;
    ref: string;
}
interface CssVarOptions {
    fallback?: string;
    prefix?: string;
    hash?: boolean;
}
declare function cssVar(name: string, options?: CssVarOptions): CssVar;

type Dict = Record<string, any>;
declare const deepSet: <T extends Dict>(target: T, path: string[], value: Dict | string) => T;

declare function fromEntries<A extends symbol | string | number, B>(entries: [A, B][]): {
    [key in A]: B;
};
declare function entries<A extends symbol | string | number, B>(obj: {
    [key in A]: B;
}): [A, B][];
declare function mapEntries<A, B, K extends string | number | symbol>(obj: {
    [key in K]: A;
}, f: (key: K, val: A) => [K, B]): {
    [key in K]: B;
};

type PandaErrorCode = 'CONFIG_NOT_FOUND' | 'CONFIG_ERROR' | 'NOT_FOUND' | 'CONDITION' | 'MISSING_STUDIO' | 'INVALID_LAYER' | 'UNKNOWN_RECIPE' | 'INVALID_RECIPE' | 'UNKNOWN_TYPE' | 'UNKNOWN_ARTIFACT' | 'UNKNOWN_LITERAL_TYPE' | 'UNKNOWN_RESULT_TYPE' | 'MISSING_PARAMS' | 'NO_CONTEXT' | 'INVALID_TOKEN';
declare class PandaError extends Error {
    readonly code: string;
    readonly hint?: string;
    constructor(code: PandaErrorCode, message: string, opts?: {
        hint?: string;
        cause?: unknown;
    });
}

declare const esc: (sel: string) => string;

declare function flatten(values: Record<string, Record<string, any>>, stop?: WalkObjectStopFn): Record<string, any>;

declare function getOrCreateSet<TKey, TValue>(map: Map<TKey, Set<TValue>>, key: TKey): Set<TValue>;

declare const isCssFunction: (v: unknown) => boolean;

declare const isCssUnit: (v: unknown) => boolean;

declare const isCssVar: (v: unknown) => boolean;

/**
 * Credits: https://github.com/mesqueeb/merge-anything
 */
declare function mergeAndConcat<T, const Tn extends unknown[]>(object: T, ...otherObjects: Tn): any;

declare function mergeWith(target: any, ...sources: any[]): any;

type NormalizeContext = Pick<CreateCssContext, 'utility' | 'conditions'>;
declare function toResponsiveObject(values: string[], breakpoints: string[]): Record<string, string>;
declare function normalizeStyleObject(styles: Record<string, any>, context: NormalizeContext, shorthand?: boolean): MappedObject<Record<string, any>, any>;

declare const omit: <T, K extends keyof T | (string & {})>(obj: T, paths: K[]) => Omit<T, K>;

declare const PANDA_CONFIG_NAME: "__panda.config__";

declare const pick: <T, K extends keyof T | (string & {})>(obj: T, paths: K[]) => Partial<T>;

declare function getPropertyPriority(key: string): number;

declare const createRegex: (item: Array<string | RegExp>) => RegExp;

declare const stringifyJson: (config: Record<string, any>) => string;
declare const parseJson: (config: string) => any;

declare function splitBy(value: string, separator?: string): any[];
declare function splitDotPath(path: string): string[];
declare function getNegativePath(path: string[]): string[];
declare function getDotPath(obj: any, path: string, fallback?: any): any;

type MapToRecord<K extends Map<string, any>> = {
    [P in keyof K]: K[P] extends Map<string, infer V> ? Record<string, V> : never;
};
declare function mapToJson<T extends Map<string, any>>(map: T): MapToRecord<T>;

type CallbackFn = (args: CallbackItem) => void;
interface CallbackItem {
    value: any;
    path: string;
    paths: string[];
    depth: number;
    parent: any[] | Record<string, unknown>;
    key: string;
}
interface TraverseOptions {
    separator?: string;
    maxDepth?: number;
    stop?: (args: CallbackItem) => boolean;
}
declare function traverse(obj: any, callback: CallbackFn, options?: TraverseOptions): void;

declare function unionType(values: IterableIterator<string> | string[] | readonly string[] | Set<string>, opts?: {
    fallback?: string;
    stringify?: (value: string) => string;
}): string;

declare function getUnit(value?: string): string | undefined;
declare function toPx(value?: string | number): string | undefined;
declare function toEm(value?: string, fontSize?: number): string | undefined;
declare function toRem(value?: string): string | undefined;

export { CacheMap, CreateCssContext, type CssVar, type CssVarOptions, type MapToRecord, MappedObject, PANDA_CONFIG_NAME, PandaError, type PandaErrorCode, WalkObjectStopFn, assign, calc, camelCaseProperty, capitalize, createRegex, cssVar, dashCase, deepSet, entries, esc, flatten, fromEntries, getArbitraryValue, getDotPath, getNegativePath, getOrCreateSet, getPropertyPriority, getUnit, isCssFunction, isCssUnit, isCssVar, mapEntries, mapToJson, mergeAndConcat, mergeWith, normalizeStyleObject, omit, parseJson, pick, splitBy, splitDotPath, stringifyJson, toEm, toPx, toRem, toResponsiveObject, traverse, uncapitalize, unionType };