rainbowindex 0.0.0 → 0.2.0

package/dist/chunk-KCSNR2TV.mjs

@@ -0,0 +1,671 @@
+import {
+  APPLY_ALIASES,
+  DEFAULT_PROPERTY_GROUP,
+  DIRECTIVE_NAMES_SET,
+  MAX_DIRECTIVE_INPUT_SIZE,
+  PROPERTY_GROUPS,
+  RI_IMPORT_SPECIFIER_ALTERNATION,
+  analyzeProjectCSS,
+  collectProjectClasses,
+  compileCSSFunctions,
+  expandVariantGroups,
+  finalizeProjectCompilation,
+  forEachApplyClass,
+  getCustomUtility,
+  hasApplyLikeDirective,
+  hasCSSFunctions,
+  hasRIActivation,
+  parseUtility,
+  pushWarningsDeduped,
+  resolveGoogleFonts,
+  resolveUtilityDeclarations,
+  resolveVariant,
+  validateGlobPattern
+} from "./chunk-RPXZ3O6R.mjs";
+
+// src/integrations/postcss/index.ts
+import postcss from "postcss";
+import { isAbsolute } from "path";
+
+// src/integrations/postcss/apply.ts
+function makeDeclGroup(r) {
+  const firstProp = r.declarations[0]?.property ?? "";
+  const sortKey = PROPERTY_GROUPS[firstProp] ?? DEFAULT_PROPERTY_GROUP;
+  return {
+    sortKey,
+    decls: r.declarations.map((d) => ({ decl: d, important: r.important }))
+  };
+}
+function flattenGroups(groups) {
+  const sorted = [...groups].sort((a, b) => a.sortKey - b.sortKey);
+  const out = [];
+  for (const g of sorted) out.push(...g.decls);
+  return out;
+}
+var MAX_APPLY_DEPTH = 5;
+var MAX_APPLY_CLASSES = 500;
+function applySource(node, source) {
+  if (source && typeof source === "object" && "source" in source) {
+    const sourceNode = source;
+    if (sourceNode.source) node.source = sourceNode.source;
+  }
+  return node;
+}
+var GROUP_VARIANT_RE = /^\.group(.+) &$/;
+function findGroupAncestor(startRule, groupRoots) {
+  if (groupRoots.has(startRule)) {
+    return { groupRootSelector: resolveFullNestingSelector(startRule) };
+  }
+  let current = startRule.parent;
+  while (current) {
+    if (current.type === "rule") {
+      const rule = current;
+      if (groupRoots.has(rule)) {
+        return { groupRootSelector: resolveFullNestingSelector(rule) };
+      }
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function splitSelectorList(selector) {
+  const results = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < selector.length; i++) {
+    const ch = selector[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "," && depth === 0) {
+      results.push(selector.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  results.push(selector.slice(start).trim());
+  return results.filter(Boolean);
+}
+function composeNestedSelectors(parts) {
+  if (parts.length === 0) return "";
+  let branches = splitSelectorList(parts[0]);
+  for (let i = 1; i < parts.length; i++) {
+    const childBranches = splitSelectorList(parts[i]);
+    const next = [];
+    for (const parent of branches) {
+      for (const child of childBranches) {
+        if (child.includes("&")) {
+          next.push(child.replace(/&/g, parent));
+        } else {
+          next.push(`${parent} ${child}`);
+        }
+      }
+    }
+    branches = next;
+  }
+  return branches.join(", ");
+}
+function resolveFullNestingSelector(rule) {
+  const parts = [rule.selector];
+  let current = rule.parent;
+  while (current) {
+    if (current.type === "rule") {
+      parts.unshift(current.selector);
+    }
+    current = current.parent;
+  }
+  return composeNestedSelectors(parts);
+}
+function findDocRoot(node) {
+  let current = node;
+  while (current.parent) {
+    current = current.parent;
+  }
+  return current;
+}
+function processApply(root, theme, warnings, postcss2) {
+  if (!postcss2) {
+    warnings.push("[RI-1006] @apply requires postcss but it was not provided.");
+    return;
+  }
+  for (const alias of APPLY_ALIASES) {
+    root.walkAtRules(alias, (atRule) => {
+      atRule.name = "apply";
+    });
+  }
+  const customVariantMap = new Map(theme.customVariants.map((cv) => [cv.name, cv]));
+  const checkedApplyRoots = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < MAX_APPLY_DEPTH; depth++) {
+    const applyNodes = [];
+    const classListByNode = /* @__PURE__ */ new Map();
+    const groupRoots = /* @__PURE__ */ new Set();
+    root.walkAtRules("apply", (atRule) => {
+      applyNodes.push(atRule);
+      const params = expandVariantGroups(atRule.params, warnings);
+      const classNames = params.trim().split(/\s+/).filter(Boolean);
+      classListByNode.set(atRule, classNames);
+      if (classNames.includes("group")) {
+        const parent = atRule.parent;
+        if (parent && parent.type === "rule") {
+          groupRoots.add(parent);
+        }
+      }
+    });
+    if (applyNodes.length === 0) break;
+    for (const atRule of applyNodes) {
+      expandApply(
+        atRule,
+        classListByNode.get(atRule) ?? [],
+        theme,
+        warnings,
+        customVariantMap,
+        postcss2,
+        groupRoots,
+        checkedApplyRoots
+      );
+    }
+  }
+  const remaining = [];
+  root.walkAtRules("apply", (atRule) => {
+    remaining.push(atRule);
+  });
+  if (remaining.length > 0) {
+    warnings.push(
+      `[RI-1006] @apply recursion depth limit reached (${MAX_APPLY_DEPTH}). ${remaining.length} remaining @apply directive(s) will not be expanded.`
+    );
+    for (const atRule of remaining) {
+      atRule.remove();
+    }
+  }
+}
+function expandApply(atRule, classNames, theme, warnings, customVariantMap, postcss2, groupRoots, checkedApplyRoots) {
+  const parentRule = atRule.parent;
+  if (parentRule?.type !== "rule") {
+    warnings.push("[RI-1006] @apply must be used inside a CSS rule, not at the top level.");
+    atRule.remove();
+    return;
+  }
+  const baseSelector = parentRule.selector;
+  const parentContainer = parentRule.parent;
+  if (!parentContainer) {
+    atRule.remove();
+    return;
+  }
+  if (classNames.length > MAX_APPLY_CLASSES) {
+    warnings.push(
+      `[RI-1006] @apply contains ${classNames.length} classes (limit: ${MAX_APPLY_CLASSES}). Split into multiple @apply directives or reduce class count.`
+    );
+    atRule.remove();
+    return;
+  }
+  const resolved = [];
+  for (const className of classNames) {
+    const r = resolveClassName(className, theme, warnings, customVariantMap, checkedApplyRoots);
+    if (r) resolved.push(r);
+  }
+  const baseGroups = [];
+  const baseNestedBlocks = [];
+  const nestedGroups = /* @__PURE__ */ new Map();
+  const variantBuckets = /* @__PURE__ */ new Map();
+  for (const r of resolved) {
+    const hasVariants = r.variants.length > 0;
+    const hasNested = !!r.nestedSelector;
+    const group = makeDeclGroup(r);
+    if (!hasVariants && !hasNested) {
+      baseGroups.push(group);
+      if (r.nested) {
+        for (const block of r.nested) baseNestedBlocks.push({ block, important: r.important });
+      }
+    } else if (!hasVariants && hasNested) {
+      const key = r.nestedSelector;
+      if (!key) continue;
+      let list = nestedGroups.get(key);
+      if (!list) {
+        list = [];
+        nestedGroups.set(key, list);
+      }
+      list.push(group);
+    } else {
+      const key = variantKey(r.variants, r.nestedSelector);
+      let bucket = variantBuckets.get(key);
+      if (!bucket) {
+        bucket = {
+          wrappers: r.variants,
+          nestedSelector: r.nestedSelector,
+          groups: [],
+          nestedBlocks: []
+        };
+        variantBuckets.set(key, bucket);
+      }
+      bucket.groups.push(group);
+      if (r.nested) {
+        for (const block of r.nested) bucket.nestedBlocks.push({ block, important: r.important });
+      }
+    }
+  }
+  for (const { decl, important } of flattenGroups(baseGroups)) {
+    const node = applySource(
+      postcss2.decl({
+        prop: decl.property,
+        value: decl.value,
+        important
+      }),
+      atRule
+    );
+    atRule.before(node);
+  }
+  for (const { block, important } of baseNestedBlocks) {
+    atRule.before(buildNestedBlockNode(block, postcss2, atRule, important));
+  }
+  let insertAfter = parentRule;
+  for (const [nestedSel, groups] of nestedGroups) {
+    const sel = nestedSel.replaceAll("&", baseSelector);
+    const rule = applySource(postcss2.rule({ selector: sel }), parentRule);
+    for (const { decl, important } of flattenGroups(groups)) {
+      rule.append(
+        applySource(postcss2.decl({ prop: decl.property, value: decl.value, important }), atRule)
+      );
+    }
+    parentContainer.insertAfter(insertAfter, rule);
+    insertAfter = rule;
+  }
+  const groupInfoByKey = /* @__PURE__ */ new Map();
+  let hasGroupVariants = false;
+  for (const [key, bucket] of variantBuckets) {
+    const info = resolveGroupVariantInfo(bucket.wrappers, parentRule, groupRoots);
+    groupInfoByKey.set(key, info);
+    if (info) hasGroupVariants = true;
+  }
+  let fullSelectorMemo = null;
+  const fullNestingSelector = () => {
+    if (fullSelectorMemo === null)
+      fullSelectorMemo = resolveFullNestingSelector(parentRule);
+    return fullSelectorMemo;
+  };
+  let docRootMemo = null;
+  const docRoot = () => {
+    if (docRootMemo === null) docRootMemo = findDocRoot(parentContainer);
+    return docRootMemo;
+  };
+  for (const [key, bucket] of variantBuckets) {
+    const groupVariantInfo = groupInfoByKey.get(key) ?? null;
+    const bucketDecls = flattenGroups(bucket.groups);
+    if (groupVariantInfo) {
+      const fullSelector = fullNestingSelector();
+      const { groupRootSelector } = groupVariantInfo;
+      const rootBranches = splitSelectorList(groupRootSelector);
+      const fullBranches = splitSelectorList(fullSelector);
+      const baseBranches = [];
+      for (const fb of fullBranches) {
+        let stripped = false;
+        for (const rb of rootBranches) {
+          if (fb.startsWith(rb)) {
+            const after = fb.slice(rb.length);
+            baseBranches.push(after.startsWith(" ") ? after.slice(1) : after);
+            stripped = true;
+            break;
+          }
+        }
+        if (!stripped) baseBranches.push(fb);
+      }
+      const effectiveBase = [...new Set(baseBranches)].join(", ");
+      const node = buildVariantNode(
+        effectiveBase,
+        groupVariantInfo.rewrittenWrappers,
+        bucketDecls,
+        postcss2,
+        atRule,
+        bucket.nestedSelector,
+        bucket.nestedBlocks
+      );
+      if (node) {
+        docRoot().append(node);
+      }
+    } else if (hasGroupVariants) {
+      const node = buildVariantNode(
+        fullNestingSelector(),
+        bucket.wrappers,
+        bucketDecls,
+        postcss2,
+        atRule,
+        bucket.nestedSelector,
+        bucket.nestedBlocks
+      );
+      if (node) {
+        docRoot().append(node);
+      }
+    } else {
+      const node = buildVariantNode(
+        baseSelector,
+        bucket.wrappers,
+        bucketDecls,
+        postcss2,
+        atRule,
+        bucket.nestedSelector,
+        bucket.nestedBlocks
+      );
+      if (node) {
+        parentContainer.insertAfter(insertAfter, node);
+        insertAfter = node;
+      }
+    }
+  }
+  atRule.remove();
+}
+function resolveGroupVariantInfo(wrappers, parentRule, groupRoots) {
+  if (groupRoots.size === 0) return null;
+  const hasGroupVariant = wrappers.some(
+    (w) => w.selectorSuffix && w.replaceAmpersand && GROUP_VARIANT_RE.test(w.selectorSuffix)
+  );
+  if (!hasGroupVariant) return null;
+  const groupInfo = findGroupAncestor(parentRule, groupRoots);
+  if (!groupInfo) return null;
+  const rewrittenWrappers = wrappers.map((w) => {
+    if (!w.selectorSuffix || !w.replaceAmpersand) return w;
+    const match = w.selectorSuffix.match(GROUP_VARIANT_RE);
+    if (!match) return w;
+    const pseudo = match[1];
+    const rootBranches = splitSelectorList(groupInfo.groupRootSelector);
+    const newSuffix = rootBranches.map((b) => `${b}${pseudo} &`).join(", ");
+    return { ...w, selectorSuffix: newSuffix };
+  });
+  return { rewrittenWrappers, groupRootSelector: groupInfo.groupRootSelector };
+}
+var MARKER_CLASSES = /* @__PURE__ */ new Set(["group"]);
+var MAX_CUSTOM_APPLY_DEPTH = 5;
+function findCustomUtility(utility, value, theme) {
+  const target = value === null ? utility : `${utility}-${value}`;
+  const cu = getCustomUtility(theme, target);
+  return cu && !cu.functional ? cu : void 0;
+}
+function checkCustomApplyWarnings(cu, theme, warnings, visiting = /* @__PURE__ */ new Set()) {
+  if (!hasApplyLikeDirective(cu.body)) return;
+  const innerClasses = [];
+  forEachApplyClass(cu.body, (cls) => innerClasses.push(cls));
+  if (innerClasses.length === 0) return;
+  if (visiting.has(cu.name)) {
+    warnings.push(
+      `[RI-1005] Circular @apply detected in @utility "${cu.name}" \u2014 skipping inner @apply.`
+    );
+    return;
+  }
+  if (visiting.size >= MAX_CUSTOM_APPLY_DEPTH) {
+    warnings.push(
+      `[RI-1005] @apply recursion depth limit reached in @utility "${cu.name}" \u2014 skipping inner @apply.`
+    );
+    return;
+  }
+  visiting.add(cu.name);
+  for (const innerClass of innerClasses) {
+    const parsed = parseUtility(innerClass);
+    const innerCu = findCustomUtility(parsed.utility, parsed.value, theme);
+    if (innerCu) checkCustomApplyWarnings(innerCu, theme, warnings, visiting);
+  }
+  visiting.delete(cu.name);
+}
+function resolveClassName(className, theme, warnings, customVariantMap, checkedApplyRoots) {
+  const parsed = parseUtility(className);
+  if (parsed.variants.length === 0 && MARKER_CLASSES.has(parsed.utility) && parsed.value === null) {
+    return null;
+  }
+  const utilResult = resolveUtilityDeclarations(parsed, theme, warnings);
+  if (!utilResult) {
+    warnings.push(`[RI-1005] Unknown utility "${className}" in @apply \u2014 skipping.`);
+    return null;
+  }
+  const declarations = [...utilResult.declarations];
+  const cu = findCustomUtility(parsed.utility, parsed.value, theme);
+  if (cu && !checkedApplyRoots.has(cu.name)) {
+    checkedApplyRoots.add(cu.name);
+    checkCustomApplyWarnings(cu, theme, warnings);
+  }
+  const variantWrappers = [];
+  for (const variant of parsed.variants) {
+    const wrapper = resolveVariant(variant, theme, customVariantMap);
+    if (!wrapper) {
+      warnings.push(
+        `[RI-1004] Unknown variant "${variant}" in @apply "${className}" \u2014 skipping. Check spelling, or register the variant with \`@custom ${variant} { ... }\`. Built-in variants: hover, focus, dark, sm/md/lg/xl, data-[attr], arbitrary [selector].`
+      );
+      return null;
+    }
+    variantWrappers.push(wrapper);
+  }
+  return {
+    declarations,
+    important: parsed.important,
+    nestedSelector: utilResult.nestedSelector,
+    nested: utilResult.nested,
+    variants: variantWrappers
+  };
+}
+function variantKey(wrappers, nestedSelector) {
+  const parts = [];
+  for (const w of wrappers) {
+    const sel = w.selectorSuffix ?? "";
+    const at = w.atRule ?? "";
+    parts.push(
+      `${sel.length}:${sel}${at.length}:${at}${w.startingStyle ? "1" : "0"}${w.replaceAmpersand ? "1" : "0"}`
+    );
+  }
+  let key = parts.join("\0");
+  if (nestedSelector) key += `\0N${nestedSelector}`;
+  return key;
+}
+function buildNestedBlockNode(block, postcss2, sourceNode, important) {
+  let node;
+  if (block.selector.charCodeAt(0) === 64) {
+    const spaceIdx = block.selector.indexOf(" ");
+    const name = spaceIdx === -1 ? block.selector.slice(1) : block.selector.slice(1, spaceIdx);
+    const params = spaceIdx === -1 ? "" : block.selector.slice(spaceIdx + 1);
+    node = applySource(postcss2.atRule({ name, params }), sourceNode);
+  } else {
+    node = applySource(postcss2.rule({ selector: block.selector }), sourceNode);
+  }
+  for (const d of block.declarations) {
+    node.append(
+      applySource(postcss2.decl({ prop: d.property, value: d.value, important }), sourceNode)
+    );
+  }
+  for (const child of block.nested) {
+    node.append(buildNestedBlockNode(child, postcss2, sourceNode, important));
+  }
+  return node;
+}
+function buildVariantNode(baseSelector, wrappers, decls, postcss2, sourceNode, nestedSelector, nestedBlocks) {
+  if (decls.length === 0 && nestedBlocks.length === 0) return null;
+  let selector = baseSelector;
+  const atRules = [];
+  let startingStyle = false;
+  for (const w of wrappers) {
+    if (w.selectorSuffix) {
+      const branches = splitSelectorList(selector);
+      const suffix = w.selectorSuffix;
+      if (w.replaceAmpersand) {
+        selector = branches.map((b) => suffix.replace(/&/g, b)).join(", ");
+      } else {
+        selector = branches.map((b) => b + suffix).join(", ");
+      }
+    }
+    if (w.atRule) {
+      atRules.push(w.atRule);
+    }
+    if (w.startingStyle) {
+      startingStyle = true;
+    }
+  }
+  const rule = applySource(postcss2.rule({ selector }), sourceNode);
+  let declTarget = rule;
+  if (nestedSelector) {
+    declTarget = applySource(postcss2.rule({ selector: nestedSelector }), sourceNode);
+    rule.append(declTarget);
+  }
+  if (startingStyle) {
+    const startingAtRule = applySource(postcss2.atRule({ name: "starting-style" }), sourceNode);
+    for (const { decl, important } of decls) {
+      startingAtRule.append(
+        applySource(
+          postcss2.decl({ prop: decl.property, value: decl.value, important }),
+          sourceNode
+        )
+      );
+    }
+    declTarget.append(startingAtRule);
+  } else {
+    for (const { decl, important } of decls) {
+      declTarget.append(
+        applySource(
+          postcss2.decl({ prop: decl.property, value: decl.value, important }),
+          sourceNode
+        )
+      );
+    }
+  }
+  for (const { block, important } of nestedBlocks) {
+    declTarget.append(buildNestedBlockNode(block, postcss2, sourceNode, important));
+  }
+  if (atRules.length === 0) return rule;
+  let node = rule;
+  for (let i = atRules.length - 1; i >= 0; i--) {
+    const atRuleStr = atRules[i];
+    const spaceIdx = atRuleStr.indexOf(" ");
+    const name = spaceIdx === -1 ? atRuleStr.slice(1) : atRuleStr.slice(1, spaceIdx);
+    const params = spaceIdx === -1 ? "" : atRuleStr.slice(spaceIdx + 1);
+    const wrapper = applySource(postcss2.atRule({ name, params }), sourceNode);
+    wrapper.append(node);
+    node = wrapper;
+  }
+  return node;
+}
+
+// src/integrations/postcss/index.ts
+var RI_IMPORT_PARAMS_RE = new RegExp(
+  `^(?:url\\(\\s*)?["'](?:${RI_IMPORT_SPECIFIER_ALTERNATION})["']\\s*\\)?(?:\\s+.+)?$`,
+  "i"
+);
+function isRainbowIndexImport(atRule) {
+  if (atRule.name !== "import") return false;
+  return RI_IMPORT_PARAMS_RE.test(atRule.params.trim());
+}
+function stripRIDirectiveNodes(root) {
+  const toRemove = [];
+  for (const node of root.nodes ?? []) {
+    if (node.type === "atrule") {
+      const atRule = node;
+      const isApplyLike = atRule.name === "apply" || atRule.name === "slot" || APPLY_ALIASES.includes(atRule.name);
+      if (isRainbowIndexImport(atRule) || DIRECTIVE_NAMES_SET.has(atRule.name) && !isApplyLike) {
+        toRemove.push(atRule);
+      }
+    }
+  }
+  for (const node of toRemove) {
+    node.remove();
+  }
+}
+function warnStandaloneSlots(root, warnings) {
+  root.walkAtRules("slot", (atRule) => {
+    warnings.push(
+      '[RI-1037] @slot is only valid inside @custom (e.g. `@custom hocus { &:hover { @slot; } }`). To style a slotted element directly, write `[data-slot="name"] { \u2026 }`.'
+    );
+    atRule.remove();
+  });
+}
+function processCSSFunctions(root, theme, warnings) {
+  root.walkDecls((decl) => {
+    if (hasCSSFunctions(decl.value)) {
+      decl.value = compileCSSFunctions(decl.value, theme, warnings);
+    }
+  });
+}
+var rainbowindex = (options = {}) => {
+  return {
+    postcssPlugin: "rainbowindex",
+    async Once(root, { result }) {
+      try {
+        const cwd = options.cwd || process.cwd();
+        if (!cwd || typeof cwd !== "string" || cwd.includes("\0")) {
+          throw new Error(
+            "[RI-0002] options.cwd is invalid (empty, non-string, or contains null bytes)."
+          );
+        }
+        if (!isAbsolute(cwd)) {
+          throw new Error(
+            `[RI-0002] options.cwd must be an absolute path, got relative path: "${cwd}".`
+          );
+        }
+        const rawCSS = root.toString();
+        if (rawCSS.length > MAX_DIRECTIVE_INPUT_SIZE) {
+          result.warn(
+            `[RI-1019] CSS input exceeds ${MAX_DIRECTIVE_INPUT_SIZE / 1048576} MB limit (${(rawCSS.length / 1048576).toFixed(1)} MB). Skipping rainbowindex processing.`
+          );
+          return;
+        }
+        const hasActivation = hasRIActivation(rawCSS);
+        if (!hasActivation) {
+          return;
+        }
+        const analysis = analyzeProjectCSS(rawCSS);
+        const compilationWarnings = analysis.warnings;
+        const warningSeen = analysis.warningSeen;
+        const theme = analysis.theme;
+        const sourceOverrides = [];
+        if (options.sources) {
+          for (const s of options.sources) {
+            const err = validateGlobPattern(s);
+            if (err) {
+              pushWarningsDeduped(compilationWarnings, [`[RI-1015] ${err}`], warningSeen);
+              continue;
+            }
+            sourceOverrides.push({ pattern: s, negated: false, inline: false });
+          }
+        }
+        const scannedClasses = await collectProjectClasses(
+          theme.sources,
+          sourceOverrides,
+          cwd,
+          compilationWarnings,
+          warningSeen
+        );
+        const from = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<rainbowindex>";
+        const compiled = await finalizeProjectCompilation({
+          css: rawCSS,
+          classNames: scannedClasses,
+          analysis,
+          // Shared resolver: same fetch-timeout + RI-1213 policy as the CLI and
+          // compileProject, so all surfaces emit identical bytes on slow networks.
+          resolveFonts: resolveGoogleFonts
+        });
+        stripRIDirectiveNodes(root);
+        if (compiled.sections.length > 0) {
+          const generatedRoot = postcss.parse(compiled.sections.join("\n\n"), { from });
+          root.prepend(generatedRoot.nodes);
+        }
+        const slotWarnings = [];
+        warnStandaloneSlots(root, slotWarnings);
+        pushWarningsDeduped(compilationWarnings, slotWarnings, warningSeen);
+        const applyWarnings = [];
+        processApply(root, compiled.theme, applyWarnings, postcss);
+        pushWarningsDeduped(compilationWarnings, applyWarnings, warningSeen);
+        const cssFnWarnings = [];
+        processCSSFunctions(root, compiled.theme, cssFnWarnings);
+        pushWarningsDeduped(compilationWarnings, cssFnWarnings, warningSeen);
+        for (const warning of compilationWarnings) {
+          result.warn(warning);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith("[RI-")) throw err;
+        const sourceFile = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<input>";
+        const location = err && typeof err === "object" && "line" in err ? `:${err.line}${"column" in err ? `:${err.column}` : ""}` : "";
+        const hint = err && typeof err === "object" && "name" in err && err.name === "CssSyntaxError" ? " (CSS syntax error \u2014 check the CSS input near the location above)" : /glob|pattern/i.test(message) ? " (glob/source error \u2014 check your @source patterns and the CWD passed to the plugin)" : "";
+        throw new Error(
+          `[RI-0001] rainbowindex PostCSS plugin failed at ${sourceFile}${location}: ${message}${hint}`,
+          { cause: err }
+        );
+      }
+    }
+  };
+};
+rainbowindex.postcss = true;
+var postcss_default = rainbowindex;
+
+export {
+  postcss_default
+};

package/dist/chunk-PD4ZXGJ6.mjs

@@ -0,0 +1,14 @@
+// src/safelist.ts
+function safelist(...parts) {
+  let out = "";
+  for (const part of parts) {
+    if (!part) continue;
+    if (out) out += " ";
+    out += part;
+  }
+  return out;
+}
+
+export {
+  safelist
+};