@pikacss/core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,931 @@
+'use strict';
+
+const ATOMIC_STYLE_NAME_PLACEHOLDER = "&&";
+const ATOMIC_STYLE_NAME_PLACEHOLDER_RE_GLOBAL = /&&/g;
+const TEMP_ATOMIC_STYLE_NAME_PLACEHOLDER = "@@";
+const TEMP_ATOMIC_STYLE_NAME_PLACEHOLDER_RE_GLOBAL = /@@/g;
+const DEFAULT_SELECTOR_PLACEHOLDER = "&";
+const DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL = /&/g;
+
+const chars = [..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"];
+const numOfChars = chars.length;
+function numberToChars(num) {
+  if (num < numOfChars)
+    return chars[num];
+  let result = "";
+  let n = num;
+  while (n >= 0) {
+    result += chars[n % numOfChars];
+    n = Math.floor(n / numOfChars) - 1;
+  }
+  return result;
+}
+const UPPER_CASE = /[A-Z]/g;
+function toKebab(str) {
+  return str.replace(UPPER_CASE, (c) => `-${c.toLowerCase()}`);
+}
+function isNotNullish(value) {
+  return value != null;
+}
+function isNotString(value) {
+  return typeof value !== "string";
+}
+function isPropertyValue(v) {
+  if (Array.isArray(v))
+    return v.length === 2 && isPropertyValue(v[0]) && Array.isArray(v[1]) && v[1].every(isPropertyValue);
+  if (v == null)
+    return true;
+  if (typeof v === "string" || typeof v === "number")
+    return true;
+  return false;
+}
+function serialize(value) {
+  return JSON.stringify(value);
+}
+function addToSet(set, ...values) {
+  values.forEach((value) => set.add(value));
+}
+function appendAutocompleteSelectors(config, ...selectors) {
+  addToSet(config.autocomplete.selectors, ...selectors);
+}
+function appendAutocompleteStyleItemStrings(config, ...styleItemStrings) {
+  addToSet(config.autocomplete.styleItemStrings, ...styleItemStrings);
+}
+function appendAutocompleteExtraProperties(config, ...properties) {
+  addToSet(config.autocomplete.extraProperties, ...properties);
+}
+function appendAutocompleteExtraCssProperties(config, ...properties) {
+  addToSet(config.autocomplete.extraCssProperties, ...properties);
+}
+function appendAutocompletePropertyValues(config, property, ...tsTypes) {
+  const current = config.autocomplete.properties.get(property) || [];
+  config.autocomplete.properties.set(property, [...current, ...tsTypes]);
+}
+function appendAutocompleteCssPropertyValues(config, property, ...values) {
+  const current = config.autocomplete.cssProperties.get(property) || [];
+  config.autocomplete.cssProperties.set(property, [...current, ...values]);
+}
+
+const RE_SPLIT = /\s*,\s*/;
+function normalizeSelectors({
+  selectors,
+  defaultSelector
+}) {
+  let normalized;
+  const lastSelector = selectors[selectors.length - 1];
+  if (selectors.length === 0) {
+    normalized = [DEFAULT_SELECTOR_PLACEHOLDER];
+  } else if (lastSelector.includes(ATOMIC_STYLE_NAME_PLACEHOLDER) || lastSelector.includes(DEFAULT_SELECTOR_PLACEHOLDER)) {
+    normalized = selectors;
+  } else {
+    normalized = [...selectors, DEFAULT_SELECTOR_PLACEHOLDER];
+  }
+  return normalized.map((s) => s.replace(ATOMIC_STYLE_NAME_PLACEHOLDER_RE_GLOBAL, TEMP_ATOMIC_STYLE_NAME_PLACEHOLDER).replace(DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL, defaultSelector).replace(TEMP_ATOMIC_STYLE_NAME_PLACEHOLDER_RE_GLOBAL, ATOMIC_STYLE_NAME_PLACEHOLDER).split(RE_SPLIT).join(","));
+}
+function normalizeValue(value) {
+  if (value == null)
+    return value;
+  return [...new Set([value].flat(2).map((v) => String(v).trim()))];
+}
+async function extract({
+  styleDefinition,
+  levels = [],
+  result = [],
+  defaultSelector,
+  transformSelectors,
+  transformStyleItems,
+  transformStyleDefinitions
+}) {
+  const selector = normalizeSelectors({
+    selectors: await transformSelectors(levels),
+    defaultSelector
+  });
+  for (const definition of await transformStyleDefinitions([styleDefinition])) {
+    for (const [k, v] of Object.entries(definition)) {
+      if (isPropertyValue(v)) {
+        const property = toKebab(k);
+        const value = normalizeValue(v);
+        result.push({
+          selector,
+          property,
+          value
+        });
+      } else if (Array.isArray(v)) {
+        for (const styleItem of await transformStyleItems(v)) {
+          if (typeof styleItem === "string")
+            continue;
+          await extract({
+            styleDefinition: styleItem,
+            levels: [...levels, k],
+            result,
+            transformSelectors,
+            transformStyleItems,
+            transformStyleDefinitions,
+            defaultSelector
+          });
+        }
+      } else {
+        await extract({
+          styleDefinition: v,
+          levels: [...levels, k],
+          result,
+          transformSelectors,
+          transformStyleItems,
+          transformStyleDefinitions,
+          defaultSelector
+        });
+      }
+    }
+  }
+  return result;
+}
+function createExtractFn(options) {
+  return (styleDefinition) => extract({
+    styleDefinition,
+    ...options
+  });
+}
+
+async function execAsyncHook(plugins, hook, payload) {
+  for (const plugin of plugins) {
+    if (plugin[hook] == null)
+      continue;
+    const newPayload = await plugin[hook](payload);
+    if (newPayload != null)
+      payload = newPayload;
+  }
+  return payload;
+}
+function execSyncHook(plugins, hook, payload) {
+  for (const plugin of plugins) {
+    if (plugin[hook] == null)
+      continue;
+    const newPayload = plugin[hook](payload);
+    if (newPayload != null)
+      payload = newPayload;
+  }
+  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),
+  transformSelectors: (plugins, selectors) => execAsyncHook(plugins, "transformSelectors", selectors),
+  transformStyleItems: (plugins, styleItems) => execAsyncHook(plugins, "transformStyleItems", styleItems),
+  transformStyleDefinitions: (plugins, styleDefinitions) => execAsyncHook(plugins, "transformStyleDefinitions", styleDefinitions),
+  preflightUpdated: (plugins) => execSyncHook(plugins, "preflightUpdated", void 0),
+  atomicRuleAdded: (plugins) => execSyncHook(plugins, "atomicRuleAdded", void 0),
+  autocompleteConfigUpdated: (plugins) => execSyncHook(plugins, "autocompleteConfigUpdated", void 0)
+};
+const orderMap = /* @__PURE__ */ new Map([
+  [void 0, 1],
+  ["pre", 0],
+  ["post", 2]
+]);
+function resolvePlugins(plugins) {
+  return plugins.sort((a, b) => orderMap.get(a.order) - orderMap.get(b.order));
+}
+function defineEnginePlugin$1(plugin) {
+  return plugin;
+}
+
+function important() {
+  let _default;
+  return defineEnginePlugin$1({
+    name: "core:important",
+    beforeConfigResolving(config) {
+      _default = config.important?.default ?? false;
+    },
+    configResolved(resolvedConfig) {
+      appendAutocompleteExtraProperties(resolvedConfig, "__important");
+      appendAutocompletePropertyValues(resolvedConfig, "__important", "boolean");
+    },
+    transformStyleDefinitions(styleDefinitions) {
+      return styleDefinitions.map((styleDefinition) => {
+        const { __important, ...rest } = styleDefinition;
+        const theImportant = __important;
+        const important2 = theImportant == null ? _default : theImportant;
+        if (important2 === false)
+          return rest;
+        return Object.fromEntries(
+          Object.entries(rest).map(([k, v]) => {
+            if (isPropertyValue(v) === false || v == null)
+              return [k, v];
+            const modified = [v].flat(2).map((v2) => `${v2} !important`);
+            return [k, modified];
+          })
+        );
+      });
+    }
+  });
+}
+
+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 configList;
+  return defineEnginePlugin$1({
+    name: "core:keyframes",
+    beforeConfigResolving(config) {
+      configList = config.keyframes ?? [];
+    },
+    configResolved(resolvedConfig) {
+      const autocomplete = {
+        animationName: [],
+        animation: []
+      };
+      configList.forEach((config) => {
+        const { name, frames, autocomplete: autocompleteAnimation } = resolveKeyframesConfig(config);
+        if (frames != null) {
+          const css = [
+            `@keyframes ${name}{`,
+            ...Object.entries(frames).map(([frame, properties]) => (
+              // eslint-disable-next-line style/newline-per-chained-call
+              `${frame}{${Object.entries(properties).map(([property, value]) => `${property}:${value}`).join(";")}}`
+            )),
+            "}"
+          ].join("");
+          allKeyframes.set(name, css);
+        }
+        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) => {
+        const used = /* @__PURE__ */ new Set();
+        engine.store.atomicRules.forEach(({ content: { property, value } }) => {
+          if (property === "animationName") {
+            value.forEach((name) => used.add(name));
+          } else if (property === "animation") {
+            value.forEach((value2) => {
+              const animations = value2.split(",").map((v) => v.trim());
+              animations.forEach((animation) => {
+                const name = animation.split(" ")[0];
+                if (isNotNullish(name))
+                  used.add(name);
+              });
+            });
+          }
+        });
+        const content = Array.from(allKeyframes.entries()).filter(([name]) => used.has(name)).map(([, css]) => css).join("");
+        return content;
+      });
+    }
+  });
+}
+
+class AbstractResolver {
+  _resolvedResultsMap = /* @__PURE__ */ new Map();
+  staticRulesMap = /* @__PURE__ */ new Map();
+  dynamicRulesMap = /* @__PURE__ */ new Map();
+  onResolved = () => {
+  };
+  get staticRules() {
+    return [...this.staticRulesMap.values()];
+  }
+  get dynamicRules() {
+    return [...this.dynamicRulesMap.values()];
+  }
+  addStaticRule(rule) {
+    this.staticRulesMap.set(rule.key, rule);
+    return this;
+  }
+  removeStaticRule(key) {
+    const rule = this.staticRulesMap.get(key);
+    if (rule == null)
+      return this;
+    this.staticRulesMap.delete(key);
+    this._resolvedResultsMap.delete(rule.string);
+    return this;
+  }
+  addDynamicRule(rule) {
+    this.dynamicRulesMap.set(rule.key, rule);
+    return this;
+  }
+  removeDynamicRule(key) {
+    const rule = this.dynamicRulesMap.get(key);
+    if (rule == null)
+      return this;
+    const matchedResolvedStringList = Array.from(this._resolvedResultsMap.keys()).filter((string) => rule.stringPattern.test(string));
+    this.dynamicRulesMap.delete(key);
+    matchedResolvedStringList.forEach((string) => this._resolvedResultsMap.delete(string));
+    return this;
+  }
+  async _resolve(string) {
+    const existedResult = this._resolvedResultsMap.get(string);
+    if (existedResult != null)
+      return existedResult;
+    const staticRule = Array.from(this.staticRulesMap.values()).find((rule) => rule.string === string);
+    if (staticRule != null) {
+      const resolvedResult = { value: staticRule.resolved };
+      this._resolvedResultsMap.set(string, resolvedResult);
+      this.onResolved(string, "static", resolvedResult);
+      return resolvedResult;
+    }
+    let dynamicRule;
+    let matched;
+    for (const rule of this.dynamicRulesMap.values()) {
+      matched = string.match(rule.stringPattern);
+      if (matched != null) {
+        dynamicRule = rule;
+        break;
+      }
+    }
+    if (dynamicRule != null && matched != null) {
+      const resolvedResult = { value: await dynamicRule.createResolved(matched) };
+      this._resolvedResultsMap.set(string, resolvedResult);
+      this.onResolved(string, "dynamic", resolvedResult);
+      return resolvedResult;
+    }
+    return void 0;
+  }
+  _setResolvedResult(string, resolved) {
+    const resolvedResult = this._resolvedResultsMap.get(string);
+    if (resolvedResult) {
+      resolvedResult.value = resolved;
+      return;
+    }
+    this._resolvedResultsMap.set(string, { value: resolved });
+  }
+}
+
+class SelectorResolver extends AbstractResolver {
+  async resolve(selector) {
+    const resolved = await this._resolve(selector);
+    if (resolved == null)
+      return [selector];
+    const result = [];
+    for (const s of resolved.value)
+      result.push(...await this.resolve(s));
+    this._setResolvedResult(selector, result);
+    return result;
+  }
+}
+function resolveSelectorConfig(config) {
+  if (typeof config === "string") {
+    return config;
+  } else if (Array.isArray(config)) {
+    if (typeof config[0] === "string" && typeof config[1] !== "function") {
+      return {
+        type: "static",
+        rule: {
+          key: config[0],
+          string: config[0],
+          resolved: [config[1]].flat(1)
+        },
+        autocomplete: [config[0]]
+      };
+    }
+    if (config[0] instanceof RegExp && typeof config[1] === "function") {
+      const fn = config[1];
+      return {
+        type: "dynamic",
+        rule: {
+          key: config[0].source,
+          stringPattern: config[0],
+          createResolved: async (match) => [await fn(match)].flat(1)
+        },
+        autocomplete: config[2] != null ? [config[2]].flat(1) : []
+      };
+    }
+  } else if (typeof config.selector === "string" && typeof config.value !== "function") {
+    return {
+      type: "static",
+      rule: {
+        key: config.selector,
+        string: config.selector,
+        resolved: [config.value].flat(1)
+      },
+      autocomplete: [config.selector]
+    };
+  } else if (config.selector instanceof RegExp && typeof config.value === "function") {
+    const fn = config.value;
+    return {
+      type: "dynamic",
+      rule: {
+        key: config.selector.source,
+        stringPattern: config.selector,
+        createResolved: async (match) => [await fn(match)].flat(1)
+      },
+      autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
+    };
+  }
+  return void 0;
+}
+function selectors() {
+  const selectorResolver = new SelectorResolver();
+  let configList;
+  return defineEnginePlugin$1({
+    name: "core:selectors",
+    beforeConfigResolving(config) {
+      configList = config.selectors ?? [];
+    },
+    configResolved(resolvedConfig) {
+      configList.forEach((config) => {
+        const resolved = resolveSelectorConfig(config);
+        if (resolved == null)
+          return;
+        if (typeof resolved === "string") {
+          appendAutocompleteSelectors(resolvedConfig, resolved);
+          return;
+        }
+        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) => {
+        if (type === "dynamic") {
+          engine.appendAutocompleteSelectors(string);
+        }
+      };
+    },
+    async transformSelectors(selectors2) {
+      const result = [];
+      for (const selector of selectors2) {
+        result.push(...await selectorResolver.resolve(selector));
+      }
+      return result;
+    }
+  });
+}
+
+class ShortcutResolver extends AbstractResolver {
+  async resolve(shortcut) {
+    const resolved = await this._resolve(shortcut);
+    if (resolved == null)
+      return [shortcut];
+    const result = [];
+    for (const partial of resolved.value) {
+      if (typeof partial === "string")
+        result.push(...await this.resolve(partial));
+      else
+        result.push(partial);
+    }
+    this._setResolvedResult(shortcut, result);
+    return result;
+  }
+}
+function resolveShortcutConfig(config) {
+  if (typeof config === "string") {
+    return config;
+  } else if (Array.isArray(config)) {
+    if (typeof config[0] === "string" && typeof config[1] !== "function") {
+      return {
+        type: "static",
+        rule: {
+          key: config[0],
+          string: config[0],
+          resolved: [config[1]].flat(1)
+        },
+        autocomplete: [config[0]]
+      };
+    }
+    if (config[0] instanceof RegExp && typeof config[1] === "function") {
+      const fn = config[1];
+      return {
+        type: "dynamic",
+        rule: {
+          key: config[0].source,
+          stringPattern: config[0],
+          createResolved: async (match) => [await fn(match)].flat(1)
+        },
+        autocomplete: config[2] != null ? [config[2]].flat(1) : []
+      };
+    }
+  } else if (typeof config.shortcut === "string" && typeof config.value !== "function") {
+    return {
+      type: "static",
+      rule: {
+        key: config.shortcut,
+        string: config.shortcut,
+        resolved: [config.value].flat(1)
+      },
+      autocomplete: [config.shortcut]
+    };
+  } else if (config.shortcut instanceof RegExp && typeof config.value === "function") {
+    const fn = config.value;
+    return {
+      type: "dynamic",
+      rule: {
+        key: config.shortcut.source,
+        stringPattern: config.shortcut,
+        createResolved: async (match) => [await fn(match)].flat(1)
+      },
+      autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
+    };
+  }
+  throw new Error("Invalid shortcut config");
+}
+function shortcuts() {
+  const shortcutResolver = new ShortcutResolver();
+  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 (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);
+      });
+      appendAutocompleteStyleItemStrings(resolvedConfig, ...autocompleteShortcuts);
+      appendAutocompleteExtraProperties(resolvedConfig, "__shortcut");
+      const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
+      appendAutocompletePropertyValues(resolvedConfig, "__shortcut", unionType, `(${unionType})[]`);
+    },
+    engineInitialized(engine) {
+      shortcutResolver.onResolved = (string, type) => {
+        if (type === "dynamic") {
+          engine.appendAutocompleteStyleItemStrings(string);
+        }
+      };
+    },
+    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;
+    }
+  });
+}
+
+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 } };
+}
+const VAR_NAME_RE = /var\((--[\w-]+)/g;
+function extractUsedVarNames(input) {
+  const matched = input.match(VAR_NAME_RE);
+  if (!matched)
+    return [];
+  return matched.map((match) => {
+    const varNameMatch = match.match(/--[^,)]+/);
+    return varNameMatch ? varNameMatch[0] : "";
+  }).filter(Boolean);
+}
+function normalizeVariableName(name, prefix) {
+  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, `${name}:${value}`);
+      });
+      resolvedConfig.preflights.push((engine) => {
+        const used = /* @__PURE__ */ new Set();
+        engine.store.atomicRules.forEach(({ content: { value } }) => {
+          value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
+        });
+        const content = Array.from(allVariables.entries()).filter(([name]) => used.has(name)).map(([, css]) => css).join(";");
+        return content === "" ? "" : `:root{${content}}`;
+      });
+    }
+  });
+}
+
+async function createEngine(config = {}) {
+  const corePlugins = [
+    important(),
+    variables(),
+    keyframes(),
+    selectors(),
+    shortcuts()
+  ];
+  const plugins = resolvePlugins([...corePlugins, ...config.plugins || []]);
+  config.plugins = plugins;
+  config = await hooks.config(
+    config.plugins,
+    config
+  );
+  hooks.beforeConfigResolving(
+    resolvePlugins(config.plugins || []),
+    config
+  );
+  let resolvedConfig = await resolveEngineConfig(config);
+  resolvedConfig = await hooks.configResolved(
+    resolvedConfig.plugins,
+    resolvedConfig
+  );
+  return new Engine(resolvedConfig);
+}
+class Engine {
+  config;
+  extract;
+  store = {
+    atomicNames: /* @__PURE__ */ new Map(),
+    atomicRules: /* @__PURE__ */ new Map()
+  };
+  constructor(config) {
+    this.config = config;
+    this.extract = createExtractFn({
+      defaultSelector: this.config.defaultSelector,
+      transformSelectors: (selectors2) => hooks.transformSelectors(this.config.plugins, selectors2),
+      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);
+  }
+  notifyAtomicRuleAdded() {
+    hooks.atomicRuleAdded(this.config.plugins);
+  }
+  notifyAutocompleteConfigUpdated() {
+    hooks.autocompleteConfigUpdated(this.config.plugins);
+  }
+  appendAutocompleteSelectors(...selectors2) {
+    appendAutocompleteSelectors(this.config, ...selectors2);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  appendAutocompleteStyleItemStrings(...styleItemStrings) {
+    appendAutocompleteStyleItemStrings(this.config, ...styleItemStrings);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  appendAutocompleteExtraProperties(...properties) {
+    appendAutocompleteExtraProperties(this.config, ...properties);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  appendAutocompleteExtraCssProperties(...properties) {
+    appendAutocompleteExtraCssProperties(this.config, ...properties);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  appendAutocompletePropertyValues(property, ...tsTypes) {
+    appendAutocompletePropertyValues(this.config, property, ...tsTypes);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  appendAutocompleteCssPropertyValues(property, ...values) {
+    appendAutocompleteCssPropertyValues(this.config, property, ...values);
+    this.notifyAutocompleteConfigUpdated();
+  }
+  async use(...itemList) {
+    const {
+      unknown,
+      contents
+    } = await resolveStyleItemList({
+      itemList,
+      transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
+      extractStyleDefinition: (styleDefinition) => this.extract(styleDefinition)
+    });
+    const resolvedNames = [];
+    contents.forEach((content) => {
+      const name = getAtomicStyleName({
+        content,
+        prefix: this.config.prefix,
+        stored: this.store.atomicNames
+      });
+      resolvedNames.push(name);
+      if (!this.store.atomicRules.has(name)) {
+        const added = {
+          name,
+          content
+        };
+        this.store.atomicRules.set(name, added);
+        this.notifyAtomicRuleAdded();
+      }
+    });
+    return [...unknown, ...resolvedNames];
+  }
+  async renderPreviewStyles(...itemList) {
+    const nameList = await this.use(...itemList);
+    const targets = nameList.map((name) => this.store.atomicRules.get(name)).filter(isNotNullish);
+    return renderAtomicStyles({
+      atomicRules: targets,
+      isPreview: true
+    });
+  }
+  renderStyles() {
+    return [
+      this.renderPreflights(),
+      this.renderAtomicStyles()
+    ].join("");
+  }
+  renderPreflights() {
+    return this.config.preflights.map((p) => p(this)).join("");
+  }
+  renderAtomicStyles() {
+    return renderAtomicStyles({
+      atomicRules: [...this.store.atomicRules.values()],
+      isPreview: false
+    });
+  }
+}
+async function resolveEngineConfig(config) {
+  const {
+    prefix = "",
+    defaultSelector = `.${ATOMIC_STYLE_NAME_PLACEHOLDER}`,
+    plugins = [],
+    preflights = [],
+    autocomplete = {}
+  } = config;
+  const resolvedConfig = {
+    rawConfig: config,
+    plugins: resolvePlugins(plugins),
+    prefix,
+    defaultSelector,
+    preflights: [],
+    autocomplete: {
+      selectors: /* @__PURE__ */ new Set(),
+      styleItemStrings: /* @__PURE__ */ new Set(),
+      extraProperties: /* @__PURE__ */ new Set(),
+      extraCssProperties: /* @__PURE__ */ new Set(),
+      properties: /* @__PURE__ */ new Map(),
+      cssProperties: /* @__PURE__ */ new Map()
+    }
+  };
+  const resolvedPreflights = preflights.map((p) => typeof p === "function" ? p : () => p);
+  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 getAtomicStyleName({
+  content,
+  prefix,
+  stored
+}) {
+  const key = serialize([content.selector, content.property, content.value]);
+  const cached = stored.get(key);
+  if (cached != null)
+    return cached;
+  const num = stored.size;
+  const name = `${prefix}${numberToChars(num)}`;
+  stored.set(key, name);
+  return name;
+}
+function optimizeAtomicStyleContents(list) {
+  const map = /* @__PURE__ */ new Map();
+  list.forEach((content) => {
+    const key = serialize([content.selector, content.property]);
+    map.delete(key);
+    if (content.value == null)
+      return;
+    map.set(key, content);
+  });
+  return [...map.values()];
+}
+async function resolveStyleItemList({
+  itemList,
+  transformStyleItems,
+  extractStyleDefinition
+}) {
+  const unknown = /* @__PURE__ */ new Set();
+  const list = [];
+  for (const styleItem of await transformStyleItems(itemList)) {
+    if (typeof styleItem === "string")
+      unknown.add(styleItem);
+    else
+      list.push(...await extractStyleDefinition(styleItem));
+  }
+  return {
+    unknown,
+    contents: optimizeAtomicStyleContents(list)
+  };
+}
+function prepareAtomicStyleBlocks({
+  atomicRules,
+  isPreview
+}) {
+  const blocks = /* @__PURE__ */ new Map();
+  atomicRules.forEach(({ name, content: { selector, property, value } }) => {
+    const isValidSelector = selector.some((s) => s.includes(ATOMIC_STYLE_NAME_PLACEHOLDER));
+    if (isValidSelector === false || value == null)
+      return;
+    const renderObject = {
+      selector: isPreview ? selector : selector.map((s) => s.replace(ATOMIC_STYLE_NAME_PLACEHOLDER_RE_GLOBAL, name)),
+      content: Array.isArray(value) ? value.map((v) => `${property}:${v}`).join(";") : `${property}:${value}`
+    };
+    let currentBlocks = blocks;
+    for (let i = 0; i < renderObject.selector.length; i++) {
+      const s = renderObject.selector[i];
+      const block = currentBlocks.get(s) || { content: [] };
+      const isLast = i === renderObject.selector.length - 1;
+      if (isLast) {
+        block.content.push(renderObject.content);
+      } else {
+        block.children ||= /* @__PURE__ */ new Map();
+      }
+      currentBlocks.set(s, block);
+      if (isLast === false)
+        currentBlocks = block.children;
+    }
+  });
+  return blocks;
+}
+function renderAtomicStyleBlocks(blocks) {
+  let rendered = "";
+  blocks.forEach((block, selector) => {
+    rendered += `${selector}{${block.content.join(";")}`;
+    if (block.children != null)
+      rendered += renderAtomicStyleBlocks(block.children);
+    rendered += "}";
+  });
+  return rendered;
+}
+function renderAtomicStyles(payload) {
+  const blocks = prepareAtomicStyleBlocks(payload);
+  return renderAtomicStyleBlocks(blocks);
+}
+
+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;