@csszyx/unplugin 0.12.0 → 0.13.0

package/dist/shared/unplugin.X9a9SL_s.cjs

@@ -0,0 +1,612 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const htmlEscape = require('./unplugin.BkRah5Ot.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const EMPTY_THEME = {
+  colors: [],
+  spacings: [],
+  fonts: [],
+  textSizes: [],
+  fontWeights: [],
+  radii: [],
+  shadows: [],
+  breakpoints: []
+};
+function findMatchingBrace(source, openBrace) {
+  let depth = 0;
+  for (let index = openBrace; index < source.length; index++) {
+    if (source[index] === "{") {
+      depth++;
+    } else if (source[index] === "}") {
+      depth--;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function stripLayerWrappers(css) {
+  let result = "";
+  let i = 0;
+  while (i < css.length) {
+    const layerIdx = css.indexOf("@layer", i);
+    if (layerIdx === -1) {
+      result += css.slice(i);
+      break;
+    }
+    result += css.slice(i, layerIdx);
+    const openBrace = css.indexOf("{", layerIdx);
+    if (openBrace === -1) {
+      result += css.slice(layerIdx);
+      break;
+    }
+    const closeBrace = findMatchingBrace(css, openBrace);
+    if (closeBrace === -1) {
+      result += css.slice(openBrace);
+      break;
+    }
+    result += css.slice(openBrace + 1, closeBrace);
+    i = closeBrace + 1;
+  }
+  return result;
+}
+function themePreludeStart(css, at) {
+  const cursor = at + "@theme".length;
+  const next = css[cursor];
+  const validBoundary = next === "{" || next === " " || next === "	" || next === "\n" || next === "\r";
+  return validBoundary ? cursor : null;
+}
+function readThemeBlock(css, start) {
+  for (let cursor = start; cursor < css.length; cursor++) {
+    const character = css[cursor];
+    if (character === "{") {
+      const close = findMatchingBrace(css, cursor);
+      return {
+        body: close === -1 ? null : css.slice(cursor + 1, close),
+        end: close === -1 ? cursor : close
+      };
+    }
+    if (character === ";" || character === "}" || character === "@") {
+      return { body: null, end: cursor };
+    }
+  }
+  return { body: null, end: css.length };
+}
+function extractThemeBlocks(css) {
+  const blocks = [];
+  let searchFrom = 0;
+  for (; ; ) {
+    const at = css.indexOf("@theme", searchFrom);
+    if (at === -1) {
+      break;
+    }
+    const preludeStart = themePreludeStart(css, at);
+    if (preludeStart === null) {
+      searchFrom = at + "@theme".length;
+      continue;
+    }
+    const match = readThemeBlock(css, preludeStart);
+    if (match.body !== null) blocks.push(match.body);
+    searchFrom = Math.max(match.end, at + "@theme".length);
+  }
+  return blocks;
+}
+function categorizeProperty(prop) {
+  const categoryMap = [
+    ["color-", "colors"],
+    ["spacing-", "spacings"],
+    // `font-weight-` MUST precede `font-`: startsWith would otherwise route
+    // `font-weight-chunky` into font FAMILIES as token "weight-chunky".
+    ["font-weight-", "fontWeights"],
+    ["font-", "fonts"],
+    // `--text-*` defines font-size utilities (text-huge) in Tailwind v4.
+    ["text-", "textSizes"],
+    ["radius-", "radii"],
+    ["shadow-", "shadows"],
+    ["breakpoint-", "breakpoints"]
+  ];
+  for (const [prefix, category] of categoryMap) {
+    if (prop.startsWith(prefix)) {
+      let token = prop.slice(prefix.length);
+      if (category !== "breakpoints") {
+        token = token.replace(/-\d+$/, "");
+      }
+      if (token) {
+        return { category, token };
+      }
+    }
+  }
+  return null;
+}
+function parseThemeBlocks(cssContent) {
+  const result = {
+    colors: /* @__PURE__ */ new Set(),
+    spacings: /* @__PURE__ */ new Set(),
+    fonts: /* @__PURE__ */ new Set(),
+    textSizes: /* @__PURE__ */ new Set(),
+    fontWeights: /* @__PURE__ */ new Set(),
+    radii: /* @__PURE__ */ new Set(),
+    shadows: /* @__PURE__ */ new Set(),
+    breakpoints: /* @__PURE__ */ new Set()
+  };
+  const stripped = stripLayerWrappers(cssContent);
+  const blocks = extractThemeBlocks(stripped);
+  for (const block of blocks) {
+    for (const name of scanCustomPropertyNames(block)) {
+      const categorized = categorizeProperty(name);
+      if (categorized) {
+        result[categorized.category].add(categorized.token);
+      }
+    }
+  }
+  return {
+    colors: htmlEscape.sortStrings(result.colors),
+    spacings: htmlEscape.sortStrings(result.spacings),
+    fonts: htmlEscape.sortStrings(result.fonts),
+    textSizes: htmlEscape.sortStrings(result.textSizes),
+    fontWeights: htmlEscape.sortStrings(result.fontWeights),
+    radii: htmlEscape.sortStrings(result.radii),
+    shadows: htmlEscape.sortStrings(result.shadows),
+    breakpoints: htmlEscape.sortStrings(result.breakpoints)
+  };
+}
+function mergeThemes(themes) {
+  if (themes.length === 0) {
+    return { ...EMPTY_THEME };
+  }
+  const merged = {
+    colors: /* @__PURE__ */ new Set(),
+    spacings: /* @__PURE__ */ new Set(),
+    fonts: /* @__PURE__ */ new Set(),
+    textSizes: /* @__PURE__ */ new Set(),
+    fontWeights: /* @__PURE__ */ new Set(),
+    radii: /* @__PURE__ */ new Set(),
+    shadows: /* @__PURE__ */ new Set(),
+    breakpoints: /* @__PURE__ */ new Set()
+  };
+  for (const theme of themes) {
+    for (const cat of Object.keys(merged)) {
+      for (const token of theme[cat]) {
+        merged[cat].add(token);
+      }
+    }
+  }
+  return {
+    colors: htmlEscape.sortStrings(merged.colors),
+    spacings: htmlEscape.sortStrings(merged.spacings),
+    fonts: htmlEscape.sortStrings(merged.fonts),
+    textSizes: htmlEscape.sortStrings(merged.textSizes),
+    fontWeights: htmlEscape.sortStrings(merged.fontWeights),
+    radii: htmlEscape.sortStrings(merged.radii),
+    shadows: htmlEscape.sortStrings(merged.shadows),
+    breakpoints: htmlEscape.sortStrings(merged.breakpoints)
+  };
+}
+function hasTokens(theme) {
+  return Object.values(theme).some((arr) => arr.length > 0);
+}
+function readCustomPropertyName(block, dashes) {
+  let end = dashes + 2;
+  if (end >= block.length || !/[a-z]/.test(block[end])) {
+    return null;
+  }
+  end++;
+  while (end < block.length && /[a-z0-9-]/.test(block[end])) {
+    end++;
+  }
+  return { name: block.slice(dashes + 2, end), end };
+}
+function findCustomPropertyDeclarationEnd(block, nameEnd) {
+  let cursor = nameEnd;
+  while (cursor < block.length && /\s/.test(block[cursor])) {
+    cursor++;
+  }
+  if (block[cursor] === ":") {
+    const valueStart = cursor + 1;
+    const semicolon = block.indexOf(";", valueStart);
+    return semicolon > valueStart ? semicolon + 1 : -1;
+  }
+  return block[nameEnd] === ";" ? nameEnd + 1 : -1;
+}
+function scanCustomPropertyNames(block) {
+  const names = [];
+  let i = 0;
+  while (i < block.length) {
+    const dashes = block.indexOf("--", i);
+    if (dashes === -1) {
+      break;
+    }
+    const property = readCustomPropertyName(block, dashes);
+    if (!property) {
+      i = dashes + 1;
+      continue;
+    }
+    const matchEnd = findCustomPropertyDeclarationEnd(block, property.end);
+    if (matchEnd === -1) {
+      i = dashes + 1;
+      continue;
+    }
+    names.push(property.name);
+    i = matchEnd;
+  }
+  return names;
+}
+
+const LEADING_WHITESPACE_RE = /^\s+/;
+const LINE_COMMENT_RE = /^\/\/[^\n]*(?:\n|$)/;
+const BLOCK_COMMENT_RE = /^\/\*[\s\S]*?\*\//;
+const USE_DIRECTIVE_RE = /^['"]use (?:client|server)['"];?\s*/;
+function insertAfterUseDirective(code, insertion) {
+  let offset = 0;
+  while (offset < code.length) {
+    const triviaLength = leadingTriviaLength(code.slice(offset));
+    if (triviaLength === 0) break;
+    offset += triviaLength;
+  }
+  const directive = USE_DIRECTIVE_RE.exec(code.slice(offset));
+  if (!directive) return `${insertion}${code}`;
+  const insertionOffset = offset + directive[0].length;
+  return `${code.slice(0, insertionOffset)}${insertion}${code.slice(insertionOffset)}`;
+}
+function leadingTriviaLength(source) {
+  return LEADING_WHITESPACE_RE.exec(source)?.[0].length ?? LINE_COMMENT_RE.exec(source)?.[0].length ?? BLOCK_COMMENT_RE.exec(source)?.[0].length ?? 0;
+}
+
+const RUNTIME_IMPORT_CLAUSE_RE = /(?:import|export)\s+\{([^{}]*)\}\s*from\s*['"]@csszyx\/runtime['"]/g;
+function clauseNames(clauseBody) {
+  const names = [];
+  for (const part of clauseBody.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const spaceAt = trimmed.search(/\s/);
+    names.push(spaceAt === -1 ? trimmed : trimmed.slice(0, spaceAt));
+  }
+  return names;
+}
+function importsRuntimeHelper(code, helper) {
+  RUNTIME_IMPORT_CLAUSE_RE.lastIndex = 0;
+  for (let match = RUNTIME_IMPORT_CLAUSE_RE.exec(code); match; match = RUNTIME_IMPORT_CLAUSE_RE.exec(code)) {
+    if (clauseNames(match[1]).includes(helper)) {
+      return true;
+    }
+  }
+  return false;
+}
+const RUNTIME_IMPORT_APPEND_RE = /(import\s+\{[^{}]*)\}\s*from\s*['"]@csszyx\/runtime['"]/;
+function findRuntimeImportClause(code) {
+  const match = RUNTIME_IMPORT_APPEND_RE.exec(code);
+  return match ? { statement: match[0], prefixWithBody: match[1] } : null;
+}
+
+function runtimeHelperGroupsFromUsage(usage) {
+  const slim = usage.usesSzPart === true && usage.szPartArgsProvable === true && usage.usesRuntime !== true && usage.usesMerge !== true;
+  const groups = { all: [], barrel: [], merge: [] };
+  const append = (helper, toMerge = false) => {
+    groups.all.push(helper);
+    (toMerge ? groups.merge : groups.barrel).push(helper);
+  };
+  if (usage.usesRuntime) append("_sz");
+  if (usage.usesMerge) append("_szMerge");
+  if (usage.usesSzcn) append("_szcn", slim);
+  if (usage.usesSzPart) append("_szPart", slim);
+  if (usage.usesSzvPick) append("__szvPick");
+  if (usage.usesSzvPick1) append("__szvPick1");
+  if (usage.usesColorVar) append("__szColorVar");
+  if (usage.usesSpacingVar) append("__szSpacingVar");
+  if (usage.usesUnitVar) append("__szUnitVar");
+  return groups;
+}
+function injectNextRuntimeImports(code, usage) {
+  const groups = runtimeHelperGroupsFromUsage(usage);
+  const helpers = groups.all;
+  if (helpers.length === 0) {
+    return { code, injected: [] };
+  }
+  const hasRuntimeImport = code.includes("@csszyx/runtime");
+  const missing = hasRuntimeImport ? helpers.filter((helper) => !importsRuntimeHelper(code, helper)) : helpers;
+  if (missing.length === 0) {
+    return { code, injected: [] };
+  }
+  if (groups.merge.length > 0) {
+    const mergeHelpers = missing.filter((helper) => groups.merge.includes(helper));
+    const barrelHelpers = missing.filter((helper) => groups.barrel.includes(helper));
+    let next = insertRuntimeImport(
+      code,
+      `import { ${mergeHelpers.join(", ")} } from '@csszyx/runtime/merge';
+`
+    );
+    if (barrelHelpers.length > 0) {
+      next = insertRuntimeImport(
+        next,
+        `import { ${barrelHelpers.join(", ")} } from '@csszyx/runtime';
+`
+      );
+    }
+    return { code: next, injected: missing };
+  }
+  return {
+    code: insertRuntimeImport(
+      code,
+      `import { ${missing.join(", ")} } from '@csszyx/runtime';
+`
+    ),
+    injected: missing
+  };
+}
+function insertRuntimeImport(code, importStmt) {
+  return insertAfterUseDirective(code, importStmt);
+}
+
+const THEME_SCAN_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  "build",
+  ".turbo"
+]);
+function normalize(value) {
+  const posix = value.replaceAll("\\", "/");
+  return posix.endsWith("/") ? posix.slice(0, -1) : posix;
+}
+function walkCss(dir, out) {
+  let entries;
+  try {
+    entries = fs__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!THEME_SCAN_IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        walkCss(path__default.join(dir, entry.name), out);
+      }
+      continue;
+    }
+    if (entry.name.endsWith(".css")) {
+      out.push(path__default.join(dir, entry.name));
+    }
+  }
+}
+function discoverProjectTheme(rootDir, extraDirs = []) {
+  const cssFiles = [];
+  walkCss(rootDir, cssFiles);
+  const normalizedRoot = normalize(rootDir);
+  for (const dir of extraDirs) {
+    const normalized = normalize(dir);
+    if (normalized === normalizedRoot || normalized.startsWith(`${normalizedRoot}/`)) continue;
+    walkCss(dir, cssFiles);
+  }
+  const themes = [];
+  const files = [];
+  for (const file of cssFiles) {
+    let content;
+    try {
+      content = fs__default.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!content.includes("@theme")) continue;
+    themes.push(parseThemeBlocks(content));
+    files.push(file);
+  }
+  return {
+    theme: themes.length > 0 ? mergeThemes(themes) : null,
+    files,
+    scanned: cssFiles
+  };
+}
+
+const VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+const THEME_GROUPS_VIRTUAL_ID = "virtual:csszyx/theme-groups";
+const RESOLVED_THEME_GROUPS_VIRTUAL_ID = `\0${THEME_GROUPS_VIRTUAL_ID}`;
+const VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
+const RESOLVED_VIRTUAL_CHECKSUM_ID = `\0${VIRTUAL_CHECKSUM_ID}`;
+function createMangleMapModule(mangleMap, checksum, varMangleMap = {}, cssVarMetrics = null) {
+  return `/**
+ * Auto-generated mangle map for csszyx.
+ * This module is generated at build time and contains the mapping
+ * from original class names and CSS variable names to mangled names.
+ *
+ * @generated
+ */
+
+export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
+
+export const varMangleMap = ${JSON.stringify(varMangleMap, null, 2)};
+
+export const cssVarMetrics = ${JSON.stringify(cssVarMetrics, null, 2)};
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default {
+  mangleMap,
+  varMangleMap,
+  cssVarMetrics,
+  checksum,
+};
+`;
+}
+function createChecksumModule(checksum) {
+  return `/**
+ * Auto-generated checksum for csszyx mangle map.
+ *
+ * @generated
+ */
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default checksum;
+`;
+}
+function isVirtualModule(id) {
+  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID || id === THEME_GROUPS_VIRTUAL_ID || id === MANGLE_RUNTIME_VIRTUAL_ID;
+}
+function resolveVirtualModule(id) {
+  if (id === VIRTUAL_MODULE_ID) {
+    return RESOLVED_VIRTUAL_MODULE_ID;
+  }
+  if (id === VIRTUAL_CHECKSUM_ID) {
+    return RESOLVED_VIRTUAL_CHECKSUM_ID;
+  }
+  if (id === THEME_GROUPS_VIRTUAL_ID) {
+    return RESOLVED_THEME_GROUPS_VIRTUAL_ID;
+  }
+  if (id === MANGLE_RUNTIME_VIRTUAL_ID) {
+    return RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID;
+  }
+  return void 0;
+}
+const MANGLE_RUNTIME_VIRTUAL_ID = "virtual:csszyx/mangle-runtime";
+const RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID = `\0${MANGLE_RUNTIME_VIRTUAL_ID}`;
+const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+const VAR_MANGLE_MAP_PLACEHOLDER = "___CSSZYX_VAR_MANGLE_MAP___";
+const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+function createMangleRuntimeModule(globalVarAliasPrefix) {
+  return `/**
+ * Auto-generated by csszyx: installs the runtime mangle map from the bundle.
+ *
+ * @generated
+ */
+
+const m = ${MANGLE_MAP_PLACEHOLDER};
+const vm = ${VAR_MANGLE_MAP_PLACEHOLDER};
+const gp = ${JSON.stringify(globalVarAliasPrefix)};
+const checksum = "${CHECKSUM_PLACEHOLDER}";
+
+if (typeof window !== 'undefined' && !window.__csszyx) {
+    const r = {};
+    const vr = {};
+    for (const k in m) r[m[k]] = k;
+    for (const vk in vm) {
+        const vv = vm[vk];
+        const vs = Array.isArray(vv) ? vv : [vv];
+        for (const v of vs) (vr[v] || (vr[v] = [])).push(vk);
+    }
+    window.__csszyx = {
+        mangleMap: m,
+        varMangleMap: vm,
+        checksum,
+        decode: (c) => r[c],
+        encode: (c) => m[c],
+        decodeVar: (v) => vr[v] || [],
+        encodeVar: (v) => vm[v],
+        decodeGlobalVar: (v) => {
+            const a = vr[v] || [];
+            return v.indexOf(gp) === 0 ? a[0] : undefined;
+        },
+        decodeAll: (el) => (el.className || '').split(' ').map((c) => r[c] || c),
+    };
+}
+
+export {};
+`;
+}
+function createThemeGroupsModule(tokens) {
+  const payload = JSON.stringify({
+    colors: tokens.colors,
+    textSizes: tokens.textSizes,
+    fontFamilies: tokens.fontFamilies,
+    fontWeights: tokens.fontWeights
+  });
+  return [
+    "// Auto-generated by csszyx from the @theme blocks in scanned CSS.",
+    "import { setSzcnGroups } from '@csszyx/runtime';",
+    // `set`, not `register`: this payload is the COMPLETE scanned set, so
+    // re-running it after a `@theme` edit has to drop the tokens the
+    // stylesheet lost. The source name scopes the replace, leaving an app's
+    // own hand-written registration untouched.
+    `setSzcnGroups(${payload}, 'build');`,
+    "export {};"
+  ].join("\n");
+}
+
+const THEME_GROUPS_FILE = "theme-groups.mjs";
+const THEME_GROUPS_FILE_MARKER = `.csszyx/${THEME_GROUPS_FILE}`;
+const cacheByRoot = /* @__PURE__ */ new Map();
+function signatureOf(files) {
+  return files.map((file) => {
+    try {
+      const stat = fs__default.statSync(file);
+      return `${file}:${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return `${file}:gone`;
+    }
+  }).join("|");
+}
+function isCacheUsable(cached) {
+  if (cached === void 0) return false;
+  return signatureOf(cached.watch) === cached.signature;
+}
+function ensureThemeGroupsFile(root, outputDir) {
+  const cached = cacheByRoot.get(root);
+  if (isCacheUsable(cached)) {
+    return { file: cached.file, watch: cached.watch };
+  }
+  const { theme, scanned } = discoverProjectTheme(root);
+  const tokens = {
+    colors: theme?.colors ?? [],
+    textSizes: theme?.textSizes ?? [],
+    fontFamilies: theme?.fonts ?? [],
+    fontWeights: theme?.fontWeights ?? []
+  };
+  const hasTokens = Object.values(tokens).some((names) => names.length > 0);
+  let file = null;
+  if (hasTokens) {
+    const target = path__default.join(outputDir, THEME_GROUPS_FILE);
+    try {
+      fs__default.mkdirSync(outputDir, { recursive: true });
+      fs__default.writeFileSync(target, createThemeGroupsModule(tokens), "utf8");
+      file = target;
+    } catch {
+      file = null;
+    }
+  }
+  const result = { file, watch: scanned, signature: signatureOf(scanned) };
+  cacheByRoot.set(root, result);
+  return { file, watch: scanned };
+}
+function themeGroupsSpecifier(fromFile, themeGroupsFile) {
+  const relative = path__default.relative(path__default.dirname(fromFile), themeGroupsFile).replaceAll("\\", "/");
+  return relative.startsWith("./") || relative.startsWith("../") ? relative : `./${relative}`;
+}
+
+exports.CHECKSUM_PLACEHOLDER = CHECKSUM_PLACEHOLDER;
+exports.MANGLE_MAP_PLACEHOLDER = MANGLE_MAP_PLACEHOLDER;
+exports.MANGLE_RUNTIME_VIRTUAL_ID = MANGLE_RUNTIME_VIRTUAL_ID;
+exports.RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID = RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID;
+exports.RESOLVED_THEME_GROUPS_VIRTUAL_ID = RESOLVED_THEME_GROUPS_VIRTUAL_ID;
+exports.RESOLVED_VIRTUAL_CHECKSUM_ID = RESOLVED_VIRTUAL_CHECKSUM_ID;
+exports.RESOLVED_VIRTUAL_MODULE_ID = RESOLVED_VIRTUAL_MODULE_ID;
+exports.THEME_GROUPS_FILE_MARKER = THEME_GROUPS_FILE_MARKER;
+exports.THEME_GROUPS_VIRTUAL_ID = THEME_GROUPS_VIRTUAL_ID;
+exports.VAR_MANGLE_MAP_PLACEHOLDER = VAR_MANGLE_MAP_PLACEHOLDER;
+exports.createChecksumModule = createChecksumModule;
+exports.createMangleMapModule = createMangleMapModule;
+exports.createMangleRuntimeModule = createMangleRuntimeModule;
+exports.createThemeGroupsModule = createThemeGroupsModule;
+exports.discoverProjectTheme = discoverProjectTheme;
+exports.ensureThemeGroupsFile = ensureThemeGroupsFile;
+exports.findRuntimeImportClause = findRuntimeImportClause;
+exports.hasTokens = hasTokens;
+exports.importsRuntimeHelper = importsRuntimeHelper;
+exports.injectNextRuntimeImports = injectNextRuntimeImports;
+exports.insertAfterUseDirective = insertAfterUseDirective;
+exports.isVirtualModule = isVirtualModule;
+exports.mergeThemes = mergeThemes;
+exports.parseThemeBlocks = parseThemeBlocks;
+exports.resolveVirtualModule = resolveVirtualModule;
+exports.runtimeHelperGroupsFromUsage = runtimeHelperGroupsFromUsage;
+exports.scanCustomPropertyNames = scanCustomPropertyNames;
+exports.themeGroupsSpecifier = themeGroupsSpecifier;