@qw-ui/tokens 0.1.0

package/dist/index.js

@@ -0,0 +1,1182 @@
+import { z } from 'zod';
+import { rgb, parse, formatHex, oklch, clampChroma } from 'culori';
+
+// src/seed/index.json
+var seed_default = {
+  qw: {
+    seed: {
+      color: {
+        brand: { $value: { colorSpace: "srgb", components: [0, 0.0667, 1], alpha: 1 }, $type: "color" },
+        black: { $value: { colorSpace: "srgb", components: [0.1333, 0.1333, 0.1333], alpha: 1 }, $type: "color" },
+        white: { $value: { colorSpace: "srgb", components: [1, 1, 1], alpha: 1 }, $type: "color" },
+        gray: { $value: { colorSpace: "srgb", components: [0.6, 0.6, 0.6], alpha: 1 }, $type: "color" },
+        red: { $value: { colorSpace: "srgb", components: [1, 0.251, 0.251], alpha: 1 }, $type: "color" },
+        orange: { $value: { colorSpace: "srgb", components: [1, 0.4196, 0.2471], alpha: 1 }, $type: "color" },
+        yellow: { $value: { colorSpace: "srgb", components: [1, 0.8353, 0.4588], alpha: 1 }, $type: "color" },
+        green: { $value: { colorSpace: "srgb", components: [0.1216, 0.6, 0.2471], alpha: 1 }, $type: "color" },
+        cyan: { $value: { colorSpace: "srgb", components: [0.1608, 0.7451, 0.8], alpha: 1 }, $type: "color" },
+        blue: { $value: { colorSpace: "srgb", components: [0.051, 0.3255, 1], alpha: 1 }, $type: "color" },
+        purple: { $value: { colorSpace: "srgb", components: [0.2627, 0.1725, 0.8588], alpha: 1 }, $type: "color" },
+        brown: { $value: { colorSpace: "srgb", components: [0.7059, 0.3686, 0.0235], alpha: 1 }, $type: "color" }
+      },
+      size: {
+        spacing: {
+          step: { $value: { value: 4, unit: "px" }}
+        },
+        borderWidth: {
+          hairline: { $value: { value: 1, unit: "px" }}
+        },
+        radius: {
+          base: { $value: { value: 8, unit: "px" }},
+          full: { $value: { value: 9999, unit: "px" }}
+        },
+        controlSize: {
+          base: { $value: { value: 40, unit: "px" }}
+        },
+        iconSize: {
+          base: { $value: { value: 20, unit: "px" }}
+        },
+        opacity: {
+          disabled: { $value: 0.5},
+          alphaStep: { $value: 0.04}
+        },
+        zIndex: {
+          step: { $value: 10}
+        }
+      },
+      typography: {
+        fontFamily: {
+          text: { $value: ["system-ui", "-apple-system", "BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial", "sans-serif"]},
+          number: { $value: ["PlusJakartaSans", "system-ui", "Segoe UI", "Roboto", "Helvetica Neue", "Arial", "sans-serif"]},
+          code: { $value: ["ui-monospace", "SFMono-Regular", "SF Mono", "Menlo", "Consolas", "Liberation Mono", "monospace"]},
+          textMacLatin: { $value: ["-apple-system", "BlinkMacSystemFont", "SF Pro Text", "system-ui", "Helvetica Neue", "Helvetica", "Arial", "sans-serif"]},
+          textMacZh: { $value: ["PingFang SC", "-apple-system", "BlinkMacSystemFont", "Hiragino Sans GB", "Hiragino Sans", "SF Pro Text", "system-ui", "Noto Sans SC", "Helvetica Neue", "Helvetica", "Arial", "sans-serif"]},
+          textMacJa: { $value: ["Hiragino Sans", "Hiragino Kaku Gothic ProN", "-apple-system", "BlinkMacSystemFont", "PingFang SC", "SF Pro Text", "system-ui", "Noto Sans JP", "Helvetica Neue", "Helvetica", "Arial", "sans-serif"]},
+          textWindowsLatin: { $value: ["Segoe UI", "system-ui", "Roboto", "Noto Sans", "Helvetica Neue", "Arial", "sans-serif"]},
+          textWindowsZh: { $value: ["Microsoft YaHei", "Segoe UI", "system-ui", "Roboto", "Noto Sans SC", "Helvetica Neue", "Arial", "sans-serif"]},
+          textWindowsJa: { $value: ["Meiryo", "Yu Gothic UI", "Segoe UI", "system-ui", "Roboto", "Noto Sans JP", "Helvetica Neue", "Arial", "sans-serif"]}
+        },
+        fontWeight: {
+          regular: { $value: 400},
+          medium: { $value: 500},
+          semibold: { $value: 600}
+        },
+        fontSize: {
+          base: { $value: { value: 14, unit: "px" }}
+        },
+        lineHeight: {
+          base: { $value: 1.5}
+        },
+        letterSpacing: {
+          base: { $value: { value: 0, unit: "px" }}
+        }
+      },
+      motion: {
+        duration: {
+          base: { $value: { value: 200, unit: "ms" }}
+        },
+        easing: {
+          standard: { $value: [0.16, 1, 0.3, 1]}
+        }
+      },
+      effect: {
+        shadow: {
+          base: {
+            $value: {
+              color: { colorSpace: "srgb", components: [0, 0, 0], alpha: 0.08 },
+              offsetX: { value: 0, unit: "px" },
+              offsetY: { value: 2, unit: "px" },
+              blur: { value: 4, unit: "px" },
+              spread: { value: 0, unit: "px" }
+            }}
+        }
+      }
+    }
+  }
+};
+
+// src/color-architecture.ts
+var FIGMA_COLOR_COLLECTION = "Color";
+var FIGMA_COLOR_PREFIX = "qw";
+var T1_COLOR_KEYS = [
+  "brand",
+  "black",
+  "white",
+  "gray",
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "cyan",
+  "blue",
+  "purple",
+  "brown"
+];
+var FIGMA_T1_SEED_HEX = {
+  brand: "#0011FF",
+  black: "#222222",
+  white: "#FFFFFF",
+  gray: "#999999",
+  red: "#FF4040",
+  orange: "#FF6B3F",
+  yellow: "#FFD575",
+  green: "#1F993F",
+  cyan: "#29BECC",
+  blue: "#0D53FF",
+  purple: "#432CDB",
+  brown: "#B45E06"
+};
+var T2_ALPHA_STEPS = [5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+var T2_ALPHA_KEYS = T2_ALPHA_STEPS.map((step) => `a${step}`);
+var T2_OKLCH_STEPS = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+var FIGMA_T2_SOLID_SCALE = {
+  brand: {
+    50: "#F2F6FF",
+    100: "#E6ECFF",
+    200: "#C4D8FF",
+    300: "#9DBDFF",
+    400: "#6C9AFF",
+    500: "#426EFF",
+    600: "#1B57FF",
+    700: "#002CE8",
+    800: "#001A99",
+    900: "#000540"
+  },
+  black: {
+    50: "#F6F6F6",
+    100: "#EBEBEB",
+    200: "#D7D7D7",
+    300: "#BEBEBE",
+    400: "#9E9E9E",
+    500: "#868686",
+    600: "#6F6F6F",
+    700: "#555555",
+    800: "#353535",
+    900: "#121212"
+  },
+  white: {
+    50: "#F6F6F6",
+    100: "#EBEBEB",
+    200: "#D7D7D7",
+    300: "#BEBEBE",
+    400: "#9E9E9E",
+    500: "#868686",
+    600: "#6F6F6F",
+    700: "#555555",
+    800: "#353535",
+    900: "#121212"
+  },
+  gray: {
+    50: "#F6F6F6",
+    100: "#EEEEEE",
+    200: "#E0E0E0",
+    300: "#CCCCCC",
+    400: "#A2A9B6",
+    500: "#888E99",
+    600: "#666666",
+    700: "#3A3A3A",
+    800: "#2D2D2D",
+    900: "#202020"
+  },
+  red: {
+    50: "#FFF3F1",
+    100: "#FFE7E4",
+    200: "#FFC8C2",
+    300: "#FFA097",
+    400: "#FF5745",
+    500: "#FF4D4D",
+    600: "#CF081E",
+    700: "#A30013",
+    800: "#6A0009",
+    900: "#2A0001"
+  },
+  orange: {
+    50: "#FFF3EF",
+    100: "#FFE5DD",
+    200: "#FFC9B9",
+    300: "#FFA287",
+    400: "#F76F47",
+    500: "#FF764D",
+    600: "#C03800",
+    700: "#962A00",
+    800: "#611800",
+    900: "#260500"
+  },
+  yellow: {
+    50: "#FFF5DF",
+    100: "#FFE9B9",
+    200: "#F4D38B",
+    300: "#DCB96B",
+    400: "#BE9940",
+    500: "#A78013",
+    600: "#8B6900",
+    700: "#6C5100",
+    800: "#453200",
+    900: "#191000"
+  },
+  green: {
+    50: "#E2FFE4",
+    100: "#BCFFC3",
+    200: "#9BEFA5",
+    300: "#7BD688",
+    400: "#52B764",
+    500: "#2C9F47",
+    600: "#068631",
+    700: "#006823",
+    800: "#004213",
+    900: "#001704"
+  },
+  cyan: {
+    50: "#E0FCFF",
+    100: "#BAF8FF",
+    200: "#91EAF2",
+    300: "#65D0DC",
+    400: "#2FB2BE",
+    500: "#0098A4",
+    600: "#007E88",
+    700: "#006169",
+    800: "#003D43",
+    900: "#001518"
+  },
+  blue: {
+    50: "#EBF5FF",
+    100: "#E7F1FF",
+    200: "#D6EBFF",
+    300: "#9CBEFF",
+    400: "#3086FF",
+    500: "#1677FF",
+    600: "#266FFF",
+    700: "#003DB8",
+    800: "#001D66",
+    900: "#000A3A"
+  },
+  purple: {
+    50: "#F3F5FF",
+    100: "#E6EAFF",
+    200: "#CDD5FF",
+    300: "#A699FF",
+    400: "#8692FF",
+    500: "#6B71FF",
+    600: "#5550F2",
+    700: "#4135C9",
+    800: "#280B96",
+    900: "#0C0041"
+  },
+  brown: {
+    50: "#FFF3EC",
+    100: "#FFE6D5",
+    200: "#FFCBA8",
+    300: "#F8A971",
+    400: "#DA8749",
+    500: "#C36D24",
+    600: "#A75600",
+    700: "#824100",
+    800: "#542800",
+    900: "#200B00"
+  }
+};
+var FIGMA_T3_COLOR_ROLES = {
+  "surface.base": { light: "color.white.base", dark: "color.black.base" },
+  "surface.subtle": { light: "color.gray.50", dark: "color.gray.900" },
+  "surface.elevated": { light: "color.white.base", dark: "color.gray.800" },
+  "surface.header": { light: "color.gray.100", dark: "color.gray.700" },
+  "surface.brand-subtle": { light: "color.blue.50", dark: "color.blue.800" },
+  "content.primary": { light: "color.black.base", dark: "color.white.base" },
+  "content.secondary": { light: "color.gray.600", dark: "color.gray.base" },
+  "content.tertiary": { light: "color.gray.base", dark: "color.gray.600" },
+  "content.placeholder": { light: "color.gray.300", dark: "color.white.a30" },
+  "content.intro": { light: "color.gray.400", dark: "color.gray.500" },
+  "border.default": { light: "color.gray.100", dark: "color.gray.700" },
+  "border.strong": { light: "color.gray.300", dark: "color.gray.600" },
+  "border.focus": { light: "color.brand.base", dark: "color.brand.500" },
+  "fill.subtle": { light: "color.gray.50", dark: "color.white.a20" },
+  "fill.hover": { light: "color.gray.100", dark: "color.gray.800" },
+  "fill.active": { light: "color.blue.50", dark: "color.blue.800" },
+  "fill.disabled": { light: "color.gray.50", dark: "color.gray.900" },
+  "action.brand": { light: "color.brand.base", dark: "color.brand.500" },
+  "action.product": { light: "color.blue.base", dark: "color.blue.600" },
+  "action.selected": { light: "color.blue.a20", dark: "color.blue.a40" },
+  "action.inverse": { light: "color.white.base", dark: "color.black.base" },
+  "status.success": { light: "color.green.base", dark: "color.green.base" },
+  "status.warning": { light: "color.yellow.base", dark: "color.yellow.base" },
+  "status.danger": { light: "color.red.400", dark: "color.red.400" },
+  "status.info": { light: "color.blue.base", dark: "color.blue.600" },
+  "overlay.scrim": { light: "color.black.a50", dark: "color.black.a70" },
+  "overlay.guide": { light: "color.black.a70", dark: "color.black.a70" }
+};
+
+// src/seed/index.ts
+var s = seed_default.qw.seed;
+var px = (d) => `${d.value}${d.unit}`;
+var color = (v) => v;
+var defaultSeed = {
+  color: Object.fromEntries(T1_COLOR_KEYS.map((key) => [key, color(s.color[key].$value)])),
+  size: {
+    spacing: {
+      step: px(s.size.spacing.step.$value)
+    },
+    borderWidth: {
+      hairline: px(s.size.borderWidth.hairline.$value)
+    },
+    radius: {
+      base: px(s.size.radius.base.$value),
+      full: px(s.size.radius.full.$value)
+    },
+    controlSize: {
+      base: px(s.size.controlSize.base.$value)
+    },
+    iconSize: {
+      base: px(s.size.iconSize.base.$value)
+    },
+    opacity: {
+      disabled: s.size.opacity.disabled.$value,
+      alphaStep: s.size.opacity.alphaStep.$value
+    },
+    zIndex: {
+      step: s.size.zIndex.step.$value
+    }
+  },
+  typography: {
+    fontFamily: {
+      text: s.typography.fontFamily.text.$value,
+      number: s.typography.fontFamily.number.$value,
+      code: s.typography.fontFamily.code.$value,
+      textMacLatin: s.typography.fontFamily.textMacLatin.$value,
+      textMacZh: s.typography.fontFamily.textMacZh.$value,
+      textMacJa: s.typography.fontFamily.textMacJa.$value,
+      textWindowsLatin: s.typography.fontFamily.textWindowsLatin.$value,
+      textWindowsZh: s.typography.fontFamily.textWindowsZh.$value,
+      textWindowsJa: s.typography.fontFamily.textWindowsJa.$value
+    },
+    fontWeight: {
+      regular: s.typography.fontWeight.regular.$value,
+      medium: s.typography.fontWeight.medium.$value,
+      semibold: s.typography.fontWeight.semibold.$value
+    },
+    fontSize: {
+      base: px(s.typography.fontSize.base.$value)
+    },
+    lineHeight: {
+      base: s.typography.lineHeight.base.$value
+    },
+    letterSpacing: {
+      base: px(s.typography.letterSpacing.base.$value)
+    }
+  },
+  motion: {
+    duration: {
+      base: px(s.motion.duration.base.$value)
+    },
+    easing: {
+      standard: s.motion.easing.standard.$value
+    }
+  },
+  effect: {
+    shadow: {
+      base: {
+        color: color(s.effect.shadow.base.$value.color),
+        offsetX: px(s.effect.shadow.base.$value.offsetX),
+        offsetY: px(s.effect.shadow.base.$value.offsetY),
+        blur: px(s.effect.shadow.base.$value.blur),
+        spread: px(s.effect.shadow.base.$value.spread)
+      }
+    }
+  }
+};
+var seedColor = z.object({
+  colorSpace: z.enum(["srgb", "oklch"]),
+  components: z.tuple([z.number(), z.number(), z.number()]),
+  alpha: z.number().min(0).max(1)
+}).superRefine((c, ctx) => {
+  if (c.colorSpace === "srgb") {
+    if (c.components.some((v) => v < 0 || v > 1)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "srgb components \u5FC5\u987B\u662F 0\u20131\uFF08\u4E0D\u662F 0\u2013255\uFF09\uFF0C\u4F8B\u5982 #0011ff \u2192 [0, 0.0667, 1]"
+      });
+    }
+  } else {
+    const [l, chroma] = c.components;
+    if (l < 0 || l > 1 || chroma < 0) {
+      ctx.addIssue({ code: "custom", message: "oklch \u8981\u6C42 l \u2208 [0,1] \u4E14 c \u2265 0" });
+    }
+  }
+});
+var cubicBezier = z.tuple([z.number(), z.number(), z.number(), z.number()]);
+var fontStack = z.array(z.string()).min(1);
+var colorSeedShape = Object.fromEntries(T1_COLOR_KEYS.map((key) => [key, seedColor]));
+var SeedSchema = z.object({
+  color: z.object(colorSeedShape),
+  size: z.object({
+    spacing: z.object({
+      step: z.string()
+    }),
+    borderWidth: z.object({
+      hairline: z.string()
+    }),
+    radius: z.object({
+      /** 控件基准圆角；Reference 派生 sm=×0.5 / md=×1 / lg=×1.75。 */
+      base: z.string(),
+      /** 药丸/圆形裁切基准（独立设计决策，不从 base 派生）。 */
+      full: z.string()
+    }),
+    controlSize: z.object({
+      /** md 控件高度锚点；sm/lg = base ∓ spacing.step × 2。 */
+      base: z.string()
+    }),
+    iconSize: z.object({
+      /** md 图标尺寸锚点；sm/lg = base ∓ spacing.step。 */
+      base: z.string()
+    }),
+    opacity: z.object({
+      disabled: z.number().min(0).max(1),
+      alphaStep: z.number().min(0).max(1)
+    }),
+    zIndex: z.object({
+      step: z.number().int().positive()
+    })
+  }),
+  typography: z.object({
+    fontFamily: z.object({
+      /** 通用正文栈（跨平台缺省）。 */
+      text: fontStack,
+      /** 数字/数据展示栈。 */
+      number: fontStack,
+      /** 代码等宽栈。 */
+      code: fontStack,
+      /** 平台/语言细分变体，供上层按 UA/lang 重映射 text 角色。 */
+      textMacLatin: fontStack,
+      textMacZh: fontStack,
+      textMacJa: fontStack,
+      textWindowsLatin: fontStack,
+      textWindowsZh: fontStack,
+      textWindowsJa: fontStack
+    }),
+    fontWeight: z.object({
+      regular: z.number(),
+      medium: z.number(),
+      semibold: z.number()
+    }),
+    fontSize: z.object({
+      base: z.string()
+    }),
+    lineHeight: z.object({
+      base: z.number().positive()
+    }),
+    letterSpacing: z.object({
+      base: z.string()
+    })
+  }),
+  motion: z.object({
+    duration: z.object({
+      base: z.string()
+    }),
+    easing: z.object({
+      standard: cubicBezier
+    })
+  }),
+  effect: z.object({
+    shadow: z.object({
+      base: z.object({
+        color: seedColor,
+        offsetX: z.string(),
+        offsetY: z.string(),
+        blur: z.string(),
+        spread: z.string()
+      })
+    })
+  })
+});
+function validateSeed(seed) {
+  const r = SeedSchema.safeParse(seed);
+  if (!r.success) {
+    console.error("[qw] invalid seed:", r.error.format());
+    throw new Error("invalid seed");
+  }
+  return r.data;
+}
+function toCulori(c) {
+  if (c.colorSpace === "srgb") {
+    return { mode: "rgb", r: c.components[0], g: c.components[1], b: c.components[2], alpha: c.alpha };
+  }
+  return { mode: "oklch", l: c.components[0], c: c.components[1], h: c.components[2], alpha: c.alpha };
+}
+var round6 = (n) => Math.round(n * 1e6) / 1e6;
+function hexToSeedColor(hex) {
+  const parsed = rgb(parse(hex));
+  if (!parsed) throw new Error(`[qw] \u65E0\u6CD5\u89E3\u6790\u989C\u8272: ${hex}`);
+  return {
+    colorSpace: "srgb",
+    components: [round6(parsed.r), round6(parsed.g), round6(parsed.b)],
+    alpha: parsed.alpha ?? 1
+  };
+}
+function seedColorToHex(c) {
+  const converted = rgb(toCulori(c));
+  if (!converted) throw new Error(`[qw] \u65E0\u6CD5\u8F6C\u6362\u989C\u8272: ${JSON.stringify(c)}`);
+  return formatHex(converted) ?? "#000000";
+}
+function seedColorToCss(c) {
+  if (c.colorSpace === "oklch") {
+    const [l, ch, h] = c.components;
+    return c.alpha >= 1 ? `oklch(${l} ${ch} ${h})` : `oklch(${l} ${ch} ${h} / ${c.alpha})`;
+  }
+  if (c.alpha >= 1) return seedColorToHex(c);
+  const [r, g, b] = c.components.map((v) => Math.round(v * 255));
+  return `rgb(${r} ${g} ${b} / ${c.alpha})`;
+}
+var STEPS = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+var L_TARGETS = {
+  50: 0.972,
+  100: 0.94,
+  200: 0.88,
+  300: 0.8,
+  400: 0.7,
+  500: 0.62,
+  600: 0.54,
+  700: 0.45,
+  800: 0.33,
+  900: 0.18
+};
+function chromaFactor(l) {
+  const d = Math.abs(l - 0.6) / 0.6;
+  return 1 - 0.45 * Math.min(1, d);
+}
+function ramp(seedColor2) {
+  const input = typeof seedColor2 === "string" ? parse(seedColor2) : toCulori(seedColor2);
+  const base = oklch(input);
+  if (!base) throw new Error(`[qw] \u65E0\u6CD5\u89E3\u6790\u989C\u8272: ${JSON.stringify(seedColor2)}`);
+  const baseC = base.c ?? 0;
+  const baseH = base.h ?? 0;
+  const out = {};
+  for (const step of STEPS) {
+    const l = L_TARGETS[step];
+    const c = baseC * chromaFactor(l);
+    const inGamut = clampChroma({ mode: "oklch", l, c, h: baseH }, "oklch");
+    out[step] = formatHex(inGamut) ?? formatHex(base) ?? "#000000";
+  }
+  return out;
+}
+function relativeLuminance(hex) {
+  const srgb = parse(hex);
+  if (!srgb) return 0;
+  const lin = (v) => v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  return 0.2126 * lin(srgb.r) + 0.7152 * lin(srgb.g) + 0.0722 * lin(srgb.b);
+}
+function contrastRatio(fg, bg) {
+  const l1 = relativeLuminance(fg);
+  const l2 = relativeLuminance(bg);
+  const [hi, lo] = l1 > l2 ? [l1, l2] : [l2, l1];
+  return (hi + 0.05) / (lo + 0.05);
+}
+
+// src/derive/naming.ts
+function kebab(segment) {
+  return segment.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toVar(layer, path) {
+  return `--qw-${layer}-${path.map(kebab).join("-")}`;
+}
+
+// src/derive/reference.ts
+function seedValueAt(seed, dotted) {
+  let node = seed;
+  for (const seg of dotted.split(".")) {
+    if (node == null || typeof node !== "object") {
+      throw new Error(`[qw] Seed \u8DEF\u5F84\u4E0D\u5B58\u5728: ${dotted}`);
+    }
+    node = node[seg];
+  }
+  if (node === void 0) throw new Error(`[qw] Seed \u8DEF\u5F84\u4E0D\u5B58\u5728: ${dotted}`);
+  return node;
+}
+function parsePx(s2) {
+  const m = /^(-?\d+(?:\.\d+)?)(.*)$/.exec(s2.trim());
+  if (!m) throw new Error(`[qw] \u65E0\u6CD5\u89E3\u6790\u5C3A\u5BF8: ${s2}`);
+  return { value: Number(m[1]), unit: m[2] ?? "" };
+}
+var round2 = (n) => Math.round(n * 100) / 100;
+function rgba(components, alpha) {
+  return `rgba(${components[0]}, ${components[1]}, ${components[2]}, ${round2(alpha)})`;
+}
+function hexRgb(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex);
+  if (!m) throw new Error(`[qw] \u65E0\u6CD5\u89E3\u6790 hex \u989C\u8272: ${hex}`);
+  const n = Number.parseInt(m[1], 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function seedAlphaCss(seedColor2, alpha) {
+  if (alpha >= 1) return seedColorToCss({ ...seedColor2, alpha: 1 });
+  return rgba(hexRgb(seedColorToHex(seedColor2)), alpha);
+}
+function formatFontFamily(list) {
+  return list.map((f) => /[\s./]/.test(f) ? `'${f}'` : f).join(", ");
+}
+function formatCubicBezier([a, b, c, d]) {
+  return `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
+}
+var SHADOW_LEVELS = {
+  sm: { offset: 0.5, blur: 0.5, alphaMult: 2 },
+  md: { offset: 2, blur: 3, alphaMult: 3 },
+  lg: { offset: 4, blur: 6, alphaMult: 4 }
+};
+function shadowShapeOf(seed, level) {
+  const { offset, blur } = SHADOW_LEVELS[level];
+  const base = seed.effect.shadow.base;
+  const scale = (s2, f) => {
+    const { value, unit } = parsePx(s2);
+    return `${round2(value * f)}${unit}`;
+  };
+  return {
+    offsetX: scale(base.offsetX, offset),
+    offsetY: scale(base.offsetY, offset),
+    blur: scale(base.blur, blur),
+    spread: scale(base.spread, offset)
+  };
+}
+function evaluateDerivation(d, seed) {
+  switch (d.kind) {
+    case "alias": {
+      const v = seedValueAt(seed, d.seedRef);
+      if (v != null && typeof v === "object" && "colorSpace" in v) {
+        return seedColorToCss(v);
+      }
+      return typeof v === "number" ? String(v) : v;
+    }
+    case "scale": {
+      const { value, unit } = parsePx(seedValueAt(seed, d.seedRef));
+      const scaled = value * d.factor;
+      return `${d.round === "int" ? Math.round(scaled) : round2(scaled)}${unit}`;
+    }
+    case "scaleNumber":
+      return String(round2(seedValueAt(seed, d.seedRef) * d.factor));
+    case "offsetNumber":
+      return String(round2(seedValueAt(seed, d.seedRef) + d.delta));
+    case "offsetSteps": {
+      const base = parsePx(seedValueAt(seed, d.seedRef));
+      const step = parsePx(seedValueAt(seed, d.stepRef));
+      return `${round2(base.value + step.value * d.n)}${base.unit}`;
+    }
+    case "oklchRamp":
+      return ramp(seed.color[d.seedRef.split(".")[1]])[d.step];
+    case "figmaOklchScale":
+      return d.value;
+    case "seedAlpha":
+      return seedAlphaCss(seedValueAt(seed, d.seedRef), d.alpha);
+    case "alphaScale": {
+      const step = seedValueAt(seed, d.stepRef);
+      const channel = d.channel === "black" ? [0, 0, 0] : [255, 255, 255];
+      return rgba(channel, step * d.multiplier);
+    }
+    case "fontStack":
+      return formatFontFamily(seedValueAt(seed, d.seedRef));
+    case "cubicBezier":
+      return formatCubicBezier(seedValueAt(seed, d.seedRef));
+    case "literal":
+      return d.value;
+    case "shadowLayer": {
+      const { offsetX, offsetY, blur, spread } = shadowShapeOf(seed, d.level);
+      const color2 = rgba([0, 0, 0], seed.size.opacity.alphaStep * SHADOW_LEVELS[d.level].alphaMult);
+      return `${offsetX} ${offsetY} ${blur} ${spread} ${color2}`;
+    }
+  }
+}
+function seedRefsOf(d) {
+  switch (d.kind) {
+    case "alias":
+    case "scale":
+    case "scaleNumber":
+    case "offsetNumber":
+    case "oklchRamp":
+    case "figmaOklchScale":
+    case "seedAlpha":
+    case "fontStack":
+    case "cubicBezier":
+      return [d.seedRef];
+    case "offsetSteps":
+      return [d.seedRef, d.stepRef];
+    case "alphaScale":
+      return [d.stepRef];
+    case "literal":
+      return [];
+    case "shadowLayer":
+      return ["effect.shadow.base", "size.opacity.alphaStep"];
+  }
+}
+function formatDerivation(d) {
+  const sign = (n) => n >= 0 ? "+" : "\u2212";
+  switch (d.kind) {
+    case "alias":
+    case "fontStack":
+    case "cubicBezier":
+      return `= seed.${d.seedRef}`;
+    case "scale":
+      return `= seed.${d.seedRef} \xD7 ${d.factor}`;
+    case "scaleNumber":
+      return `= seed.${d.seedRef} \xD7 ${d.factor}`;
+    case "offsetNumber":
+      return `= seed.${d.seedRef} ${sign(d.delta)} ${Math.abs(d.delta)}`;
+    case "offsetSteps":
+      return `= seed.${d.seedRef} ${sign(d.n)} seed.${d.stepRef} \xD7 ${Math.abs(d.n)}`;
+    case "oklchRamp":
+      return `= oklch(seed.${d.seedRef}) @ L ${L_TARGETS[d.step]} \xB7 C \xD7 ${round2(chromaFactor(L_TARGETS[d.step]))}`;
+    case "figmaOklchScale":
+      return `= figma Color/qw/t2/${d.seedRef.split(".")[1]}/${d.step}\uFF08OKLCH \u8BBE\u8BA1\u6821\u51C6\uFF09`;
+    case "seedAlpha":
+      return `= seed.${d.seedRef} / ${round2(d.alpha * 100)}%`;
+    case "alphaScale":
+      return `= ${d.channel === "black" ? "\u9ED1" : "\u767D"} / seed.${d.stepRef} \xD7 ${d.multiplier}`;
+    case "literal":
+      return `= ${d.value}\uFF08\u8272\u5F69\u7A7A\u95F4\u7AEF\u70B9\uFF0C\u767D\u540D\u5355\u5B57\u9762\u91CF\uFF09`;
+    case "shadowLayer": {
+      const f = SHADOW_LEVELS[d.level];
+      return `= seed.effect.shadow.base \u5F62\u72B6 \xD7 {offset ${f.offset}, blur ${f.blur}} \xB7 \u8272 = \u9ED1 / alphaStep \xD7 ${f.alphaMult}`;
+    }
+  }
+}
+function ref(path, derivation) {
+  return { path, cssVar: toVar("ref", path), seedRefs: seedRefsOf(derivation), derivation };
+}
+var RAMP_COLORS = T1_COLOR_KEYS;
+function buildColorRampRecipes() {
+  const out = [];
+  for (const name of RAMP_COLORS) {
+    const seedRef = `color.${name}`;
+    for (const alpha of T2_ALPHA_STEPS) {
+      out.push(ref(["color", name, `a${alpha}`], { kind: "seedAlpha", seedRef, alpha: alpha / 100 }));
+    }
+    for (const step of T2_OKLCH_STEPS) {
+      out.push(
+        ref(["color", name, String(step)], {
+          kind: "figmaOklchScale",
+          seedRef,
+          step,
+          value: FIGMA_T2_SOLID_SCALE[name][step]
+        })
+      );
+    }
+    out.push(ref(["color", name, "base"], { kind: "alias", seedRef }));
+  }
+  return out;
+}
+function buildSpacingRecipes() {
+  const out = [];
+  for (let n = 1; n <= 8; n++) {
+    out.push(ref(["size", "spacing", String(n)], { kind: "scale", seedRef: "size.spacing.step", factor: n }));
+  }
+  return out;
+}
+var RADIUS_FACTORS = { sm: 0.5, lg: 1.75 };
+function buildRadiusRecipes() {
+  return [
+    ref(["size", "radius", "sm"], { kind: "scale", seedRef: "size.radius.base", factor: RADIUS_FACTORS.sm }),
+    ref(["size", "radius", "md"], { kind: "alias", seedRef: "size.radius.base" }),
+    ref(["size", "radius", "lg"], { kind: "scale", seedRef: "size.radius.base", factor: RADIUS_FACTORS.lg }),
+    ref(["size", "radius", "full"], { kind: "alias", seedRef: "size.radius.full" })
+  ];
+}
+function buildControlIconSizeRecipes() {
+  const step = "size.spacing.step";
+  return [
+    ref(["size", "controlSize", "sm"], { kind: "offsetSteps", seedRef: "size.controlSize.base", stepRef: step, n: -2 }),
+    ref(["size", "controlSize", "md"], { kind: "alias", seedRef: "size.controlSize.base" }),
+    ref(["size", "controlSize", "lg"], { kind: "offsetSteps", seedRef: "size.controlSize.base", stepRef: step, n: 2 }),
+    ref(["size", "iconSize", "sm"], { kind: "offsetSteps", seedRef: "size.iconSize.base", stepRef: step, n: -1 }),
+    ref(["size", "iconSize", "md"], { kind: "alias", seedRef: "size.iconSize.base" }),
+    ref(["size", "iconSize", "lg"], { kind: "offsetSteps", seedRef: "size.iconSize.base", stepRef: step, n: 1 })
+  ];
+}
+function buildBorderWidthRecipes() {
+  return [ref(["size", "borderWidth", "hairline"], { kind: "alias", seedRef: "size.borderWidth.hairline" })];
+}
+function buildLineHeightRecipes() {
+  return [
+    ref(["typography", "lineHeight", "tight"], { kind: "offsetNumber", seedRef: "typography.lineHeight.base", delta: -0.25 }),
+    ref(["typography", "lineHeight", "normal"], { kind: "alias", seedRef: "typography.lineHeight.base" }),
+    ref(["typography", "lineHeight", "relaxed"], { kind: "offsetNumber", seedRef: "typography.lineHeight.base", delta: 0.25 })
+  ];
+}
+function buildOpacityRecipes() {
+  return [ref(["size", "opacity", "disabled"], { kind: "alias", seedRef: "size.opacity.disabled" })];
+}
+function buildZIndexRecipes() {
+  return [1, 2, 3, 4].map(
+    (n) => ref(["size", "zIndex", String(n)], { kind: "scaleNumber", seedRef: "size.zIndex.step", factor: n })
+  );
+}
+var FONT_FAMILY_KEYS = [
+  "text",
+  "number",
+  "code",
+  "textMacLatin",
+  "textMacZh",
+  "textMacJa",
+  "textWindowsLatin",
+  "textWindowsZh",
+  "textWindowsJa"
+];
+var FONT_SIZE_FACTORS = { sm: 0.857, lg: 1.143, xl: 1.429, "2xl": 1.714 };
+function buildTypographyRecipes() {
+  const out = [];
+  for (const key of FONT_FAMILY_KEYS) {
+    out.push(ref(["typography", "fontFamily", key], { kind: "fontStack", seedRef: `typography.fontFamily.${key}` }));
+  }
+  for (const key of ["regular", "medium", "semibold"]) {
+    out.push(ref(["typography", "fontWeight", key], { kind: "alias", seedRef: `typography.fontWeight.${key}` }));
+  }
+  out.push(ref(["typography", "fontSize", "base"], { kind: "alias", seedRef: "typography.fontSize.base" }));
+  for (const [key, factor] of Object.entries(FONT_SIZE_FACTORS)) {
+    out.push(
+      ref(["typography", "fontSize", key], { kind: "scale", seedRef: "typography.fontSize.base", factor, round: "int" })
+    );
+  }
+  out.push(ref(["typography", "letterSpacing", "base"], { kind: "alias", seedRef: "typography.letterSpacing.base" }));
+  return out;
+}
+var DURATION_FACTORS = { fast: 0.5, slow: 1.6 };
+function buildMotionRecipes() {
+  return [
+    ref(["motion", "duration", "fast"], { kind: "scale", seedRef: "motion.duration.base", factor: DURATION_FACTORS.fast }),
+    ref(["motion", "duration", "base"], { kind: "alias", seedRef: "motion.duration.base" }),
+    ref(["motion", "duration", "slow"], { kind: "scale", seedRef: "motion.duration.base", factor: DURATION_FACTORS.slow }),
+    ref(["motion", "easing", "standard"], { kind: "cubicBezier", seedRef: "motion.easing.standard" })
+  ];
+}
+function buildShadowRecipes() {
+  return ["sm", "md", "lg"].map((level) => ref(["effect", "shadow", level], { kind: "shadowLayer", level }));
+}
+function allReferenceRecipes() {
+  return [
+    ...buildColorRampRecipes(),
+    ...buildSpacingRecipes(),
+    ...buildRadiusRecipes(),
+    ...buildControlIconSizeRecipes(),
+    ...buildBorderWidthRecipes(),
+    ...buildLineHeightRecipes(),
+    ...buildOpacityRecipes(),
+    ...buildZIndexRecipes(),
+    ...buildTypographyRecipes(),
+    ...buildMotionRecipes(),
+    ...buildShadowRecipes()
+  ];
+}
+function buildReference(seed) {
+  const recipes = allReferenceRecipes();
+  const tokens = {};
+  for (const recipe of recipes) tokens[recipe.cssVar] = evaluateDerivation(recipe.derivation, seed);
+  return {
+    recipes,
+    tokens,
+    shapes: {
+      shadow: {
+        sm: shadowShapeOf(seed, "sm"),
+        md: shadowShapeOf(seed, "md"),
+        lg: shadowShapeOf(seed, "lg")
+      }
+    }
+  };
+}
+
+// src/derive/semantic.ts
+function pick(tokens, dottedRefPath) {
+  const v = tokens[toVar("ref", dottedRefPath.split("."))];
+  if (v === void 0) throw new Error(`[qw] Semantic \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 Reference token: ${dottedRefPath}`);
+  return v;
+}
+function semVar(path) {
+  return toVar("sem", path);
+}
+var RADIUS_ROLES = {
+  control: "size.radius.md",
+  card: "size.radius.lg",
+  pill: "size.radius.full",
+  full: "size.radius.full"
+};
+var CONTROL_HEIGHT_ROLES = {
+  sm: "size.controlSize.sm",
+  md: "size.controlSize.md",
+  lg: "size.controlSize.lg"
+};
+var ICON_SIZE_ROLES = {
+  sm: "size.iconSize.sm",
+  md: "size.iconSize.md",
+  lg: "size.iconSize.lg"
+};
+var INSET_STACK_ROLES = {
+  sm: "size.spacing.2",
+  md: "size.spacing.4",
+  lg: "size.spacing.6"
+};
+var Z_INDEX_ROLES = {
+  dropdown: "size.zIndex.1",
+  sticky: "size.zIndex.2",
+  overlay: "size.zIndex.3",
+  toast: "size.zIndex.4"
+};
+var MOTION_DURATION_ROLES = {
+  fast: "motion.duration.fast",
+  base: "motion.duration.base",
+  slow: "motion.duration.slow"
+};
+var FONT_FAMILY_ROLES = {
+  text: "typography.fontFamily.text",
+  number: "typography.fontFamily.number",
+  code: "typography.fontFamily.code"
+};
+var T_LETTER = "typography.letterSpacing.base";
+var TYPOGRAPHY_ROLES = {
+  body: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.base",
+    fontWeightRef: "typography.fontWeight.regular",
+    lineHeightRef: "typography.lineHeight.normal",
+    letterSpacingRef: T_LETTER
+  },
+  bodyStrong: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.base",
+    fontWeightRef: "typography.fontWeight.medium",
+    lineHeightRef: "typography.lineHeight.normal",
+    letterSpacingRef: T_LETTER
+  },
+  headingSm: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.lg",
+    fontWeightRef: "typography.fontWeight.semibold",
+    lineHeightRef: "typography.lineHeight.tight",
+    letterSpacingRef: T_LETTER
+  },
+  headingMd: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.xl",
+    fontWeightRef: "typography.fontWeight.semibold",
+    lineHeightRef: "typography.lineHeight.tight",
+    letterSpacingRef: T_LETTER
+  },
+  headingLg: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.2xl",
+    fontWeightRef: "typography.fontWeight.semibold",
+    lineHeightRef: "typography.lineHeight.tight",
+    letterSpacingRef: T_LETTER
+  },
+  caption: {
+    fontFamilyRef: "typography.fontFamily.text",
+    fontSizeRef: "typography.fontSize.sm",
+    fontWeightRef: "typography.fontWeight.regular",
+    lineHeightRef: "typography.lineHeight.normal",
+    letterSpacingRef: T_LETTER
+  },
+  code: {
+    fontFamilyRef: "typography.fontFamily.code",
+    fontSizeRef: "typography.fontSize.sm",
+    fontWeightRef: "typography.fontWeight.regular",
+    lineHeightRef: "typography.lineHeight.normal",
+    letterSpacingRef: T_LETTER
+  }
+};
+var COLOR_ROLES = FIGMA_T3_COLOR_ROLES;
+var SHADOW_COMPOSITE_ROLES = {};
+function semanticRoleEntries() {
+  const out = [];
+  const structural = (path, refPath) => out.push({ kind: "structural", path: path.join("."), cssVar: semVar(path), refPath });
+  for (const [role, refPath] of Object.entries(RADIUS_ROLES)) structural(["size", "radius", role], refPath);
+  for (const [role, refPath] of Object.entries(CONTROL_HEIGHT_ROLES)) structural(["size", "controlHeight", role], refPath);
+  for (const [role, refPath] of Object.entries(ICON_SIZE_ROLES)) structural(["size", "iconSize", role], refPath);
+  for (const [role, refPath] of Object.entries(INSET_STACK_ROLES)) {
+    structural(["size", "inset", role], refPath);
+    structural(["size", "stack", role], refPath);
+  }
+  structural(["size", "opacity", "disabled"], "size.opacity.disabled");
+  for (const [role, refPath] of Object.entries(Z_INDEX_ROLES)) structural(["size", "zIndex", role], refPath);
+  for (const [role, refPath] of Object.entries(FONT_FAMILY_ROLES)) structural(["typography", "fontFamily", role], refPath);
+  for (const [role, spec] of Object.entries(TYPOGRAPHY_ROLES)) {
+    structural(["typography", role, "fontFamily"], spec.fontFamilyRef);
+    structural(["typography", role, "fontSize"], spec.fontSizeRef);
+    structural(["typography", role, "fontWeight"], spec.fontWeightRef);
+    structural(["typography", role, "lineHeight"], spec.lineHeightRef);
+    structural(["typography", role, "letterSpacing"], spec.letterSpacingRef);
+  }
+  for (const [role, refPath] of Object.entries(MOTION_DURATION_ROLES)) structural(["motion", "duration", role], refPath);
+  structural(["motion", "easing", "standard"], "motion.easing.standard");
+  for (const [path, refs] of Object.entries(COLOR_ROLES)) {
+    const segs = ["color", ...path.split(".")];
+    out.push({ kind: "color", path: segs.join("."), cssVar: semVar(segs), refPath: refs });
+  }
+  for (const [role, level] of Object.entries(SHADOW_COMPOSITE_ROLES)) {
+    const segs = ["effect", "shadow", role];
+    out.push({
+      kind: "shadowComposite",
+      path: segs.join("."),
+      cssVar: semVar(segs),
+      shapeRef: `effect.shadow.${level}`,
+      colorRole: "color.shadow"
+    });
+  }
+  return out;
+}
+function buildSemanticStructural(reference) {
+  const out = {};
+  const { tokens } = reference;
+  for (const entry of semanticRoleEntries()) {
+    if (entry.kind !== "structural") continue;
+    out[entry.cssVar] = pick(tokens, entry.refPath);
+  }
+  return out;
+}
+function buildSemanticColor(reference, mode) {
+  const out = {};
+  const { tokens, shapes } = reference;
+  for (const entry of semanticRoleEntries()) {
+    if (entry.kind !== "color") continue;
+    out[entry.cssVar] = pick(tokens, entry.refPath[mode]);
+  }
+  const shadowColor = out[semVar(["color", "shadow"])];
+  for (const [role, level] of Object.entries(SHADOW_COMPOSITE_ROLES)) {
+    const shape = shapes.shadow[level];
+    out[semVar(["effect", "shadow", role])] = `${shape.offsetX} ${shape.offsetY} ${shape.blur} ${shape.spread} ${shadowColor}`;
+  }
+  return out;
+}
+
+// src/derive/index.ts
+function derive(seed) {
+  const reference = buildReference(seed);
+  const structural = buildSemanticStructural(reference);
+  const mk = (mode) => ({
+    ...reference.tokens,
+    ...structural,
+    ...buildSemanticColor(reference, mode)
+  });
+  return { light: mk("light"), dark: mk("dark") };
+}
+
+// src/derive/live-css.ts
+var round4 = (n) => Math.round(n * 1e4) / 1e4;
+function seedVar(dotted) {
+  return toVar("seed", dotted.split("."));
+}
+function seedCssVars(seed) {
+  const out = {};
+  for (const [name, value] of Object.entries(seed.color)) {
+    out[seedVar(`color.${name}`)] = seedColorToCss(value);
+  }
+  out[seedVar("size.spacing.step")] = seed.size.spacing.step;
+  out[seedVar("size.borderWidth.hairline")] = seed.size.borderWidth.hairline;
+  out[seedVar("size.radius.base")] = seed.size.radius.base;
+  out[seedVar("size.radius.full")] = seed.size.radius.full;
+  out[seedVar("size.controlSize.base")] = seed.size.controlSize.base;
+  out[seedVar("size.iconSize.base")] = seed.size.iconSize.base;
+  out[seedVar("size.opacity.disabled")] = String(seed.size.opacity.disabled);
+  out[seedVar("size.opacity.alphaStep")] = String(seed.size.opacity.alphaStep);
+  out[seedVar("size.zIndex.step")] = String(seed.size.zIndex.step);
+  for (const key of FONT_FAMILY_KEYS) {
+    out[seedVar(`typography.fontFamily.${key}`)] = formatFontFamily(seed.typography.fontFamily[key]);
+  }
+  out[seedVar("typography.fontWeight.regular")] = String(seed.typography.fontWeight.regular);
+  out[seedVar("typography.fontWeight.medium")] = String(seed.typography.fontWeight.medium);
+  out[seedVar("typography.fontWeight.semibold")] = String(seed.typography.fontWeight.semibold);
+  out[seedVar("typography.fontSize.base")] = seed.typography.fontSize.base;
+  out[seedVar("typography.lineHeight.base")] = String(seed.typography.lineHeight.base);
+  out[seedVar("typography.letterSpacing.base")] = seed.typography.letterSpacing.base;
+  out[seedVar("motion.duration.base")] = seed.motion.duration.base;
+  const [a, b, c, d] = seed.motion.easing.standard;
+  out[seedVar("motion.easing.standard")] = `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
+  out[seedVar("effect.shadow.base.offsetX")] = seed.effect.shadow.base.offsetX;
+  out[seedVar("effect.shadow.base.offsetY")] = seed.effect.shadow.base.offsetY;
+  out[seedVar("effect.shadow.base.blur")] = seed.effect.shadow.base.blur;
+  out[seedVar("effect.shadow.base.spread")] = seed.effect.shadow.base.spread;
+  return out;
+}
+function shadowShapeExprs(level) {
+  const { offset, blur } = SHADOW_LEVELS[level];
+  const scale = (field, f) => `calc(var(${seedVar(`effect.shadow.base.${field}`)}) * ${f})`;
+  return {
+    offsetX: scale("offsetX", offset),
+    offsetY: scale("offsetY", offset),
+    blur: scale("blur", blur),
+    spread: scale("spread", offset)
+  };
+}
+function derivationToCssExpr(d) {
+  switch (d.kind) {
+    case "alias":
+    case "fontStack":
+    case "cubicBezier":
+      return `var(${seedVar(d.seedRef)})`;
+    case "scale": {
+      const expr = `calc(var(${seedVar(d.seedRef)}) * ${d.factor})`;
+      return d.round === "int" ? `round(nearest, ${expr}, 1px)` : expr;
+    }
+    case "scaleNumber":
+      return `calc(var(${seedVar(d.seedRef)}) * ${d.factor})`;
+    case "offsetNumber":
+      return `calc(var(${seedVar(d.seedRef)}) ${d.delta >= 0 ? "+" : "-"} ${Math.abs(d.delta)})`;
+    case "offsetSteps":
+      return `calc(var(${seedVar(d.seedRef)}) ${d.n >= 0 ? "+" : "-"} var(${seedVar(d.stepRef)}) * ${Math.abs(d.n)})`;
+    case "oklchRamp": {
+      const l = L_TARGETS[d.step];
+      const f = round4(chromaFactor(l));
+      return `oklch(from var(${seedVar(d.seedRef)}) ${l} calc(c * ${f}) h)`;
+    }
+    case "figmaOklchScale":
+      return d.value;
+    case "seedAlpha":
+      return `rgb(from var(${seedVar(d.seedRef)}) r g b / ${round4(d.alpha)})`;
+    case "alphaScale": {
+      const channel = d.channel === "black" ? "0 0 0" : "255 255 255";
+      return `rgb(${channel} / calc(var(${seedVar(d.stepRef)}) * ${d.multiplier}))`;
+    }
+    case "literal":
+      return d.value;
+    case "shadowLayer": {
+      const s2 = shadowShapeExprs(d.level);
+      const alpha = `calc(var(${seedVar("size.opacity.alphaStep")}) * ${SHADOW_LEVELS[d.level].alphaMult})`;
+      return `${s2.offsetX} ${s2.offsetY} ${s2.blur} ${s2.spread} rgb(0 0 0 / ${alpha})`;
+    }
+  }
+}
+function block(selector, decls) {
+  return `${selector} {
+${decls.map(([k, v]) => `  ${k}: ${v};`).join("\n")}
+}
+`;
+}
+function buildLiveCss(seed, options = {}) {
+  const selector = options.selector ?? ":root";
+  const darkSelector = options.darkSelector ?? '[data-qw-mode="dark"]';
+  const seedDecls = Object.entries(seedCssVars(seed));
+  const refDecls = allReferenceRecipes().map((r) => [
+    r.cssVar,
+    derivationToCssExpr(r.derivation)
+  ]);
+  const semLight = [];
+  const semDark = [];
+  for (const entry of semanticRoleEntries()) {
+    if (entry.kind === "structural") {
+      semLight.push([entry.cssVar, `var(${toVar("ref", entry.refPath.split("."))})`]);
+    } else if (entry.kind === "color") {
+      semLight.push([entry.cssVar, `var(${toVar("ref", entry.refPath.light.split("."))})`]);
+      if (entry.refPath.dark !== entry.refPath.light) {
+        semDark.push([entry.cssVar, `var(${toVar("ref", entry.refPath.dark.split("."))})`]);
+      }
+    } else {
+      const level = entry.shapeRef.split(".").pop();
+      const s2 = shadowShapeExprs(level);
+      semLight.push([
+        entry.cssVar,
+        `${s2.offsetX} ${s2.offsetY} ${s2.blur} ${s2.spread} var(${toVar("sem", entry.colorRole.split("."))})`
+      ]);
+    }
+  }
+  return [
+    "/* @qw-ui/tokens live \u2014 Seed \u53D8\u91CF\u9A71\u52A8\u7684\u54CD\u5E94\u5F0F\u6D3E\u751F\u6811\uFF08relative color / calc\uFF09\uFF0C\u8BF7\u52FF\u624B\u6539\u3002",
+    "   \u6539 --qw-seed-* \u5373\u7EA7\u8054\u6574\u68F5 ref/sem \u6811\uFF1B\u9700\u8981\u73B0\u4EE3\u6D4F\u89C8\u5668\uFF0C\u7EC4\u4EF6\u5E93\u6D88\u8D39\u65B9\u8BF7\u7528\u9759\u6001 tokens.css\u3002 */",
+    block(selector, [...seedDecls, ...refDecls, ...semLight]),
+    block(darkSelector, semDark)
+  ].join("\n");
+}
+
+export { COLOR_ROLES, FIGMA_COLOR_COLLECTION, FIGMA_COLOR_PREFIX, FIGMA_T1_SEED_HEX, FIGMA_T2_SOLID_SCALE, FIGMA_T3_COLOR_ROLES, L_TARGETS, RAMP_COLORS, SHADOW_COMPOSITE_ROLES, STEPS, SeedSchema, T1_COLOR_KEYS, T2_ALPHA_KEYS, T2_ALPHA_STEPS, T2_OKLCH_STEPS, TYPOGRAPHY_ROLES, allReferenceRecipes, buildLiveCss, buildReference, buildSemanticColor, buildSemanticStructural, contrastRatio, defaultSeed, derivationToCssExpr, derive, evaluateDerivation, formatDerivation, hexToSeedColor, ramp, seedColorToCss, seedColorToHex, seedCssVars, seedRefsOf, seedValueAt, semanticRoleEntries, toVar, validateSeed };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map