@pikacss/core 0.0.30 → 0.0.31

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.30",
+  "version": "0.0.31",
   "author": "DevilTea <ch19980814@gmail.com>",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
   },
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.mts",
   "files": [
     "dist"
   ],
@@ -43,8 +43,7 @@
     "csstype": "^3.1.3"
   },
   "scripts": {
-    "build": "unbuild",
-    "stub": "unbuild --stub",
+    "build": "tsdown",
     "typecheck": "pnpm typecheck:package && pnpm typecheck:test",
     "typecheck:package": "tsc --project ./tsconfig.package.json --noEmit",
     "typecheck:test": "tsc --project ./tsconfig.tests.json --noEmit",

package/dist/index.d.ts

@@ -1,539 +0,0 @@
-import * as _pikacss_core from '@pikacss/core';
-import * as CSS from 'csstype';
-
-interface ImportantConfig {
-    default?: boolean;
-}
-declare module '@pikacss/core' {
-    interface EngineConfig {
-        important?: ImportantConfig;
-    }
-}
-
-interface Progress {
-    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;
-};
-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;
-        };
-    }
-}
-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;
-}
-
-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 class SelectorResolver extends AbstractResolver<string[]> {
-    resolve(selector: string): Promise<string[]>;
-}
-
-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 class ShortcutResolver extends AbstractResolver<StyleItem$1[]> {
-    resolve(shortcut: string): Promise<StyleItem$1[]>;
-}
-
-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: 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;
-    };
-}
-
-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 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;
-
-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;
-    PropertiesValue: Record<string, unknown>;
-    CssPropertiesValue: Record<string, UnionString | UnionNumber>;
-}
-type DefineAutocomplete<A extends _Autocomplete> = A;
-type EmptyAutocomplete = DefineAutocomplete<{
-    Selector: never;
-    StyleItemString: never;
-    ExtraProperty: never;
-    ExtraCssProperty: never;
-    PropertiesValue: never;
-    CssPropertiesValue: never;
-}>;
-
-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];
-}>;
-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;
-
-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[];
-}
-type StyleItem$1 = string | StyleDefinition$1;
-interface ExtractedStyleContent {
-    selector: string[];
-    property: string;
-    value: string[] | Nullish;
-}
-interface StyleContent {
-    selector: string[];
-    property: string;
-    value: string[];
-}
-interface AtomicStyle {
-    id: string;
-    content: StyleContent;
-}
-interface CSSStyleBlockBody {
-    properties: {
-        property: string;
-        value: string;
-    }[];
-    children?: CSSStyleBlocks;
-}
-type CSSStyleBlocks = Map<string, CSSStyleBlockBody>;
-
-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;
-};
-type PreflightFn = (engine: Engine, isFormatted: boolean) => Awaitable<string | PreflightDefinition>;
-/**
- * PreflightConfig can be a string or a function that returns a string.
- *
- * 1. A string is a static preflight style.
- * 2. A function is a dynamic preflight style that can use the engine instance to generate styles.
- */
-type Preflight = string | PreflightDefinition | PreflightFn;
-
-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[];
-}
-interface ResolvedEngineConfig {
-    rawConfig: EngineConfig;
-    prefix: string;
-    defaultSelector: string;
-    plugins: EnginePlugin[];
-    preflights: PreflightFn[];
-    autocomplete: ResolvedAutocompleteConfig;
-}
-
-type ExtractFn = (styleDefinition: StyleDefinition$1) => Promise<ExtractedStyleContent[]>;
-
-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>;
-}
-
-declare function setWarnFn(fn: (...args: any[]) => void): void;
-declare function warn(...args: any[]): 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;
-
-interface 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 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 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 };