rainbowindex 0.6.0 → 0.7.0

package/dist/chunk-L56IRO7A.mjs

@@ -0,0 +1,491 @@
+// src/theme/colors.ts
+function isValidColorSuffix(n) {
+  return Number.isInteger(n) && n >= 1 && n <= 999;
+}
+var STOP_LO = 50;
+var STOP_STEP = 50;
+var L_PROFILE = [
+  0.9668,
+  // 50
+  0.936756,
+  // 100
+  0.905984,
+  // 150
+  0.87442,
+  // 200
+  0.841988,
+  // 250
+  0.808602,
+  // 300
+  0.774158,
+  // 350
+  0.73853,
+  // 400
+  0.701568,
+  // 450
+  0.663082,
+  // 500
+  0.622832,
+  // 550
+  0.580504,
+  // 600
+  0.535677,
+  // 650
+  0.487755,
+  // 700
+  0.435847,
+  // 750
+  0.378506,
+  // 800
+  0.313034,
+  // 850
+  0.232988,
+  // 900
+  0.045
+  // 950
+];
+var REF_CHROMA = 0.05;
+var C_REF = [
+  0.006863863034589374,
+  // 50
+  0.01319862716849036,
+  // 100
+  0.019388384668336325,
+  // 150
+  0.025429811853816625,
+  // 200
+  0.03131716290796655,
+  // 250
+  0.03704281264548738,
+  // 300
+  0.04259815284255128,
+  // 350
+  0.04797259847240491,
+  // 400
+  0.053139652622711774,
+  // 450
+  0.05807254410984486,
+  // 500
+  0.057890440330825195,
+  // 550
+  0.05222950205066024,
+  // 600
+  0.04663166172903349,
+  // 650
+  0.04108661482545571,
+  // 700
+  0.035584106512529856,
+  // 750
+  0.030108630901677546,
+  // 800
+  0.02463007273923548,
+  // 850
+  0.01911062262055484,
+  // 900
+  0.013470720217073236
+  // 950
+];
+var H_DRIFT = [
+  -0.93815866691077,
+  // 50
+  -0.88308454198904,
+  // 100
+  -0.82986570023714,
+  // 150
+  -0.77925524218887,
+  // 200
+  -0.73231968077941,
+  // 250
+  -0.69055370894147,
+  // 300
+  -0.65608113228225,
+  // 350
+  -0.6319804472577,
+  // 400
+  -0.62282301825498,
+  // 450
+  -0.63542113918918,
+  // 500
+  -0.65047025648765,
+  // 550
+  -0.64293938410323,
+  // 600
+  -0.63626978185344,
+  // 650
+  -0.63057786221076,
+  // 700
+  -0.62611168444876,
+  // 750
+  -0.62332854799372,
+  // 800
+  -0.62317507759171,
+  // 850
+  -0.62789446720379,
+  // 900
+  -0.64378251527182
+  // 950
+];
+function sampleProfile(values, suffix, monotone) {
+  const last = values.length - 1;
+  const fx = (suffix - STOP_LO) / STOP_STEP;
+  if (fx <= 0) return values[0] + (values[1] - values[0]) * fx;
+  if (fx >= last) return values[last] + (values[last] - values[last - 1]) * (fx - last);
+  const i = Math.floor(fx);
+  const t = fx - i;
+  if (t === 0) return values[i];
+  const seg = values[i + 1] - values[i];
+  const tangent = (k) => {
+    if (k <= 0) return values[1] - values[0];
+    if (k >= last) return values[last] - values[last - 1];
+    return (values[k + 1] - values[k - 1]) / 2;
+  };
+  let m0 = tangent(i);
+  let m1 = tangent(i + 1);
+  if (monotone) {
+    if (seg === 0) {
+      m0 = 0;
+      m1 = 0;
+    } else {
+      const a = m0 / seg;
+      const b = m1 / seg;
+      const s = a * a + b * b;
+      if (s > 9) {
+        const tau = 3 / Math.sqrt(s);
+        m0 = tau * a * seg;
+        m1 = tau * b * seg;
+      }
+    }
+  }
+  const t2 = t * t;
+  const t3 = t2 * t;
+  return (2 * t3 - 3 * t2 + 1) * values[i] + (t3 - 2 * t2 + t) * m0 + (-2 * t3 + 3 * t2) * values[i + 1] + (t3 - t2) * m1;
+}
+function lightnessFromSuffix(suffix) {
+  return Math.min(0.98, Math.max(0.02, sampleProfile(L_PROFILE, suffix, true)));
+}
+var DEFAULT_COLORS = Object.freeze({
+  theme: {
+    type: "generative",
+    chroma: 0,
+    hue: 0,
+    parabolic: false,
+    chromaBoost: false
+  }
+});
+var DEFAULT_DARK_VARIANT = Object.freeze({ kind: "media" });
+var DEFAULT_DARK_CONFIG = {
+  mode: "auto",
+  // 0 → dark keeps the light stop's chroma exactly (same tone in both modes).
+  // Raise it via `@color dark { chroma-boost }` for punchier dark-mode colors.
+  chromaBoost: 0,
+  hueShift: 0,
+  variant: DEFAULT_DARK_VARIANT
+};
+var GAMUT_CLAMP_ITERATIONS = 20;
+function oklchToOklab(l, c, h) {
+  const hRad = h * Math.PI / 180;
+  return [l, c * Math.cos(hRad), c * Math.sin(hRad)];
+}
+function oklabToLinearSrgb(l, a, b) {
+  const l_ = l + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = l - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = l - 0.0894841775 * a - 1.291485548 * b;
+  const lc = l_ * l_ * l_;
+  const mc = m_ * m_ * m_;
+  const sc = s_ * s_ * s_;
+  const r = 4.0767416621 * lc - 3.3077115913 * mc + 0.2309699292 * sc;
+  const g = -1.2684380046 * lc + 2.6097574011 * mc - 0.3413193965 * sc;
+  const bv = -0.0041960863 * lc - 0.7034186147 * mc + 1.707614701 * sc;
+  return [r, g, bv];
+}
+function isInSrgbGamut(l, c, h) {
+  const [la, a, b] = oklchToOklab(l, c, h);
+  const [r, g, bv] = oklabToLinearSrgb(la, a, b);
+  const eps = 1e-3;
+  return r >= -eps && r <= 1 + eps && g >= -eps && g <= 1 + eps && bv >= -eps && bv <= 1 + eps;
+}
+function gamutSafeChroma(l, requestedChroma, h) {
+  if (requestedChroma <= 0) return 0;
+  if (isInSrgbGamut(l, requestedChroma, h)) return requestedChroma;
+  let lo = 0;
+  let hi = requestedChroma;
+  for (let i = 0; i < GAMUT_CLAMP_ITERATIONS; i++) {
+    const mid = (lo + hi) / 2;
+    if (isInSrgbGamut(l, mid, h)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+    if (hi - lo < 5e-4) break;
+  }
+  return lo;
+}
+var APCA_MAIN_TRC = 2.4;
+var APCA_NORM_BG = 0.56;
+var APCA_NORM_TXT = 0.57;
+var APCA_REV_TXT = 0.62;
+var APCA_REV_BG = 0.65;
+var APCA_BLK_THRS = 0.022;
+var APCA_BLK_CLMP = Math.SQRT2;
+var APCA_SCALE = 1.14;
+var APCA_LO_BOW_OFFSET = 0.027;
+var APCA_LO_WOB_OFFSET = 0.027;
+var APCA_DELTA_Y_MIN = 5e-4;
+var APCA_LO_CLIP = 0.1;
+function linearToSrgb(c) {
+  const x = Math.max(0, Math.min(1, c));
+  return x <= 31308e-7 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055;
+}
+function oklchToApcaY(l, c, h) {
+  const [la, a, b] = oklchToOklab(l, c, h);
+  const [lr, lg, lb] = oklabToLinearSrgb(la, a, b);
+  const r = linearToSrgb(lr);
+  const g = linearToSrgb(lg);
+  const bv = linearToSrgb(lb);
+  return 0.2126 * r ** APCA_MAIN_TRC + 0.7152 * g ** APCA_MAIN_TRC + 0.0722 * bv ** APCA_MAIN_TRC;
+}
+function apcaContrast(yText, yBg) {
+  if (yText < 0 || yBg < 0) return 0;
+  if (Math.max(yText, yBg) < APCA_BLK_THRS) return 0;
+  const txtY = yText < APCA_BLK_THRS ? yText + (APCA_BLK_THRS - yText) ** APCA_BLK_CLMP : yText;
+  const bgY = yBg < APCA_BLK_THRS ? yBg + (APCA_BLK_THRS - yBg) ** APCA_BLK_CLMP : yBg;
+  if (Math.abs(bgY - txtY) < APCA_DELTA_Y_MIN) return 0;
+  if (bgY > txtY) {
+    const sapc2 = (bgY ** APCA_NORM_BG - txtY ** APCA_NORM_TXT) * APCA_SCALE;
+    return sapc2 < APCA_LO_CLIP ? 0 : (sapc2 - APCA_LO_BOW_OFFSET) * 100;
+  }
+  const sapc = (bgY ** APCA_REV_BG - txtY ** APCA_REV_TXT) * APCA_SCALE;
+  return sapc > -APCA_LO_CLIP ? 0 : (sapc + APCA_LO_WOB_OFFSET) * 100;
+}
+var _stopMemo = /* @__PURE__ */ new WeakMap();
+function generateStop(def, suffix) {
+  let bySuffix = _stopMemo.get(def);
+  if (!bySuffix) {
+    bySuffix = /* @__PURE__ */ new Map();
+    _stopMemo.set(def, bySuffix);
+  }
+  const cached = bySuffix.get(suffix);
+  if (cached) return cached;
+  const stop = computeStop(def, suffix);
+  bySuffix.set(suffix, stop);
+  return stop;
+}
+function computeStop(def, suffix) {
+  const roundedL = Math.round(lightnessFromSuffix(suffix) * 1e3) / 1e3;
+  const h = def.chroma > 0 ? def.hue + sampleProfile(H_DRIFT, suffix, false) : def.hue;
+  const roundedH = Math.round(h * 1e3) / 1e3;
+  const shapedChroma = def.parabolic === false ? def.chroma : def.chroma * sampleProfile(C_REF, suffix, false) / REF_CHROMA;
+  const safeC = gamutSafeChroma(roundedL, shapedChroma, roundedH);
+  const roundedC = Math.floor(safeC * 1e4) / 1e4;
+  return {
+    stop: suffix,
+    l: roundedL,
+    c: roundedC,
+    h: roundedH
+  };
+}
+function computeDarkStop(def, suffix, darkConfig, darkOverride) {
+  const lightStop = generateStop(def, suffix);
+  const darkL = generateStop(def, 1e3 - suffix).l;
+  let extraChroma = 0;
+  let extraHue = 0;
+  if (darkOverride?.strategy === "shift") {
+    extraChroma = darkOverride.chromaDelta;
+    extraHue = darkOverride.hueDelta;
+  }
+  const darkH = lightStop.h + darkConfig.hueShift + extraHue;
+  const globalChromaBoost = def.chromaBoost !== false ? darkConfig.chromaBoost : 0;
+  const requestedChroma = lightStop.c + globalChromaBoost + extraChroma;
+  const darkC = Math.floor(gamutSafeChroma(darkL, requestedChroma, darkH) * 1e4) / 1e4;
+  return { stop: suffix, l: darkL, c: darkC, h: darkH };
+}
+function formatOklch(l, c, h) {
+  return `oklch(${l} ${c} ${h})`;
+}
+function generateColorVariables(name, def, suffixes, darkConfig = DEFAULT_DARK_CONFIG, darkOverride) {
+  const vars = [];
+  const strategy = darkOverride?.strategy ?? "mirror";
+  for (const suffix of suffixes) {
+    const lightStop = generateStop(def, suffix);
+    const lightValue = formatOklch(lightStop.l, lightStop.c, lightStop.h);
+    if (darkConfig.mode === "off" || strategy === "fixed") {
+      if (darkConfig.mode === "off") {
+        vars.push(`--color-${name}-${suffix}: ${lightValue};`);
+      } else {
+        vars.push(`--color-${name}-${suffix}: light-dark(${lightValue}, ${lightValue});`);
+      }
+    } else {
+      const darkStop = computeDarkStop(def, suffix, darkConfig, darkOverride);
+      const darkValue = formatOklch(darkStop.l, darkStop.c, darkStop.h);
+      vars.push(`--color-${name}-${suffix}: light-dark(${lightValue}, ${darkValue});`);
+    }
+  }
+  return vars;
+}
+var SEMANTIC_COLORS = Object.freeze([
+  "--color-paper: light-dark(oklch(1 0 0), oklch(0 0 0));",
+  "--color-ink: light-dark(oklch(0 0 0), oklch(1 0 0));"
+]);
+var DEFAULT_PALETTE_CONTRAST_LC = 60;
+function checkPaletteContrast(colors, usedColorStops, options = {}) {
+  const minLc = options.minLc ?? DEFAULT_PALETTE_CONTRAST_LC;
+  const warnings = [];
+  const paperY = oklchToApcaY(1, 0, 0);
+  const inkY = oklchToApcaY(0, 0, 0);
+  for (const [name, def] of Object.entries(colors)) {
+    if (def.type !== "generative") continue;
+    const stops = usedColorStops.get(name);
+    if (!stops || stops.size === 0) continue;
+    const sorted = [...stops].sort((a, b) => a - b);
+    for (const suffix of sorted) {
+      const stop = generateStop(def, suffix);
+      const fgY = oklchToApcaY(stop.l, stop.c, stop.h);
+      const lcPaper = Math.abs(apcaContrast(fgY, paperY));
+      const lcInk = Math.abs(apcaContrast(fgY, inkY));
+      const best = Math.max(lcPaper, lcInk);
+      if (best < minLc) {
+        warnings.push(
+          `[RI-1106] @color "${name}-${suffix}" has low APCA contrast (best |Lc| ${best.toFixed(0)} < ${minLc}; paper ${lcPaper.toFixed(0)}, ink ${lcInk.toFixed(0)}). Stop is unsuitable as text on either --color-paper or --color-ink \u2014 use a darker (lower suffix) or lighter (higher suffix) variant for text roles.`
+        );
+      }
+    }
+  }
+  return warnings;
+}
+function resolveAliasTarget(colors, source) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = source;
+  while (!visited.has(current)) {
+    visited.add(current);
+    const def = colors[current];
+    if (!def) return null;
+    if (def.type !== "alias") return { name: current, def };
+    current = def.source;
+  }
+  return null;
+}
+function generateAllColorVariables(colors = DEFAULT_COLORS, darkConfig = DEFAULT_DARK_CONFIG, usedColorStops, usedColorNames) {
+  const allVars = [];
+  allVars.push(...SEMANTIC_COLORS);
+  for (const [name, def] of Object.entries(colors)) {
+    switch (def.type) {
+      case "generative": {
+        const suffixes = usedColorStops?.get(name);
+        if (!suffixes || suffixes.size === 0) break;
+        const sorted = [...suffixes].sort((a, b) => a - b);
+        allVars.push(...generateColorVariables(name, def, sorted, darkConfig, def.dark));
+        break;
+      }
+      case "explicit": {
+        if (usedColorNames && !usedColorNames.has(name)) break;
+        allVars.push(`--color-${name}: ${def.value};`);
+        break;
+      }
+      case "pair": {
+        if (usedColorNames && !usedColorNames.has(name)) break;
+        if (darkConfig.mode === "off") {
+          allVars.push(`--color-${name}: ${def.light};`);
+        } else {
+          allVars.push(`--color-${name}: light-dark(${def.light}, ${def.dark});`);
+        }
+        break;
+      }
+      case "alias": {
+        const target = resolveAliasTarget(colors, def.source);
+        if (target === null) break;
+        if (target.def.type === "generative") {
+          const suffixes = usedColorStops?.get(name);
+          if (!suffixes || suffixes.size === 0) break;
+          const sorted = [...suffixes].sort((a, b) => a - b);
+          for (const suffix of sorted) {
+            allVars.push(`--color-${name}-${suffix}: var(--color-${def.source}-${suffix});`);
+          }
+        } else if (target.def.type === "keyword") {
+          if (usedColorNames && !usedColorNames.has(name)) break;
+          allVars.push(`--color-${name}: ${target.def.value};`);
+        } else {
+          if (usedColorNames && !usedColorNames.has(name)) break;
+          allVars.push(`--color-${name}: var(--color-${def.source});`);
+        }
+        break;
+      }
+    }
+  }
+  return allVars;
+}
+function generateThemeOverrides(colors, usedThemeSuffixes) {
+  if (!Object.hasOwn(colors, "theme")) return [];
+  if (!usedThemeSuffixes || usedThemeSuffixes.size === 0) return [];
+  const sorted = [...usedThemeSuffixes].sort((a, b) => a - b);
+  const blocks = [];
+  for (const [name, def] of Object.entries(colors)) {
+    if (name === "theme") continue;
+    if (def.type !== "generative") continue;
+    if (!def.inline) continue;
+    const vars = [];
+    for (const suffix of sorted) {
+      vars.push(`  --color-theme-${suffix}: var(--color-${name}-${suffix});`);
+    }
+    const safeName = name.replace(/[\\"'\]]/g, "");
+    if (!safeName) continue;
+    blocks.push(`[data-theme="${safeName}"] {
+${vars.join("\n")}
+}`);
+  }
+  return blocks;
+}
+
+// src/theme/index.ts
+var CORNER_SHAPE_KEYWORDS = [
+  "round",
+  "scoop",
+  "bevel",
+  "notch",
+  "square",
+  "squircle"
+];
+var DEFAULT_CORNER_SCALE = {
+  round: 1,
+  square: 1,
+  notch: 1,
+  bevel: 0.8,
+  scoop: 1.2,
+  squircle: 1.6
+};
+var DEFAULT_SUPERELLIPSE_SCALE = 1.6;
+var defaultTheme = Object.freeze({
+  spacing: {
+    base: "0.25rem"
+  },
+  colors: DEFAULT_COLORS,
+  // Every named scale below ships empty: the tokens come from @text,
+  // @breakpoint, @shadow, @weight, @ease, @animate and @blur. @fluid carries
+  // no viewport range until one is declared, so fluid utilities stay inert.
+  text: {},
+  breakpoints: {},
+  shadows: {},
+  weights: {},
+  easing: {},
+  fluid: {},
+  animations: {},
+  blur: {}
+});
+
+export {
+  isValidColorSuffix,
+  DEFAULT_COLORS,
+  DEFAULT_DARK_CONFIG,
+  oklchToOklab,
+  oklabToLinearSrgb,
+  linearToSrgb,
+  generateStop,
+  computeDarkStop,
+  formatOklch,
+  checkPaletteContrast,
+  generateAllColorVariables,
+  generateThemeOverrides,
+  CORNER_SHAPE_KEYWORDS,
+  DEFAULT_CORNER_SCALE,
+  DEFAULT_SUPERELLIPSE_SCALE,
+  defaultTheme
+};

package/dist/chunk-PZDVDEZJ.mjs

@@ -0,0 +1,196 @@
+import {
+  createClassInspector,
+  enumerateClassNames,
+  listThemeTokens,
+  resolveColorSwatch
+} from "./chunk-WBESS2ZD.mjs";
+import {
+  analyzeProjectCSS,
+  assembleSections,
+  codepointCompare,
+  compileCSSFunctions,
+  createCompiler,
+  createThemeSnapshot,
+  diagnosticFromWarning,
+  extractClassCandidates,
+  hasCSSFunctions,
+  inlineDirectiveImports,
+  scanCSSForTokenUsage,
+  stripRIDirectives
+} from "./chunk-FJOZJIKB.mjs";
+import {
+  mergeUncached,
+  resolverFor
+} from "./chunk-XQGSG2HK.mjs";
+
+// src/merge/analyze.ts
+function analyzeMerge(classes, snapshot) {
+  const resolve = resolverFor(snapshot);
+  const trace = { claimers: /* @__PURE__ */ new Map(), dropped: [] };
+  const output = mergeUncached(classes, resolve, trace);
+  trace.dropped.sort((a, b) => a.index - b.index);
+  const droppedIndexes = new Set(trace.dropped.map((d) => d.index));
+  const kept = [];
+  for (let i = 0; i < classes.length; i++) {
+    if (!droppedIndexes.has(i)) kept.push(i);
+  }
+  return {
+    output,
+    kept,
+    dropped: trace.dropped.map((d) => ({
+      index: d.index,
+      className: classes[d.index],
+      overriddenBy: d.overriddenBy
+    }))
+  };
+}
+
+// src/editor/render.ts
+function renderStylesheet(theme, classNames, options = {}) {
+  const compiler = createCompiler();
+  const compilation = compiler.compile([...classNames], theme, options.authoredClassNames);
+  const warnings = [];
+  let userCSS = options.userCSS ?? "";
+  if (userCSS && hasCSSFunctions(userCSS)) {
+    userCSS = compileCSSFunctions(userCSS, theme, warnings);
+  }
+  if (userCSS) scanCSSForTokenUsage(userCSS, compilation);
+  const assembled = assembleSections(compilation, theme, compiler.fontOutputCache);
+  warnings.push(...assembled.warnings, ...compilation.warnings);
+  const sections = assembled.sections;
+  return {
+    css: userCSS ? [...sections, userCSS].join("\n\n") : sections.join("\n\n"),
+    sections,
+    userCSS,
+    warnings
+  };
+}
+
+// src/editor/sort.ts
+function sortClassesWithInspector(inspector, classes) {
+  const unknown = [];
+  const known = [];
+  for (const className of classes) {
+    const explanation = inspector.explain(className);
+    if (explanation === null) {
+      unknown.push(className);
+      continue;
+    }
+    known.push({ className, sortKey: explanation.sortKey, selector: explanation.selector });
+  }
+  known.sort((a, b) => a.sortKey - b.sortKey || codepointCompare(a.selector, b.selector));
+  const out = unknown;
+  for (const entry of known) out.push(entry.className);
+  return out;
+}
+var inspectorMemo = /* @__PURE__ */ new WeakMap();
+function sortClasses(theme, classes) {
+  let inspector = inspectorMemo.get(theme);
+  if (inspector === void 0) {
+    inspector = createClassInspector(theme);
+    inspectorMemo.set(theme, inspector);
+  }
+  return sortClassesWithInspector(inspector, classes);
+}
+
+// src/editor/session.ts
+function createEditorSession(options = {}) {
+  let css = options.css ?? "";
+  let analysis = null;
+  let inspector = null;
+  let enumeration = null;
+  let tokens = null;
+  let snapshot = null;
+  let importedFiles = [];
+  let effectiveCss = "";
+  const ensureAnalysis = () => {
+    if (analysis === null) {
+      const resolve = options.resolveImport;
+      if (resolve === void 0) {
+        importedFiles = [];
+        effectiveCss = css;
+        analysis = analyzeProjectCSS(css);
+      } else {
+        const inlined = inlineDirectiveImports(css, { resolve, from: options.cssPath });
+        importedFiles = inlined.files;
+        effectiveCss = inlined.css;
+        analysis = analyzeProjectCSS(inlined.css);
+        for (const warning of inlined.warnings) {
+          if (analysis.warningSeen.has(warning)) continue;
+          analysis.warningSeen.add(warning);
+          analysis.warnings.push(warning);
+          analysis.diagnostics.push(diagnosticFromWarning(warning, null));
+        }
+      }
+    }
+    return analysis;
+  };
+  const ensureSnapshot = () => {
+    snapshot ??= createThemeSnapshot(ensureAnalysis().theme);
+    return snapshot;
+  };
+  return {
+    get css() {
+      return css;
+    },
+    setCss(next) {
+      if (next === css) return;
+      css = next;
+      analysis = null;
+      inspector = null;
+      enumeration = null;
+      tokens = null;
+      snapshot = null;
+    },
+    get theme() {
+      return ensureAnalysis().theme;
+    },
+    get diagnostics() {
+      return ensureAnalysis().diagnostics;
+    },
+    get inspector() {
+      inspector ??= createClassInspector(ensureAnalysis().theme);
+      return inspector;
+    },
+    enumerate() {
+      enumeration ??= enumerateClassNames(ensureAnalysis().theme);
+      return enumeration;
+    },
+    tokens() {
+      tokens ??= listThemeTokens(ensureAnalysis().theme);
+      return tokens;
+    },
+    snapshot: ensureSnapshot,
+    analyzeMerge(classes) {
+      return analyzeMerge(classes, ensureSnapshot());
+    },
+    get importedFiles() {
+      ensureAnalysis();
+      return importedFiles;
+    },
+    extractCandidates(content, path) {
+      return extractClassCandidates({ content, path });
+    },
+    swatch(name, stop) {
+      return resolveColorSwatch(ensureAnalysis().theme, name, stop);
+    },
+    sortClasses(classNames) {
+      inspector ??= createClassInspector(ensureAnalysis().theme);
+      return sortClassesWithInspector(inspector, classNames);
+    },
+    render(classNames, renderOptions = {}) {
+      const theme = ensureAnalysis().theme;
+      return renderStylesheet(theme, classNames, {
+        ...renderOptions,
+        userCSS: renderOptions.userCSS ?? stripRIDirectives(effectiveCss)
+      });
+    }
+  };
+}
+
+export {
+  analyzeMerge,
+  renderStylesheet,
+  sortClasses,
+  createEditorSession
+};