@motion-proto/live-tokens 0.94.3 → 0.95.0

package/dist-plugin/index.cjs

@@ -2043,6 +2043,28 @@ var colorsAndTypeMigration_2026_09_21_washColorAndOpacity = {
   }
 };
 
+// src/editor/core/themes/migrations/2026-10-15-responsive-columns.ts
+var RENAMES8 = {
+  "--columns-gutter": "--columns-desktop-gutter",
+  "--columns-margin": "--columns-desktop-margin"
+};
+var SHIPPED = {
+  "--columns-count": ["12"],
+  "--columns-gutter": ["32px"],
+  "--columns-margin": ["0px", "0"]
+};
+var colorsAndTypeMigration_2026_10_15_responsiveColumns = {
+  id: "2026-10-15-responsive-columns",
+  fromVersion: 9,
+  toVersion: 10,
+  appliesTo: "colors-and-type",
+  apply(rawVars) {
+    return Object.fromEntries(
+      Object.entries(rawVars).filter(([name, value]) => !SHIPPED[name]?.includes(value.trim())).map(([name, value]) => [RENAMES8[name] ?? name, value])
+    );
+  }
+};
+
 // src/editor/core/themes/migrations/2026-09-21-scrim-surface.ts
 var STOPS2 = {
   "--scrim-opacity-low": "--scrim-low",
@@ -2081,7 +2103,7 @@ var componentMigration_2026_09_21_scrimSurface = {
 };
 
 // src/editor/core/themes/migrations/2026-09-13-cornerbadge-prefix.ts
-var RENAMES8 = {
+var RENAMES9 = {
   cornerbadge: {
     "--corner-badge-margin": "--cornerbadge-margin",
     "--corner-badge-outer-radius": "--cornerbadge-outer-radius",
@@ -2131,7 +2153,7 @@ var componentMigration_2026_09_13_cornerbadgePrefix = {
   toVersion: 32,
   appliesTo: "component-config",
   apply(rawVars, meta) {
-    const renames = meta.component ? RENAMES8[meta.component] : void 0;
+    const renames = meta.component ? RENAMES9[meta.component] : void 0;
     if (!renames) return { ...rawVars };
     const out = {};
     for (const [key, value] of Object.entries(rawVars)) {
@@ -2142,7 +2164,7 @@ var componentMigration_2026_09_13_cornerbadgePrefix = {
 };
 
 // src/editor/core/themes/migrations/2026-09-13-toggle-label.ts
-var RENAMES9 = {
+var RENAMES10 = {
   toggle: {
     "--toggle-label-text": "--toggle-label",
     "--toggle-disabled-label-text": "--toggle-disabled-label"
@@ -2154,7 +2176,7 @@ var componentMigration_2026_09_13_toggleLabel = {
   toVersion: 33,
   appliesTo: "component-config",
   apply(rawVars, meta) {
-    const renames = meta.component ? RENAMES9[meta.component] : void 0;
+    const renames = meta.component ? RENAMES10[meta.component] : void 0;
     if (!renames) return { ...rawVars };
     const out = {};
     for (const [key, value] of Object.entries(rawVars)) {
@@ -2165,7 +2187,7 @@ var componentMigration_2026_09_13_toggleLabel = {
 };
 
 // src/editor/core/themes/migrations/2026-09-13-collapsiblesection-open.ts
-var RENAMES10 = {
+var RENAMES11 = {
   collapsiblesection: {
     "--collapsiblesection-chromeless-expanded-padding": "--collapsiblesection-chromeless-open-padding",
     "--collapsiblesection-hairline-expanded-padding": "--collapsiblesection-hairline-open-padding",
@@ -2179,7 +2201,7 @@ var componentMigration_2026_09_13_collapsiblesectionOpen = {
   toVersion: 34,
   appliesTo: "component-config",
   apply(rawVars, meta) {
-    const renames = meta.component ? RENAMES10[meta.component] : void 0;
+    const renames = meta.component ? RENAMES11[meta.component] : void 0;
     if (!renames) return { ...rawVars };
     const out = {};
     for (const [key, value] of Object.entries(rawVars)) {
@@ -2206,7 +2228,7 @@ var BADGE_SUFFIXES = [
   "icon-size"
 ];
 var CORNERBADGE_SUFFIXES = ["surface", "border", "text"];
-var RENAMES11 = {
+var RENAMES12 = {
   badge: Object.fromEntries(
     BADGE_SUFFIXES.map((s) => [`--badge-primary-${s}`, `--badge-brand-${s}`])
   ),
@@ -2220,7 +2242,7 @@ var componentMigration_2026_09_13_badgeBrand = {
   toVersion: 35,
   appliesTo: "component-config",
   apply(rawVars, meta) {
-    const renames = meta.component ? RENAMES11[meta.component] : void 0;
+    const renames = meta.component ? RENAMES12[meta.component] : void 0;
     if (!renames) return { ...rawVars };
     const out = {};
     for (const [key, value] of Object.entries(rawVars)) {
@@ -2278,7 +2300,8 @@ var MIGRATIONS = [
   componentMigration_2026_09_20_imagelightboxScrim,
   componentMigration_2026_09_20_scrimColorAndOpacity,
   colorsAndTypeMigration_2026_09_21_washColorAndOpacity,
-  componentMigration_2026_09_21_scrimSurface
+  componentMigration_2026_09_21_scrimSurface,
+  colorsAndTypeMigration_2026_10_15_responsiveColumns
 ];
 function countFor(kind) {
   return MIGRATIONS.filter((m) => m.appliesTo === kind).length;
@@ -3561,7 +3584,7 @@ function setTokenValue(css, name, value, opts = {}) {
   }
   return changed ? lines.join("\n") : css;
 }
-function appendMediaBlock(css, query, entries) {
+function appendMediaBlock(css, query, entries, opts = {}) {
   const lines = css.split("\n");
   const at = query.trim();
   const blocks = findTopLevelBlocks(lines, (line) => mediaQueryOf(line) === at);
@@ -3573,6 +3596,12 @@ function appendMediaBlock(css, query, entries) {
   const media = blocks.find((b) => b.end > b.start);
   if (!media) {
     const block = [`@media ${at} {`, "  :root {", ...declarationLines(missing, "    "), "  }", "}", ""];
+    const before = opts.before?.trim();
+    const next = before === void 0 ? void 0 : findTopLevelBlocks(lines, (line) => mediaQueryOf(line) === before)[0];
+    if (next) {
+      lines.splice(next.start, 0, ...block);
+      return lines.join("\n");
+    }
     while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
     return [...lines, "", ...block].join("\n");
   }
@@ -3818,7 +3847,7 @@ var tokensCssMigration_2026_06_04_easingColorAndTypescaleAdditions = {
 };
 
 // vite-plugin/tokensCssMigrations/migrations/2026-07-20-line-height-rename.ts
-var RENAMES12 = [
+var RENAMES13 = [
   ["--line-height-xs", "--line-height-none"],
   ["--line-height-sm", "--line-height-tighter"],
   ["--line-height-md", "--line-height-normal"],
@@ -3838,7 +3867,7 @@ var tokensCssMigration_2026_07_20_lineHeightRename = {
   description: "Reshape --line-height-{xs..xl} to leading vocabulary (none/tightest/tighter/tight/normal/relaxed); retire the 2.0 slot",
   apply(css) {
     let out = css;
-    for (const [oldName, newName] of RENAMES12) out = renameToken2(out, oldName, newName);
+    for (const [oldName, newName] of RENAMES13) out = renameToken2(out, oldName, newName);
     out = removeToken(out, "--line-height-xl");
     out = ensureScale(out, {
       anchorPrefixes: ["--line-height-", "--font-size-", "--font-weight-", "--font-"],
@@ -4072,7 +4101,7 @@ var tokensCssMigration_2026_08_27_editorialLargeSteps = {
 };
 
 // vite-plugin/tokensCssMigrations/migrations/2026-09-01-scrim-rename.ts
-var RENAMES13 = [
+var RENAMES14 = [
   ["--overlay-low", "--scrim-low"],
   ["--overlay-high", "--scrim-high"],
   ["--overlay", "--scrim"]
@@ -4083,7 +4112,7 @@ var tokensCssMigration_2026_09_01_scrimRename = {
   description: "Rename --overlay-{low,base,high} to --scrim-*; a scrim dims what is behind it",
   apply(css) {
     let out = css;
-    for (const [oldName, newName] of RENAMES13) out = renameToken2(out, oldName, newName);
+    for (const [oldName, newName] of RENAMES14) out = renameToken2(out, oldName, newName);
     return out;
   }
 };
@@ -4148,7 +4177,7 @@ var tokensCssMigration_2026_09_21_tintColorAndOpacity = {
 };
 
 // vite-plugin/tokensCssMigrations/migrations/2026-10-08-type-scales.ts
-var RENAMES14 = [
+var RENAMES15 = [
   ["--code-font-size", "--code-md-font-size"],
   ["--code-line-height", "--code-md-line-height"],
   ["--code-letter-spacing", "--code-md-letter-spacing"]
@@ -4912,7 +4941,7 @@ var tokensCssMigration_2026_10_08_typeScales = {
   description: "Rebuild the text styles as five type scales with per-viewport sizes, and rename --code-font-size, --code-line-height and --code-letter-spacing to --code-md-*",
   apply(css) {
     let out = css;
-    for (const [from, to] of RENAMES14) out = renameToken2(out, from, to);
+    for (const [from, to] of RENAMES15) out = renameToken2(out, from, to);
     const values = collectTokenValues(out);
     for (const step of [...CARRIED, ...handDeclaredSteps(values)]) {
       const size = values.get(`${step.prefix}-font-size`);
@@ -4961,6 +4990,50 @@ var tokensCssMigration_2026_10_08_typeScales = {
   }
 };
 
+// vite-plugin/tokensCssMigrations/migrations/2026-10-15-responsive-columns.ts
+var DESKTOP = [
+  {
+    structural: "--columns-gutter",
+    desktop: "--columns-desktop-gutter",
+    shipped: "clamp(0.5rem, 1.5vw, 1.5rem)",
+    value: "32px"
+  },
+  { structural: "--columns-margin", desktop: "--columns-desktop-margin", shipped: "0", value: "32px" }
+];
+var SMALLER = [
+  { name: "--columns-tablet-gutter", value: "24px" },
+  { name: "--columns-tablet-margin", value: "24px" },
+  { name: "--columns-phone-gutter", value: "16px" },
+  { name: "--columns-phone-margin", value: "16px" }
+];
+var repoints = (viewport) => DESKTOP.map(({ structural }) => ({
+  name: structural,
+  value: `var(${structural.replace("--columns-", `--columns-${viewport}-`)})`
+}));
+var tokensCssMigration_2026_10_15_responsiveColumns = {
+  id: "2026-10-15-responsive-columns",
+  kind: "breaking",
+  description: "Give the column grid a gutter and margin per viewport, and re-point --columns-gutter and --columns-margin at them",
+  apply(css) {
+    const values = collectTokenValues(css);
+    const pending = DESKTOP.filter(({ desktop }) => !values.has(desktop));
+    let out = ensureScale(css, {
+      anchorPrefixes: ["--columns-"],
+      entries: [
+        ...pending.map(({ structural, desktop, shipped, value }) => {
+          const current = values.get(structural);
+          return { name: desktop, value: current === void 0 || current === shipped ? value : current };
+        }),
+        ...SMALLER
+      ]
+    });
+    for (const { structural, desktop } of pending) out = setTokenValue(out, structural, `var(${desktop})`);
+    out = ensureScale(out, { anchorPrefixes: ["--columns-"], entries: repoints("desktop") });
+    out = appendMediaBlock(out, "(max-width: 767px)", repoints("tablet"), { before: "(max-width: 480px)" });
+    return appendMediaBlock(out, "(max-width: 480px)", repoints("phone"));
+  }
+};
+
 // vite-plugin/tokensCssMigrations/index.ts
 var TOKENS_CSS_MIGRATIONS = [
   tokensCssMigration_2026_05_29_typographyScaleAdditions,
@@ -4980,7 +5053,8 @@ var TOKENS_CSS_MIGRATIONS = [
   tokensCssMigration_2026_09_01_tintScale,
   tokensCssMigration_2026_09_20_scrimColorAndOpacity,
   tokensCssMigration_2026_09_21_tintColorAndOpacity,
-  tokensCssMigration_2026_10_08_typeScales
+  tokensCssMigration_2026_10_08_typeScales,
+  tokensCssMigration_2026_10_15_responsiveColumns
 ];
 function runTokensCssMigrations(css) {
   return foldMigrations(css, () => true);
@@ -5049,6 +5123,502 @@ async function checkBeforeBuild({
   return null;
 }
 
+// vite-plugin/productionCss/index.ts
+var import_node_crypto = require("crypto");
+
+// vite-plugin/productionCss/analyze.ts
+var import_postcss = __toESM(require("postcss"), 1);
+var ROOT_SPECIFICITY = /* @__PURE__ */ new Map([
+  [":root", [0, 1, 0]],
+  [":root:root", [0, 2, 0]],
+  [":where(:root)", [0, 0, 0]],
+  ["html", [0, 0, 1]]
+]);
+var NAME = String.raw`--(?:[\w-]|[^\x00-\x7f])+`;
+var VAR_REF = new RegExp(String.raw`var\(\s*(${NAME})`, "gi");
+var PRELUDE_NAME = new RegExp(NAME, "g");
+var SCRIPT_NAME = new RegExp(String.raw`(?<![\w-])${NAME}`, "g");
+var CSS_WIDE_KEYWORD = /^\s*(?:initial|inherit|unset|revert|revert-layer)\s*$/i;
+var varRefs = (value) => [...value.matchAll(VAR_REF)].map((m) => m[1]);
+function compareSpecificity(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+function rootSpecificity(selector) {
+  let best = null;
+  for (const part of selector.split(",")) {
+    const specificity = ROOT_SPECIFICITY.get(part.trim());
+    if (!specificity) return null;
+    if (!best || compareSpecificity(specificity, best) > 0) best = specificity;
+  }
+  return best;
+}
+function outranks(a, b) {
+  if (a.important !== b.important) return a.important;
+  const bySpecificity = compareSpecificity(a.specificity, b.specificity);
+  if (bySpecificity !== 0) return bySpecificity > 0;
+  return a.asset !== b.asset ? a.asset > b.asset : a.order > b.order;
+}
+function winnerOf(declarations) {
+  let winner = null;
+  for (const d of declarations) if (d.bare && (!winner || outranks(d, winner))) winner = d;
+  return winner;
+}
+function analyze({ css, js, html, keep, entries }) {
+  const declarations = /* @__PURE__ */ new Map();
+  const regularRefs = /* @__PURE__ */ new Set();
+  const preludeNames = /* @__PURE__ */ new Set();
+  const registered = /* @__PURE__ */ new Set();
+  const reads = css.map(() => /* @__PURE__ */ new Set());
+  css.forEach((source, asset) => {
+    let order = 0;
+    import_postcss.default.parse(source).walk((node) => {
+      if (node.type === "atrule") {
+        if (node.name.toLowerCase() === "property") registered.add(node.params.trim());
+        for (const [name] of node.params.matchAll(PRELUDE_NAME)) preludeNames.add(name);
+        return;
+      }
+      if (node.type !== "decl") return;
+      const refs = varRefs(node.value);
+      for (const name of refs) reads[asset].add(name);
+      if (!node.prop.startsWith("--")) {
+        for (const name of refs) regularRefs.add(name);
+        return;
+      }
+      let selector = null;
+      let outerRule = false;
+      const atRules = [];
+      for (let p = node.parent; p && p.type !== "root"; p = p.parent) {
+        if (p.type === "atrule") {
+          const at = p;
+          atRules.unshift(`@${at.name} ${at.params}`.trim());
+        } else if (p.type === "rule") {
+          if (selector === null) selector = p.selector;
+          else outerRule = true;
+        }
+      }
+      const specificity = selector === null ? null : rootSpecificity(selector);
+      const declaration = {
+        asset,
+        order: order++,
+        selector,
+        atRules,
+        value: node.value,
+        important: node.important,
+        root: specificity !== null,
+        bare: specificity !== null && atRules.length === 0 && !outerRule,
+        specificity
+      };
+      const list = declarations.get(node.prop);
+      if (list) list.push(declaration);
+      else declarations.set(node.prop, [declaration]);
+    });
+  });
+  const scriptNames = /* @__PURE__ */ new Set();
+  for (const text2 of [...js, ...html]) {
+    for (const [name] of text2.matchAll(SCRIPT_NAME)) scriptNames.add(name);
+  }
+  const keepNames = new Set(keep);
+  const references = /* @__PURE__ */ new Map();
+  for (const [name, decls] of declarations) {
+    references.set(name, new Set(decls.flatMap((d) => varRefs(d.value))));
+  }
+  const reached = /* @__PURE__ */ new Set();
+  const toReach = [...regularRefs, ...preludeNames, ...scriptNames, ...keepNames];
+  while (toReach.length) {
+    const name = toReach.pop();
+    if (reached.has(name)) continue;
+    reached.add(name);
+    for (const ref2 of references.get(name) ?? []) toReach.push(ref2);
+  }
+  const loops = /* @__PURE__ */ new Map();
+  const reachesCycle = (name) => {
+    const state = loops.get(name);
+    if (state !== void 0) return state !== false;
+    loops.set(name, "visiting");
+    let result2 = false;
+    for (const ref2 of references.get(name) ?? []) {
+      if (declarations.has(ref2) && reachesCycle(ref2)) result2 = true;
+    }
+    loops.set(name, result2);
+    return result2;
+  };
+  const setByName = (name) => scriptNames.has(name) || keepNames.has(name) || registered.has(name);
+  const entryAssets = new Set(entries);
+  const winners = /* @__PURE__ */ new Map();
+  const reasons = /* @__PURE__ */ new Map();
+  for (const [name, decls] of declarations) {
+    const winner = winnerOf(decls);
+    winners.set(name, winner);
+    const bare = decls.filter((d) => d.bare);
+    const why = [];
+    if (decls.some((d) => !d.bare)) why.push("scoped");
+    if (scriptNames.has(name)) why.push("script");
+    if (preludeNames.has(name)) why.push("prelude");
+    if (registered.has(name)) why.push("registered");
+    if (keepNames.has(name)) why.push("keep");
+    if (winner && CSS_WIDE_KEYWORD.test(winner.value)) why.push("keyword");
+    if (reachesCycle(name)) why.push("cycle");
+    if (new Set(bare.map((d) => d.asset)).size > 1 && new Set(bare.map((d) => d.value)).size > 1) {
+      why.push("assets");
+    }
+    if ([...references.get(name)].some((ref2) => !declarations.has(ref2) && !setByName(ref2))) why.push("undeclared");
+    const declaring = new Set(decls.map((d) => d.asset));
+    if (![...declaring].some((asset) => entryAssets.has(asset)) && reads.some((names, asset) => !declaring.has(asset) && names.has(name))) {
+      why.push("lazy");
+    }
+    reasons.set(name, why);
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  for (const [name, refs] of references) {
+    for (const ref2 of refs) {
+      const list = dependents.get(ref2);
+      if (list) list.push(name);
+      else dependents.set(ref2, [name]);
+    }
+  }
+  const dynamic = /* @__PURE__ */ new Set();
+  const toSpread = [
+    ...[...reasons].filter(([, why]) => why.length > 0).map(([name]) => name),
+    ...scriptNames,
+    ...keepNames,
+    ...registered
+  ];
+  while (toSpread.length) {
+    const name = toSpread.pop();
+    if (dynamic.has(name)) continue;
+    dynamic.add(name);
+    for (const dependent of dependents.get(name) ?? []) toSpread.push(dependent);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, decls] of declarations) {
+    const refs = [...references.get(name)];
+    const why = reasons.get(name);
+    if (refs.some((ref2) => dynamic.has(ref2))) why.push("reference");
+    result.set(name, {
+      declarations: decls,
+      references: refs,
+      reached: reached.has(name),
+      dynamic: why.length > 0,
+      reasons: why,
+      winner: winners.get(name)
+    });
+  }
+  return result;
+}
+
+// vite-plugin/productionCss/rewrite.ts
+var import_postcss2 = __toESM(require("postcss"), 1);
+var TOKEN_BEFORE_FUNCTION = /[\w\-#@\\]|[^\x00-\x7f]/;
+var VAR_NAME = /^\s*(--(?:[\w-]|[^\x00-\x7f])+)\s*(?:,|$)/;
+var JOINS_LEFT = /[\w\-#@.+\\]|[^\x00-\x7f]/;
+var JOINS_RIGHT = /[\w\-.+%(\\]|[^\x00-\x7f]/;
+var EMPTIED_AT_RULES = /* @__PURE__ */ new Set(["media", "supports", "container"]);
+var DESCRIPTOR_AT_RULES = /* @__PURE__ */ new Set(["font-face", "property", "counter-style", "font-palette-values"]);
+function skipString(value, start) {
+  const quote = value[start];
+  let i = start + 1;
+  while (i < value.length && value[i] !== quote) i += value[i] === "\\" ? 2 : 1;
+  return i + 1;
+}
+function skipComment(value, start) {
+  const end = value.indexOf("*/", start + 2);
+  return end < 0 ? value.length : end + 2;
+}
+function closingParen(value, open) {
+  let depth = 0;
+  let i = open;
+  while (i < value.length) {
+    const c = value[i];
+    if (c === '"' || c === "'") i = skipString(value, i);
+    else if (c === "/" && value[i + 1] === "*") i = skipComment(value, i);
+    else {
+      if (c === "\\") i += 1;
+      else if (c === "(") depth += 1;
+      else if (c === ")" && --depth === 0) return i;
+      i += 1;
+    }
+  }
+  return -1;
+}
+function afterUrl(value, start) {
+  let i = start;
+  while (/\s/.test(value[i] ?? "")) i += 1;
+  if (value[i] === '"' || value[i] === "'") {
+    const close = closingParen(value, start - 1);
+    return close < 0 ? value.length : close + 1;
+  }
+  while (i < value.length && value[i] !== ")") i += value[i] === "\\" ? 2 : 1;
+  return i + 1;
+}
+function functionAt(value, i, name) {
+  return value.slice(i, i + name.length).toLowerCase() === name && (i === 0 || !TOKEN_BEFORE_FUNCTION.test(value[i - 1]));
+}
+function breaksBetween(left, right) {
+  if (!left || !right) return false;
+  return JOINS_LEFT.test(left) && JOINS_RIGHT.test(right) || left === "/" && right === "*";
+}
+function spliced(before, text2, after) {
+  if (text2 === "") return breaksBetween(before, after) ? "/**/" : "";
+  const head = breaksBetween(before, text2[0]) ? "/**/" : "";
+  const tail = breaksBetween(text2[text2.length - 1], after) ? "/**/" : "";
+  return head + text2 + tail;
+}
+function substituteValue(value, valueOf) {
+  let out = "";
+  let copied = 0;
+  let i = 0;
+  while (i < value.length) {
+    const c = value[i];
+    if (c === '"' || c === "'") {
+      i = skipString(value, i);
+    } else if (c === "/" && value[i + 1] === "*") {
+      i = skipComment(value, i);
+    } else if (c === "\\") {
+      i += 2;
+    } else if (functionAt(value, i, "url(")) {
+      i = afterUrl(value, i + 4);
+    } else if (functionAt(value, i, "var(")) {
+      const close = closingParen(value, i + 3);
+      if (close < 0) break;
+      const args = value.slice(i + 4, close);
+      const name = VAR_NAME.exec(args)?.[1];
+      const replacement = name === void 0 ? void 0 : valueOf(name);
+      out += value.slice(copied, i);
+      out += replacement === void 0 ? `${value.slice(i, i + 4)}${substituteValue(args, valueOf)})` : spliced(out[out.length - 1], replacement, value[close + 1]);
+      copied = i = close + 1;
+    } else {
+      i += 1;
+    }
+  }
+  return out + value.slice(copied);
+}
+function staticValues(analysis) {
+  const values = /* @__PURE__ */ new Map();
+  const valueOf = (name) => {
+    const property = analysis.get(name);
+    if (!property || property.dynamic) return void 0;
+    let value = values.get(name);
+    if (value === void 0) {
+      value = substituteValue(property.winner.value.trim(), valueOf);
+      values.set(name, value);
+    }
+    return value;
+  };
+  for (const [name, property] of analysis) if (property.reached) valueOf(name);
+  return values;
+}
+function droppedDeclarations(analysis, asset, { substitute }) {
+  const dropped = /* @__PURE__ */ new Set();
+  for (const property of analysis.values()) {
+    const own = property.declarations.filter((d) => d.asset === asset);
+    if (!property.reached || substitute && !property.dynamic) {
+      for (const d of own) dropped.add(d.order);
+      continue;
+    }
+    const winner = winnerOf(own);
+    for (const d of own) if (d.bare && d !== winner) dropped.add(d.order);
+  }
+  return dropped;
+}
+var isDescriptor = (decl) => decl.parent instanceof import_postcss2.AtRule && DESCRIPTOR_AT_RULES.has(decl.parent.name.toLowerCase());
+var removableWhenEmpty = (node) => node instanceof import_postcss2.Rule || node instanceof import_postcss2.AtRule && EMPTIED_AT_RULES.has(node.name.toLowerCase());
+function removeEmptied(containers) {
+  for (const container of containers) {
+    let node = container;
+    while (removableWhenEmpty(node) && node.nodes?.length === 0) {
+      const parent = node.parent;
+      node.remove();
+      node = parent;
+    }
+  }
+}
+function rewrite(css, asset, analysis, options, values = options.substitute ? staticValues(analysis) : null) {
+  const dropped = droppedDeclarations(analysis, asset, options);
+  const root = import_postcss2.default.parse(css);
+  const emptied = /* @__PURE__ */ new Set();
+  let order = 0;
+  root.walkDecls((decl) => {
+    if (decl.prop.startsWith("--") && dropped.has(order++)) {
+      emptied.add(decl.parent);
+      decl.remove();
+      return;
+    }
+    if (!values || isDescriptor(decl)) return;
+    const value = substituteValue(decl.value, (name) => values.get(name));
+    if (value !== decl.value) decl.value = value;
+  });
+  removeEmptied(emptied);
+  return root.toString();
+}
+
+// vite-plugin/productionCss/index.ts
+var text = (source) => typeof source === "string" ? source : new TextDecoder().decode(source);
+var HASH = /\[hash(?::(\d+))?\]/;
+var PLACEHOLDER = /\[(name|hash(?::\d+)?|ext|extname|format)\]/g;
+var escape = (literal) => literal.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+var TEXT_ASSET = /\.(css|html|json|map)$/;
+function hashedFileName(fileName, pattern, content) {
+  const hash = HASH.exec(pattern);
+  if (!hash) return null;
+  const length = hash[1] ? Number(hash[1]) : 8;
+  let regex = "^";
+  let last = 0;
+  for (const m of pattern.matchAll(PLACEHOLDER)) {
+    regex += escape(pattern.slice(last, m.index));
+    if (m.index === hash.index) regex += `([A-Za-z0-9_-]{${length}})`;
+    else if (m[1] === "ext") regex += "[^./]*";
+    else if (m[1] === "extname") regex += "(?:\\.[^./]*)?";
+    else regex += ".*?";
+    last = m.index + m[0].length;
+  }
+  regex += escape(pattern.slice(last)) + "$";
+  const match = new RegExp(regex, "d").exec(fileName);
+  if (!match?.indices?.[1]) throw new Error(`live-tokens: ${fileName} does not follow the output pattern "${pattern}"`);
+  const [start, end] = match.indices[1];
+  const digest = (0, import_node_crypto.createHash)("sha256").update(content).digest("base64url").slice(0, length);
+  return fileName.slice(0, start) + digest + fileName.slice(end);
+}
+function tails(from, to) {
+  let i = 0;
+  while (from[i] === to[i]) i += 1;
+  const start = from.lastIndexOf("/", i) + 1;
+  return [from.slice(start), to.slice(start)];
+}
+function repoint(files, renames) {
+  const pairs = [...renames].map(([from, to]) => tails(from, to));
+  const replace = (s) => {
+    for (const [from, to] of pairs) s = s.replaceAll(from, () => to);
+    return s;
+  };
+  const renamed = (names) => names.map((name) => renames.get(name) ?? name);
+  const changed = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.type === "chunk") {
+      const code = replace(file.code);
+      if (code !== file.code) {
+        file.code = code;
+        changed.add(file);
+      }
+      if (file.imports.some((name) => renames.has(name))) file.imports = renamed(file.imports);
+      if (file.dynamicImports.some((name) => renames.has(name))) file.dynamicImports = renamed(file.dynamicImports);
+      const map = file.sourcemapFileName && replace(file.sourcemapFileName);
+      if (map && map !== file.sourcemapFileName) file.sourcemapFileName = map;
+      const imported = file.viteMetadata?.importedCss;
+      if (imported && [...imported].some((name) => renames.has(name))) {
+        const next = renamed([...imported]);
+        imported.clear();
+        for (const name of next) imported.add(name);
+        changed.add(file);
+      }
+    } else if (TEXT_ASSET.test(file.fileName)) {
+      const before = text(file.source);
+      const after = replace(before);
+      if (after !== before) file.source = after;
+    }
+    const fileName = replace(file.fileName);
+    if (fileName !== file.fileName) file.fileName = fileName;
+  }
+  return changed;
+}
+function renameRewritten(files, sheetRenames, names) {
+  const affected = repoint(files, sheetRenames);
+  const chunks = files.filter((f) => f.type === "chunk");
+  const byName = new Map(chunks.map((c) => [c.fileName, c]));
+  const imported = (c) => [...c.imports, ...c.dynamicImports].flatMap((name) => byName.get(name) ?? []);
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const chunk of chunks) {
+      if (!affected.has(chunk) && imported(chunk).some((c) => affected.has(c))) {
+        affected.add(chunk);
+        grew = true;
+      }
+    }
+  }
+  const identity = (c) => [c.code, ...c.viteMetadata?.importedCss ?? []].join("\0");
+  const chunkRenames = /* @__PURE__ */ new Map();
+  for (const chunk of affected) {
+    const reached = /* @__PURE__ */ new Set([chunk]);
+    const toVisit = [chunk];
+    while (toVisit.length) {
+      for (const next of imported(toVisit.pop())) {
+        if (!reached.has(next)) {
+          reached.add(next);
+          toVisit.push(next);
+        }
+      }
+    }
+    reached.delete(chunk);
+    const others = [...reached].sort((a, b) => a.fileName < b.fileName ? -1 : 1);
+    const fileNames = chunk.isEntry ? names.entryFileNames : names.chunkFileNames;
+    const pattern = typeof fileNames === "string" ? fileNames : fileNames({
+      name: chunk.name,
+      isEntry: chunk.isEntry,
+      isDynamicEntry: chunk.isDynamicEntry,
+      facadeModuleId: chunk.facadeModuleId ?? void 0,
+      moduleIds: chunk.moduleIds,
+      exports: chunk.exports
+    });
+    const renamed = hashedFileName(chunk.fileName, pattern, [chunk, ...others].map(identity).join("\0\0"));
+    if (renamed !== null && renamed !== chunk.fileName) chunkRenames.set(chunk.fileName, renamed);
+  }
+  if (chunkRenames.size > 0) repoint(files, chunkRenames);
+}
+function entrySheets(files) {
+  const chunks = new Map(files.flatMap((f) => f.type === "chunk" ? [[f.fileName, f]] : []));
+  const sheets = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const toVisit = [...chunks.values()].filter((c) => c.isEntry);
+  while (toVisit.length) {
+    const chunk = toVisit.pop();
+    if (seen.has(chunk.fileName)) continue;
+    seen.add(chunk.fileName);
+    for (const sheet of chunk.viteMetadata?.importedCss ?? []) sheets.add(sheet);
+    for (const name of chunk.imports) {
+      const imported = chunks.get(name);
+      if (imported) toVisit.push(imported);
+    }
+  }
+  return sheets;
+}
+function rewriteBundle(bundle, { substitute = true, keep = [] }, names) {
+  const files = Object.values(bundle);
+  const assets = files.filter((f) => f.type === "asset");
+  const sheets = assets.filter((f) => f.fileName.endsWith(".css"));
+  if (sheets.length === 0) return null;
+  const css = sheets.map((f) => text(f.source));
+  const js = [
+    ...files.flatMap((f) => f.type === "chunk" ? [f.code] : []),
+    ...assets.filter((f) => /\.[cm]?js$/.test(f.fileName)).map((f) => text(f.source))
+  ];
+  const html = assets.filter((f) => f.fileName.endsWith(".html")).map((f) => text(f.source));
+  const loadedWithPage = entrySheets(files);
+  const entries = sheets.flatMap((sheet, i) => loadedWithPage.has(sheet.fileName) ? [i] : []);
+  const analysis = analyze({ css, js, html, keep, entries });
+  const values = substitute ? staticValues(analysis) : null;
+  let bytesSaved = 0;
+  const renames = /* @__PURE__ */ new Map();
+  const { assetFileNames } = names;
+  sheets.forEach((sheet, i) => {
+    const rewritten = rewrite(css[i], i, analysis, { substitute }, values);
+    bytesSaved += Buffer.byteLength(css[i]) - Buffer.byteLength(rewritten);
+    if (rewritten === css[i]) return;
+    sheet.source = rewritten;
+    const pattern = typeof assetFileNames === "string" ? assetFileNames : assetFileNames({ type: "asset", names: sheet.names, originalFileNames: sheet.originalFileNames, source: rewritten });
+    const renamed = hashedFileName(sheet.fileName, pattern, rewritten);
+    if (renamed !== null && renamed !== sheet.fileName) renames.set(sheet.fileName, renamed);
+  });
+  if (renames.size > 0) renameRewritten(files, renames, names);
+  let propertiesAfter = 0;
+  for (const property of analysis.values()) {
+    if (property.reached && (property.dynamic || !substitute)) propertiesAfter += 1;
+  }
+  return { propertiesBefore: analysis.size, propertiesAfter, bytesSaved };
+}
+function formatReport({ propertiesBefore, propertiesAfter, bytesSaved }) {
+  const kB = (Math.abs(bytesSaved) / 1e3).toFixed(1);
+  return `live-tokens: the production CSS declares ${propertiesAfter.toLocaleString("en-US")} of ${propertiesBefore.toLocaleString("en-US")} custom properties and is ${kB} kB ${bytesSaved >= 0 ? "smaller" : "larger"}.`;
+}
+
 // vite-plugin/themeFileApi.ts
 var import_node_url2 = require("url");
 var import_meta2 = {};
@@ -6496,6 +7066,7 @@ data: ${JSON.stringify(state)}
   const isEditorOwnedJson = (file) => file.endsWith(".json") && import_path5.default.resolve(file).startsWith(dataDirs.dataDir + import_path5.default.sep);
   let buildLogger = null;
   let buildChecked = false;
+  let productionCssLogger = null;
   return {
     name: "theme-file-api",
     config() {
@@ -6510,6 +7081,7 @@ data: ${JSON.stringify(state)}
     },
     configResolved(config) {
       buildLogger = config.command === "build" && opts.checks !== false ? config.logger : null;
+      productionCssLogger = config.command === "build" && opts.productionCss !== false ? config.logger : null;
     },
     async buildStart() {
       if (!buildLogger || buildChecked) return;
@@ -6517,6 +7089,15 @@ data: ${JSON.stringify(state)}
       const failure = await checkBeforeBuild({ root: process.cwd(), logger: buildLogger });
       if (failure) this.error(failure);
     },
+    generateBundle: {
+      // After Vite's own hooks, so the bundle holds the minified CSS and index.html.
+      order: "post",
+      handler(output, bundle) {
+        if (!productionCssLogger) return;
+        const report = rewriteBundle(bundle, opts.productionCss || {}, output);
+        if (report) productionCssLogger.info(formatReport(report));
+      }
+    },
     configureServer(server) {
       legacyLayout = detectLegacyLayout({
         dataDir: dataDirs.dataDir,