@pikacss/core 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -224,10 +224,10 @@ function execSyncHook(plugins, hook, payload) {
   return payload;
 }
 const hooks = {
-  config: (plugins, config) => execAsyncHook(plugins, "config", config),
-  beforeConfigResolving: (plugins, config) => execSyncHook(plugins, "beforeConfigResolving", config),
-  configResolved: (plugins, resolvedConfig) => execAsyncHook(plugins, "configResolved", resolvedConfig),
-  engineInitialized: (plugins, engine) => execSyncHook(plugins, "engineInitialized", engine),
+  configureRawConfig: (plugins, config) => execAsyncHook(plugins, "configureRawConfig", config),
+  rawConfigConfigured: (plugins, config) => execSyncHook(plugins, "rawConfigConfigured", config),
+  configureResolvedConfig: (plugins, resolvedConfig) => execAsyncHook(plugins, "configureResolvedConfig", resolvedConfig),
+  configureEngine: (plugins, engine) => execAsyncHook(plugins, "configureEngine", engine),
   transformSelectors: (plugins, selectors) => execAsyncHook(plugins, "transformSelectors", selectors),
   transformStyleItems: (plugins, styleItems) => execAsyncHook(plugins, "transformStyleItems", styleItems),
   transformStyleDefinitions: (plugins, styleDefinitions) => execAsyncHook(plugins, "transformStyleDefinitions", styleDefinitions),
@@ -243,26 +243,26 @@ const orderMap = /* @__PURE__ */ new Map([
 function resolvePlugins(plugins) {
   return plugins.sort((a, b) => orderMap.get(a.order) - orderMap.get(b.order));
 }
-function defineEnginePlugin$1(plugin) {
+function defineEnginePlugin(plugin) {
   return plugin;
 }
 
 function important() {
-  let _default;
-  return defineEnginePlugin$1({
+  let defaultValue;
+  return defineEnginePlugin({
     name: "core:important",
-    beforeConfigResolving(config) {
-      _default = config.important?.default ?? false;
+    rawConfigConfigured(config) {
+      defaultValue = config.important?.default ?? false;
     },
-    configResolved(resolvedConfig) {
-      appendAutocompleteExtraProperties(resolvedConfig, "__important");
-      appendAutocompletePropertyValues(resolvedConfig, "__important", "boolean");
+    configureEngine(engine) {
+      engine.appendAutocompleteExtraProperties("__important");
+      engine.appendAutocompletePropertyValues("__important", "boolean");
     },
     transformStyleDefinitions(styleDefinitions) {
       return styleDefinitions.map((styleDefinition) => {
         const { __important, ...rest } = styleDefinition;
-        const theImportant = __important;
-        const important2 = theImportant == null ? _default : theImportant;
+        const value = __important;
+        const important2 = value == null ? defaultValue : value;
         if (important2 === false)
           return rest;
         return Object.fromEntries(
@@ -278,47 +278,43 @@ function important() {
   });
 }
 
-function resolveKeyframesConfig(config) {
-  if (typeof config === "string")
-    return { name: config, frames: null, autocomplete: [] };
-  if (Array.isArray(config)) {
-    const [name2, frames2, autocomplete2 = []] = config;
-    return { name: name2, frames: frames2, autocomplete: autocomplete2 };
-  }
-  const { name, frames, autocomplete = [] } = config;
-  return { name, frames, autocomplete };
-}
 function keyframes() {
-  const allKeyframes = /* @__PURE__ */ new Map();
+  let resolveKeyframesConfig;
   let configList;
-  return defineEnginePlugin$1({
+  return defineEnginePlugin({
     name: "core:keyframes",
-    beforeConfigResolving(config) {
-      configList = config.keyframes ?? [];
+    rawConfigConfigured(config) {
+      resolveKeyframesConfig = createResolveConfigFn$1({
+        pruneUnused: config.keyframes?.pruneUnused
+      });
+      configList = config.keyframes?.keyframes ?? [];
     },
-    configResolved(resolvedConfig) {
-      const autocomplete = {
-        animationName: [],
-        animation: []
-      };
-      configList.forEach((config) => {
-        const { name, frames, autocomplete: autocompleteAnimation } = resolveKeyframesConfig(config);
-        if (frames != null) {
-          allKeyframes.set(name, frames);
+    configureEngine(engine) {
+      engine.keyframes = {
+        store: /* @__PURE__ */ new Map(),
+        add: (...list) => {
+          list.forEach((config) => {
+            const resolved = resolveKeyframesConfig(config);
+            const { name, frames, autocomplete: autocompleteAnimation } = resolved;
+            if (frames != null)
+              engine.keyframes.store.set(name, resolved);
+            engine.appendAutocompleteCssPropertyValues("animationName", name);
+            engine.appendAutocompleteCssPropertyValues("animation", `${name} `);
+            if (autocompleteAnimation != null)
+              engine.appendAutocompleteCssPropertyValues("animation", ...autocompleteAnimation);
+          });
+          engine.notifyPreflightUpdated();
         }
-        autocomplete.animationName.push(name);
-        autocomplete.animation.push(`${name} `);
-        if (autocompleteAnimation != null)
-          autocomplete.animation.push(...autocompleteAnimation);
-      });
-      appendAutocompleteCssPropertyValues(resolvedConfig, "animationName", ...autocomplete.animationName);
-      appendAutocompleteCssPropertyValues(resolvedConfig, "animation", ...autocomplete.animation);
-      resolvedConfig.preflights.push((engine, isFormatted) => {
+      };
+      engine.keyframes.add(...configList);
+      engine.addPreflight((engine2, isFormatted) => {
         const used = /* @__PURE__ */ new Set();
-        engine.store.atomicStyles.forEach(({ content: { property, value } }) => {
+        engine2.store.atomicStyles.forEach(({ content: { property, value } }) => {
           if (property === "animationName") {
             value.forEach((name) => used.add(name));
-          } else if (property === "animation") {
+            return;
+          }
+          if (property === "animation") {
             value.forEach((value2) => {
               const animations = value2.split(",").map((v) => v.trim());
               animations.forEach((animation) => {
@@ -330,7 +326,7 @@ function keyframes() {
           }
         });
         return renderCSSStyleBlocks(
-          new Map(Array.from(allKeyframes.entries()).filter(([name]) => used.has(name)).map(([name, frames]) => [
+          new Map(Array.from(engine2.keyframes.store.entries()).filter(([name]) => used.has(name)).map(([name, frames]) => [
             `@keyframes ${name}`,
             {
               properties: [],
@@ -352,6 +348,20 @@ function keyframes() {
     }
   });
 }
+function createResolveConfigFn$1({
+  pruneUnused: defaultPruneUnused = true
+} = {}) {
+  return function resolveKeyframesConfig(config) {
+    if (typeof config === "string")
+      return { name: config, frames: null, autocomplete: [], pruneUnused: defaultPruneUnused };
+    if (Array.isArray(config)) {
+      const [name2, frames2, autocomplete2 = [], pruneUnused2 = defaultPruneUnused] = config;
+      return { name: name2, frames: frames2, autocomplete: autocomplete2, pruneUnused: pruneUnused2 };
+    }
+    const { name, frames, autocomplete = [], pruneUnused = defaultPruneUnused } = config;
+    return { name, frames, autocomplete, pruneUnused };
+  };
+}
 
 class AbstractResolver {
   _resolvedResultsMap = /* @__PURE__ */ new Map();
@@ -428,6 +438,51 @@ class AbstractResolver {
   }
 }
 
+function selectors() {
+  let engine;
+  let configList;
+  return defineEnginePlugin({
+    name: "core:selectors",
+    rawConfigConfigured(config) {
+      configList = config.selectors?.selectors ?? [];
+    },
+    configureEngine(_engine) {
+      engine = _engine;
+      engine.selectors = {
+        resolver: new SelectorResolver(),
+        add: (...list) => {
+          list.forEach((config) => {
+            const resolved = resolveSelectorConfig(config);
+            if (resolved == null)
+              return;
+            if (typeof resolved === "string") {
+              engine.appendAutocompleteSelectors(resolved);
+              return;
+            }
+            if (resolved.type === "static")
+              engine.selectors.resolver.addStaticRule(resolved.rule);
+            else if (resolved.type === "dynamic")
+              engine.selectors.resolver.addDynamicRule(resolved.rule);
+            engine.appendAutocompleteSelectors(...resolved.autocomplete);
+          });
+        }
+      };
+      engine.selectors.add(...configList);
+      engine.selectors.resolver.onResolved = (string, type) => {
+        if (type === "dynamic") {
+          engine.appendAutocompleteSelectors(string);
+        }
+      };
+    },
+    async transformSelectors(selectors2) {
+      const result = [];
+      for (const selector of selectors2) {
+        result.push(...await engine.selectors.resolver.resolve(selector));
+      }
+      return result;
+    }
+  });
+}
 class SelectorResolver extends AbstractResolver {
   async resolve(selector) {
     const resolved = await this._resolve(selector).catch((error) => {
@@ -498,47 +553,76 @@ function resolveSelectorConfig(config) {
   }
   return void 0;
 }
-function selectors() {
-  const selectorResolver = new SelectorResolver();
+
+function shortcuts() {
+  let engine;
   let configList;
-  return defineEnginePlugin$1({
-    name: "core:selectors",
-    beforeConfigResolving(config) {
-      configList = config.selectors ?? [];
+  return defineEnginePlugin({
+    name: "core:shortcuts",
+    rawConfigConfigured(config) {
+      configList = config.shortcuts?.shortcuts ?? [];
     },
-    configResolved(resolvedConfig) {
-      configList.forEach((config) => {
-        const resolved = resolveSelectorConfig(config);
-        if (resolved == null)
-          return;
-        if (typeof resolved === "string") {
-          appendAutocompleteSelectors(resolvedConfig, resolved);
-          return;
+    configureEngine(_engine) {
+      engine = _engine;
+      engine.shortcuts = {
+        resolver: new ShortcutResolver(),
+        add: (...list) => {
+          list.forEach((config) => {
+            const resolved = resolveShortcutConfig(config);
+            if (resolved == null)
+              return;
+            if (typeof resolved === "string") {
+              engine.appendAutocompleteStyleItemStrings(resolved);
+              return;
+            }
+            if (resolved.type === "static")
+              engine.shortcuts.resolver.addStaticRule(resolved.rule);
+            else if (resolved.type === "dynamic")
+              engine.shortcuts.resolver.addDynamicRule(resolved.rule);
+            engine.appendAutocompleteStyleItemStrings(...resolved.autocomplete);
+          });
         }
-        if (resolved.type === "static")
-          selectorResolver.addStaticRule(resolved.rule);
-        else if (resolved.type === "dynamic")
-          selectorResolver.addDynamicRule(resolved.rule);
-        appendAutocompleteSelectors(resolvedConfig, ...resolved.autocomplete);
-      });
-    },
-    engineInitialized(engine) {
-      selectorResolver.onResolved = (string, type) => {
+      };
+      engine.shortcuts.add(...configList);
+      engine.shortcuts.resolver.onResolved = (string, type) => {
         if (type === "dynamic") {
-          engine.appendAutocompleteSelectors(string);
+          engine.appendAutocompleteStyleItemStrings(string);
         }
       };
+      engine.appendAutocompleteExtraProperties("__shortcut");
+      const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
+      engine.appendAutocompletePropertyValues("__shortcut", unionType, `(${unionType})[]`);
     },
-    async transformSelectors(selectors2) {
+    async transformStyleItems(styleItems) {
       const result = [];
-      for (const selector of selectors2) {
-        result.push(...await selectorResolver.resolve(selector));
+      for (const styleItem of styleItems) {
+        if (typeof styleItem === "string") {
+          result.push(...await engine.shortcuts.resolver.resolve(styleItem));
+          continue;
+        }
+        result.push(styleItem);
+      }
+      return result;
+    },
+    async transformStyleDefinitions(styleDefinitions) {
+      const result = [];
+      for (const styleDefinition of styleDefinitions) {
+        if ("__shortcut" in styleDefinition) {
+          const { __shortcut, ...rest } = styleDefinition;
+          const applied = [];
+          for (const shortcut of __shortcut == null ? [] : [__shortcut].flat(1)) {
+            const resolved = (await engine.shortcuts.resolver.resolve(shortcut)).filter(isNotString);
+            applied.push(...resolved);
+          }
+          result.push(...applied, rest);
+        } else {
+          result.push(styleDefinition);
+        }
       }
       return result;
     }
   });
 }
-
 class ShortcutResolver extends AbstractResolver {
   async resolve(shortcut) {
     const resolved = await this._resolve(shortcut).catch((error) => {
@@ -609,82 +693,70 @@ function resolveShortcutConfig(config) {
   }
   return void 0;
 }
-function shortcuts() {
-  const shortcutResolver = new ShortcutResolver();
+
+function variables() {
+  let resolveVariableConfig;
   let configList;
-  return defineEnginePlugin$1({
-    name: "core:shortcuts",
-    beforeConfigResolving(config) {
-      configList = config.shortcuts ?? [];
-    },
-    configResolved(resolvedConfig) {
-      const autocompleteShortcuts = /* @__PURE__ */ new Set();
-      configList.forEach((config) => {
-        const resolved = resolveShortcutConfig(config);
-        if (resolved == null)
-          return;
-        if (typeof resolved === "string") {
-          addToSet(autocompleteShortcuts, resolved);
-          return;
-        }
-        if (resolved.type === "static")
-          shortcutResolver.addStaticRule(resolved.rule);
-        else if (resolved.type === "dynamic")
-          shortcutResolver.addDynamicRule(resolved.rule);
-        addToSet(autocompleteShortcuts, ...resolved.autocomplete);
+  return defineEnginePlugin({
+    name: "core:variables",
+    rawConfigConfigured(config) {
+      resolveVariableConfig = createResolveConfigFn({
+        pruneUnused: config.variables?.pruneUnused
       });
-      appendAutocompleteStyleItemStrings(resolvedConfig, ...autocompleteShortcuts);
-      appendAutocompleteExtraProperties(resolvedConfig, "__shortcut");
-      const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
-      appendAutocompletePropertyValues(resolvedConfig, "__shortcut", unionType, `(${unionType})[]`);
+      configList = config.variables?.variables ?? [];
     },
-    engineInitialized(engine) {
-      shortcutResolver.onResolved = (string, type) => {
-        if (type === "dynamic") {
-          engine.appendAutocompleteStyleItemStrings(string);
+    configureEngine(engine) {
+      engine.variables = {
+        store: /* @__PURE__ */ new Map(),
+        add: (...list) => {
+          list.forEach((config) => {
+            const resolved = resolveVariableConfig(config);
+            const { name: _name, value, autocomplete: { asValueOf, asProperty } } = resolved;
+            const name = normalizeVariableName(_name);
+            asValueOf.forEach((p) => {
+              if (p !== "-")
+                engine.appendAutocompleteCssPropertyValues(p, `var(${name})`);
+            });
+            if (asProperty)
+              engine.appendAutocompleteExtraCssProperties(name);
+            if (value != null)
+              engine.variables.store.set(name, resolved);
+          });
+          engine.notifyPreflightUpdated();
         }
       };
-    },
-    async transformStyleItems(styleItems) {
-      const result = [];
-      for (const styleItem of styleItems) {
-        if (typeof styleItem === "string") {
-          result.push(...await shortcutResolver.resolve(styleItem));
-          continue;
-        }
-        result.push(styleItem);
-      }
-      return result;
-    },
-    async transformStyleDefinitions(styleDefinitions) {
-      const result = [];
-      for (const styleDefinition of styleDefinitions) {
-        if ("__shortcut" in styleDefinition) {
-          const { __shortcut, ...rest } = styleDefinition;
-          const applied = [];
-          for (const shortcut of __shortcut == null ? [] : [__shortcut].flat(1)) {
-            const resolved = (await shortcutResolver.resolve(shortcut)).filter(isNotString);
-            applied.push(...resolved);
-          }
-          result.push(...applied, rest);
-        } else {
-          result.push(styleDefinition);
-        }
-      }
-      return result;
+      engine.variables.add(...configList);
+      engine.addPreflight((engine2, isFormatted) => {
+        const used = /* @__PURE__ */ new Set();
+        engine2.store.atomicStyles.forEach(({ content: { value } }) => {
+          value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
+        });
+        return renderCSSStyleBlocks(
+          /* @__PURE__ */ new Map([[
+            ":root",
+            {
+              properties: Array.from(engine2.variables.store.entries()).filter(([name, { value }]) => used.has(name) && value != null).map(([name, { value }]) => ({ property: name, value }))
+            }
+          ]]),
+          isFormatted
+        );
+      });
     }
   });
 }
-
-function resolveVariableConfig(config) {
-  if (typeof config === "string")
-    return { name: config, value: null, autocomplete: { asValueOf: ["*"], asProperty: true } };
-  if (Array.isArray(config)) {
-    const [name2, value2, { asValueOf: asValueOf2 = "*", asProperty: asProperty2 = true } = {}] = config;
-    return { name: name2, value: value2, autocomplete: { asValueOf: [asValueOf2].flat(), asProperty: asProperty2 } };
-  }
-  const { name, value, autocomplete: { asValueOf = "*", asProperty = true } = {} } = config;
-  return { name, value, autocomplete: { asValueOf: [asValueOf].flat(), asProperty } };
+function createResolveConfigFn({
+  pruneUnused: defaultPruneUnused = true
+} = {}) {
+  return function resolveVariableConfig(config) {
+    if (typeof config === "string")
+      return { name: config, value: null, autocomplete: { asValueOf: ["*"], asProperty: true }, pruneUnused: defaultPruneUnused };
+    if (Array.isArray(config)) {
+      const [name2, value2, { asValueOf: asValueOf2 = "*", asProperty: asProperty2 = true } = {}, pruneUnused2 = defaultPruneUnused] = config;
+      return { name: name2, value: value2, autocomplete: { asValueOf: [asValueOf2].flat(), asProperty: asProperty2 }, pruneUnused: pruneUnused2 };
+    }
+    const { name, value, autocomplete: { asValueOf = "*", asProperty = true } = {}, pruneUnused = defaultPruneUnused } = config;
+    return { name, value, autocomplete: { asValueOf: [asValueOf].flat(), asProperty }, pruneUnused };
+  };
 }
 const VAR_NAME_RE = /var\((--[\w-]+)/g;
 function extractUsedVarNames(input) {
@@ -696,52 +768,15 @@ function extractUsedVarNames(input) {
     return varNameMatch ? varNameMatch[0] : "";
   }).filter(Boolean);
 }
-function normalizeVariableName(name, prefix) {
+function normalizeVariableName(name) {
   if (name.startsWith("--"))
     return name;
-  if (prefix)
-    return `--${prefix}-${name}`;
   return `--${name}`;
 }
-function variables() {
-  const allVariables = /* @__PURE__ */ new Map();
-  let prefix;
-  let configList;
-  return defineEnginePlugin$1({
-    name: "core:variables",
-    beforeConfigResolving(config) {
-      prefix = config.variablesPrefix;
-      configList = config.variables ?? [];
-    },
-    configResolved(resolvedConfig) {
-      configList.forEach((config) => {
-        const { name: _name, value, autocomplete: { asValueOf, asProperty } } = resolveVariableConfig(config);
-        const name = normalizeVariableName(_name, prefix);
-        asValueOf.forEach((p) => appendAutocompleteCssPropertyValues(resolvedConfig, p, `var(${name})`));
-        if (asProperty)
-          appendAutocompleteExtraCssProperties(resolvedConfig, name);
-        if (value != null)
-          allVariables.set(name, value);
-      });
-      resolvedConfig.preflights.push((engine, isFormatted) => {
-        const used = /* @__PURE__ */ new Set();
-        engine.store.atomicStyles.forEach(({ content: { value } }) => {
-          value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
-        });
-        return renderCSSStyleBlocks(
-          /* @__PURE__ */ new Map([[
-            ":root",
-            {
-              properties: Array.from(allVariables.entries()).filter(([name]) => used.has(name)).map(([name, value]) => ({ property: name, value }))
-            }
-          ]]),
-          isFormatted
-        );
-      });
-    }
-  });
-}
 
+function defineEngineConfig(config) {
+  return config;
+}
 async function createEngine(config = {}) {
   const corePlugins = [
     important(),
@@ -752,20 +787,25 @@ async function createEngine(config = {}) {
   ];
   const plugins = resolvePlugins([...corePlugins, ...config.plugins || []]);
   config.plugins = plugins;
-  config = await hooks.config(
+  config = await hooks.configureRawConfig(
     config.plugins,
     config
   );
-  hooks.beforeConfigResolving(
+  hooks.rawConfigConfigured(
     resolvePlugins(config.plugins || []),
     config
   );
   let resolvedConfig = await resolveEngineConfig(config);
-  resolvedConfig = await hooks.configResolved(
+  resolvedConfig = await hooks.configureResolvedConfig(
     resolvedConfig.plugins,
     resolvedConfig
   );
-  return new Engine(resolvedConfig);
+  let engine = new Engine(resolvedConfig);
+  engine = await hooks.configureEngine(
+    engine.config.plugins,
+    engine
+  );
+  return engine;
 }
 class Engine {
   config;
@@ -782,13 +822,12 @@ class Engine {
       transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
       transformStyleDefinitions: (styleDefinitions) => hooks.transformStyleDefinitions(this.config.plugins, styleDefinitions)
     });
-    hooks.engineInitialized(this.config.plugins, this);
   }
   notifyPreflightUpdated() {
     hooks.preflightUpdated(this.config.plugins);
   }
-  notifyAtomicStyleAdded() {
-    hooks.atomicStyleAdded(this.config.plugins);
+  notifyAtomicStyleAdded(atomicStyle) {
+    hooks.atomicStyleAdded(this.config.plugins, atomicStyle);
   }
   notifyAutocompleteConfigUpdated() {
     hooks.autocompleteConfigUpdated(this.config.plugins);
@@ -817,6 +856,10 @@ class Engine {
     appendAutocompleteCssPropertyValues(this.config, property, ...values);
     this.notifyAutocompleteConfigUpdated();
   }
+  addPreflight(preflight) {
+    this.config.preflights.push(resolvePreflight(preflight));
+    this.notifyPreflightUpdated();
+  }
   async use(...itemList) {
     const {
       unknown,
@@ -835,8 +878,9 @@ class Engine {
       });
       resolvedIds.push(id);
       if (!this.store.atomicStyles.has(id)) {
-        this.store.atomicStyles.set(id, { id, content });
-        this.notifyAtomicStyleAdded();
+        const atomicStyle = { id, content };
+        this.store.atomicStyles.set(id, atomicStyle);
+        this.notifyAtomicStyleAdded(atomicStyle);
       }
     });
     return [...unknown, ...resolvedIds];
@@ -855,13 +899,15 @@ class Engine {
     });
   }
 }
+function resolvePreflight(preflight) {
+  return typeof preflight === "function" ? preflight : () => preflight;
+}
 async function resolveEngineConfig(config) {
   const {
     prefix = "",
     defaultSelector = `.${ATOMIC_STYLE_ID_PLACEHOLDER}`,
     plugins = [],
-    preflights = [],
-    autocomplete = {}
+    preflights = []
   } = config;
   const resolvedConfig = {
     rawConfig: config,
@@ -878,14 +924,8 @@ async function resolveEngineConfig(config) {
       cssProperties: /* @__PURE__ */ new Map()
     }
   };
-  const resolvedPreflights = preflights.map((p) => typeof p === "function" ? p : () => p);
+  const resolvedPreflights = preflights.map(resolvePreflight);
   resolvedConfig.preflights.push(...resolvedPreflights);
-  appendAutocompleteSelectors(resolvedConfig, ...autocomplete.selectors || []);
-  appendAutocompleteStyleItemStrings(resolvedConfig, ...autocomplete.styleItemStrings || []);
-  appendAutocompleteExtraProperties(resolvedConfig, ...autocomplete.extraProperties || []);
-  appendAutocompleteExtraCssProperties(resolvedConfig, ...autocomplete.extraCssProperties || []);
-  autocomplete.properties?.forEach(([property, value]) => appendAutocompletePropertyValues(resolvedConfig, property, ...[value].flat()));
-  autocomplete.cssProperties?.forEach(([property, value]) => appendAutocompleteCssPropertyValues(resolvedConfig, property, ...[value].flat()));
   return resolvedConfig;
 }
 function getAtomicStyleId({
@@ -959,27 +999,12 @@ function renderAtomicStyles(payload) {
   return renderCSSStyleBlocks(blocks, isFormatted);
 }
 
-function createDefineEnginePluginFn() {
-  return function defineEnginePlugin2(plugin) {
-    return plugin;
-  };
-}
-const defineEnginePlugin = createDefineEnginePluginFn();
-function createDefineEngineConfigFn() {
-  return function defineEngineConfig2(config) {
-    return config;
-  };
-}
-const defineEngineConfig = createDefineEngineConfigFn();
-
 exports.appendAutocompleteCssPropertyValues = appendAutocompleteCssPropertyValues;
 exports.appendAutocompleteExtraCssProperties = appendAutocompleteExtraCssProperties;
 exports.appendAutocompleteExtraProperties = appendAutocompleteExtraProperties;
 exports.appendAutocompletePropertyValues = appendAutocompletePropertyValues;
 exports.appendAutocompleteSelectors = appendAutocompleteSelectors;
 exports.appendAutocompleteStyleItemStrings = appendAutocompleteStyleItemStrings;
-exports.createDefineEngineConfigFn = createDefineEngineConfigFn;
-exports.createDefineEnginePluginFn = createDefineEnginePluginFn;
 exports.createEngine = createEngine;
 exports.defineEngineConfig = defineEngineConfig;
 exports.defineEnginePlugin = defineEnginePlugin;