tunewind 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1614 @@
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import process from "node:process";
+import { createJiti } from "jiti";
+import { parse } from "postcss";
+// src/const/diagnostics.ts
+/** diagnostic levels of the dropped nodes */
+const DIAGNOSTIC_LEVELS = [
+	"off",
+	"warn",
+	"error"
+];
+// src/const/strict.ts
+/** strict mode names */
+const STRICT_MODES = ["bypass"];
+// src/const/tailwind.ts
+/** color family names of the tailwind default palette */
+const COLOR_FAMILIES = [
+	"amber",
+	"blue",
+	"cyan",
+	"emerald",
+	"fuchsia",
+	"gray",
+	"green",
+	"indigo",
+	"lime",
+	"mauve",
+	"mist",
+	"neutral",
+	"olive",
+	"orange",
+	"pink",
+	"purple",
+	"red",
+	"rose",
+	"sky",
+	"slate",
+	"stone",
+	"taupe",
+	"teal",
+	"violet",
+	"yellow",
+	"zinc"
+];
+/** shade numbers of the tailwind default palette */
+const COLOR_SHADES = [
+	50,
+	100,
+	200,
+	300,
+	400,
+	500,
+	600,
+	700,
+	800,
+	900,
+	950
+];
+/** flat colors */
+const FLAT_COLORS = {
+	white: "#fff",
+	black: "#000"
+};
+/** built-in breakpoint widths */
+const BREAKPOINTS = {
+	"sm": "640px",
+	"md": "768px",
+	"lg": "1024px",
+	"xl": "1280px",
+	"2xl": "1536px"
+};
+/** tailwind default palette */
+const PALETTE = {
+	amber: {
+		50: "oklch(98.7% 0.022 95.277)",
+		100: "oklch(96.2% 0.059 95.617)",
+		200: "oklch(92.4% 0.12 95.746)",
+		300: "oklch(87.9% 0.169 91.605)",
+		400: "oklch(82.8% 0.189 84.429)",
+		500: "oklch(76.9% 0.188 70.08)",
+		600: "oklch(66.6% 0.179 58.318)",
+		700: "oklch(55.5% 0.163 48.998)",
+		800: "oklch(47.3% 0.137 46.201)",
+		900: "oklch(41.4% 0.112 45.904)",
+		950: "oklch(27.9% 0.077 45.635)"
+	},
+	blue: {
+		50: "oklch(97% 0.014 254.604)",
+		100: "oklch(93.2% 0.032 255.585)",
+		200: "oklch(88.2% 0.059 254.128)",
+		300: "oklch(80.9% 0.105 251.813)",
+		400: "oklch(70.7% 0.165 254.624)",
+		500: "oklch(62.3% 0.214 259.815)",
+		600: "oklch(54.6% 0.245 262.881)",
+		700: "oklch(48.8% 0.243 264.376)",
+		800: "oklch(42.4% 0.199 265.638)",
+		900: "oklch(37.9% 0.146 265.522)",
+		950: "oklch(28.2% 0.091 267.935)"
+	},
+	cyan: {
+		50: "oklch(98.4% 0.019 200.873)",
+		100: "oklch(95.6% 0.045 203.388)",
+		200: "oklch(91.7% 0.08 205.041)",
+		300: "oklch(86.5% 0.127 207.078)",
+		400: "oklch(78.9% 0.154 211.53)",
+		500: "oklch(71.5% 0.143 215.221)",
+		600: "oklch(60.9% 0.126 221.723)",
+		700: "oklch(52% 0.105 223.128)",
+		800: "oklch(45% 0.085 224.283)",
+		900: "oklch(39.8% 0.07 227.392)",
+		950: "oklch(30.2% 0.056 229.695)"
+	},
+	emerald: {
+		50: "oklch(97.9% 0.021 166.113)",
+		100: "oklch(95% 0.052 163.051)",
+		200: "oklch(90.5% 0.093 164.15)",
+		300: "oklch(84.5% 0.143 164.978)",
+		400: "oklch(76.5% 0.177 163.223)",
+		500: "oklch(69.6% 0.17 162.48)",
+		600: "oklch(59.6% 0.145 163.225)",
+		700: "oklch(50.8% 0.118 165.612)",
+		800: "oklch(43.2% 0.095 166.913)",
+		900: "oklch(37.8% 0.077 168.94)",
+		950: "oklch(26.2% 0.051 172.552)"
+	},
+	fuchsia: {
+		50: "oklch(97.7% 0.017 320.058)",
+		100: "oklch(95.2% 0.037 318.852)",
+		200: "oklch(90.3% 0.076 319.62)",
+		300: "oklch(83.3% 0.145 321.434)",
+		400: "oklch(74% 0.238 322.16)",
+		500: "oklch(66.7% 0.295 322.15)",
+		600: "oklch(59.1% 0.293 322.896)",
+		700: "oklch(51.8% 0.253 323.949)",
+		800: "oklch(45.2% 0.211 324.591)",
+		900: "oklch(40.1% 0.17 325.612)",
+		950: "oklch(29.3% 0.136 325.661)"
+	},
+	gray: {
+		50: "oklch(98.5% 0.002 247.839)",
+		100: "oklch(96.7% 0.003 264.542)",
+		200: "oklch(92.8% 0.006 264.531)",
+		300: "oklch(87.2% 0.01 258.338)",
+		400: "oklch(70.7% 0.022 261.325)",
+		500: "oklch(55.1% 0.027 264.364)",
+		600: "oklch(44.6% 0.03 256.802)",
+		700: "oklch(37.3% 0.034 259.733)",
+		800: "oklch(27.8% 0.033 256.848)",
+		900: "oklch(21% 0.034 264.665)",
+		950: "oklch(13% 0.028 261.692)"
+	},
+	green: {
+		50: "oklch(98.2% 0.018 155.826)",
+		100: "oklch(96.2% 0.044 156.743)",
+		200: "oklch(92.5% 0.084 155.995)",
+		300: "oklch(87.1% 0.15 154.449)",
+		400: "oklch(79.2% 0.209 151.711)",
+		500: "oklch(72.3% 0.219 149.579)",
+		600: "oklch(62.7% 0.194 149.214)",
+		700: "oklch(52.7% 0.154 150.069)",
+		800: "oklch(44.8% 0.119 151.328)",
+		900: "oklch(39.3% 0.095 152.535)",
+		950: "oklch(26.6% 0.065 152.934)"
+	},
+	indigo: {
+		50: "oklch(96.2% 0.018 272.314)",
+		100: "oklch(93% 0.034 272.788)",
+		200: "oklch(87% 0.065 274.039)",
+		300: "oklch(78.5% 0.115 274.713)",
+		400: "oklch(67.3% 0.182 276.935)",
+		500: "oklch(58.5% 0.233 277.117)",
+		600: "oklch(51.1% 0.262 276.966)",
+		700: "oklch(45.7% 0.24 277.023)",
+		800: "oklch(39.8% 0.195 277.366)",
+		900: "oklch(35.9% 0.144 278.697)",
+		950: "oklch(25.7% 0.09 281.288)"
+	},
+	lime: {
+		50: "oklch(98.6% 0.031 120.757)",
+		100: "oklch(96.7% 0.067 122.328)",
+		200: "oklch(93.8% 0.127 124.321)",
+		300: "oklch(89.7% 0.196 126.665)",
+		400: "oklch(84.1% 0.238 128.85)",
+		500: "oklch(76.8% 0.233 130.85)",
+		600: "oklch(64.8% 0.2 131.684)",
+		700: "oklch(53.2% 0.157 131.589)",
+		800: "oklch(45.3% 0.124 130.933)",
+		900: "oklch(40.5% 0.101 131.063)",
+		950: "oklch(27.4% 0.072 132.109)"
+	},
+	mauve: {
+		50: "oklch(98.5% 0 none)",
+		100: "oklch(96% 0.003 325.6)",
+		200: "oklch(92.2% 0.005 325.62)",
+		300: "oklch(86.5% 0.012 325.68)",
+		400: "oklch(71.1% 0.019 323.02)",
+		500: "oklch(54.2% 0.034 322.5)",
+		600: "oklch(43.5% 0.029 321.78)",
+		700: "oklch(36.4% 0.029 323.89)",
+		800: "oklch(26.3% 0.024 320.12)",
+		900: "oklch(21.2% 0.019 322.12)",
+		950: "oklch(14.5% 0.008 326)"
+	},
+	mist: {
+		50: "oklch(98.7% 0.002 197.1)",
+		100: "oklch(96.3% 0.002 197.1)",
+		200: "oklch(92.5% 0.005 214.3)",
+		300: "oklch(87.2% 0.007 219.6)",
+		400: "oklch(72.3% 0.014 214.4)",
+		500: "oklch(56% 0.021 213.5)",
+		600: "oklch(45% 0.017 213.2)",
+		700: "oklch(37.8% 0.015 216)",
+		800: "oklch(27.5% 0.011 216.9)",
+		900: "oklch(21.8% 0.008 223.9)",
+		950: "oklch(14.8% 0.004 228.8)"
+	},
+	neutral: {
+		50: "oklch(98.5% 0 none)",
+		100: "oklch(97% 0 none)",
+		200: "oklch(92.2% 0 none)",
+		300: "oklch(87% 0 none)",
+		400: "oklch(70.8% 0 none)",
+		500: "oklch(55.6% 0 none)",
+		600: "oklch(43.9% 0 none)",
+		700: "oklch(37.1% 0 none)",
+		800: "oklch(26.9% 0 none)",
+		900: "oklch(20.5% 0 none)",
+		950: "oklch(14.5% 0 none)"
+	},
+	olive: {
+		50: "oklch(98.8% 0.003 106.5)",
+		100: "oklch(96.6% 0.005 106.5)",
+		200: "oklch(93% 0.007 106.5)",
+		300: "oklch(88% 0.011 106.6)",
+		400: "oklch(73.7% 0.021 106.9)",
+		500: "oklch(58% 0.031 107.3)",
+		600: "oklch(46.6% 0.025 107.3)",
+		700: "oklch(39.4% 0.023 107.4)",
+		800: "oklch(28.6% 0.016 107.4)",
+		900: "oklch(22.8% 0.013 107.4)",
+		950: "oklch(15.3% 0.006 107.1)"
+	},
+	orange: {
+		50: "oklch(98% 0.016 73.684)",
+		100: "oklch(95.4% 0.038 75.164)",
+		200: "oklch(90.1% 0.076 70.697)",
+		300: "oklch(83.7% 0.128 66.29)",
+		400: "oklch(75% 0.183 55.934)",
+		500: "oklch(70.5% 0.213 47.604)",
+		600: "oklch(64.6% 0.222 41.116)",
+		700: "oklch(55.3% 0.195 38.402)",
+		800: "oklch(47% 0.157 37.304)",
+		900: "oklch(40.8% 0.123 38.172)",
+		950: "oklch(26.6% 0.079 36.259)"
+	},
+	pink: {
+		50: "oklch(97.1% 0.014 343.198)",
+		100: "oklch(94.8% 0.028 342.258)",
+		200: "oklch(89.9% 0.061 343.231)",
+		300: "oklch(82.3% 0.12 346.018)",
+		400: "oklch(71.8% 0.202 349.761)",
+		500: "oklch(65.6% 0.241 354.308)",
+		600: "oklch(59.2% 0.249 0.584)",
+		700: "oklch(52.5% 0.223 3.958)",
+		800: "oklch(45.9% 0.187 3.815)",
+		900: "oklch(40.8% 0.153 2.432)",
+		950: "oklch(28.4% 0.109 3.907)"
+	},
+	purple: {
+		50: "oklch(97.7% 0.014 308.299)",
+		100: "oklch(94.6% 0.033 307.174)",
+		200: "oklch(90.2% 0.063 306.703)",
+		300: "oklch(82.7% 0.119 306.383)",
+		400: "oklch(71.4% 0.203 305.504)",
+		500: "oklch(62.7% 0.265 303.9)",
+		600: "oklch(55.8% 0.288 302.321)",
+		700: "oklch(49.6% 0.265 301.924)",
+		800: "oklch(43.8% 0.218 303.724)",
+		900: "oklch(38.1% 0.176 304.987)",
+		950: "oklch(29.1% 0.149 302.717)"
+	},
+	red: {
+		50: "oklch(97.1% 0.013 17.38)",
+		100: "oklch(93.6% 0.032 17.717)",
+		200: "oklch(88.5% 0.062 18.334)",
+		300: "oklch(80.8% 0.114 19.571)",
+		400: "oklch(70.4% 0.191 22.216)",
+		500: "oklch(63.7% 0.237 25.331)",
+		600: "oklch(57.7% 0.245 27.325)",
+		700: "oklch(50.5% 0.213 27.518)",
+		800: "oklch(44.4% 0.177 26.899)",
+		900: "oklch(39.6% 0.141 25.723)",
+		950: "oklch(25.8% 0.092 26.042)"
+	},
+	rose: {
+		50: "oklch(96.9% 0.015 12.422)",
+		100: "oklch(94.1% 0.03 12.58)",
+		200: "oklch(89.2% 0.058 10.001)",
+		300: "oklch(81% 0.117 11.638)",
+		400: "oklch(71.2% 0.194 13.428)",
+		500: "oklch(64.5% 0.246 16.439)",
+		600: "oklch(58.6% 0.253 17.585)",
+		700: "oklch(51.4% 0.222 16.935)",
+		800: "oklch(45.5% 0.188 13.697)",
+		900: "oklch(41% 0.159 10.272)",
+		950: "oklch(27.1% 0.105 12.094)"
+	},
+	sky: {
+		50: "oklch(97.7% 0.013 236.62)",
+		100: "oklch(95.1% 0.026 236.824)",
+		200: "oklch(90.1% 0.058 230.902)",
+		300: "oklch(82.8% 0.111 230.318)",
+		400: "oklch(74.6% 0.16 232.661)",
+		500: "oklch(68.5% 0.169 237.323)",
+		600: "oklch(58.8% 0.158 241.966)",
+		700: "oklch(50% 0.134 242.749)",
+		800: "oklch(44.3% 0.11 240.79)",
+		900: "oklch(39.1% 0.09 240.876)",
+		950: "oklch(29.3% 0.066 243.157)"
+	},
+	slate: {
+		50: "oklch(98.4% 0.003 247.858)",
+		100: "oklch(96.8% 0.007 247.896)",
+		200: "oklch(92.9% 0.013 255.508)",
+		300: "oklch(86.9% 0.022 252.894)",
+		400: "oklch(70.4% 0.04 256.788)",
+		500: "oklch(55.4% 0.046 257.417)",
+		600: "oklch(44.6% 0.043 257.281)",
+		700: "oklch(37.2% 0.044 257.287)",
+		800: "oklch(27.9% 0.041 260.031)",
+		900: "oklch(20.8% 0.042 265.755)",
+		950: "oklch(12.9% 0.042 264.695)"
+	},
+	stone: {
+		50: "oklch(98.5% 0.001 106.423)",
+		100: "oklch(97% 0.001 106.424)",
+		200: "oklch(92.3% 0.003 48.717)",
+		300: "oklch(86.9% 0.005 56.366)",
+		400: "oklch(70.9% 0.01 56.259)",
+		500: "oklch(55.3% 0.013 58.071)",
+		600: "oklch(44.4% 0.011 73.639)",
+		700: "oklch(37.4% 0.01 67.558)",
+		800: "oklch(26.8% 0.007 34.298)",
+		900: "oklch(21.6% 0.006 56.043)",
+		950: "oklch(14.7% 0.004 49.25)"
+	},
+	taupe: {
+		50: "oklch(98.6% 0.002 67.8)",
+		100: "oklch(96% 0.002 17.2)",
+		200: "oklch(92.2% 0.005 34.3)",
+		300: "oklch(86.8% 0.007 39.5)",
+		400: "oklch(71.4% 0.014 41.2)",
+		500: "oklch(54.7% 0.021 43.1)",
+		600: "oklch(43.8% 0.017 39.3)",
+		700: "oklch(36.7% 0.016 35.7)",
+		800: "oklch(26.8% 0.011 36.5)",
+		900: "oklch(21.4% 0.009 43.1)",
+		950: "oklch(14.7% 0.004 49.3)"
+	},
+	teal: {
+		50: "oklch(98.4% 0.014 180.72)",
+		100: "oklch(95.3% 0.051 180.801)",
+		200: "oklch(91% 0.096 180.426)",
+		300: "oklch(85.5% 0.138 181.071)",
+		400: "oklch(77.7% 0.152 181.912)",
+		500: "oklch(70.4% 0.14 182.503)",
+		600: "oklch(60% 0.118 184.704)",
+		700: "oklch(51.1% 0.096 186.391)",
+		800: "oklch(43.7% 0.078 188.216)",
+		900: "oklch(38.6% 0.063 188.416)",
+		950: "oklch(27.7% 0.046 192.524)"
+	},
+	violet: {
+		50: "oklch(96.9% 0.016 293.756)",
+		100: "oklch(94.3% 0.029 294.588)",
+		200: "oklch(89.4% 0.057 293.283)",
+		300: "oklch(81.1% 0.111 293.571)",
+		400: "oklch(70.2% 0.183 293.541)",
+		500: "oklch(60.6% 0.25 292.717)",
+		600: "oklch(54.1% 0.281 293.009)",
+		700: "oklch(49.1% 0.27 292.581)",
+		800: "oklch(43.2% 0.232 292.759)",
+		900: "oklch(38% 0.189 293.745)",
+		950: "oklch(28.3% 0.141 291.089)"
+	},
+	yellow: {
+		50: "oklch(98.7% 0.026 102.212)",
+		100: "oklch(97.3% 0.071 103.193)",
+		200: "oklch(94.5% 0.129 101.54)",
+		300: "oklch(90.5% 0.182 98.111)",
+		400: "oklch(85.2% 0.199 91.936)",
+		500: "oklch(79.5% 0.184 86.047)",
+		600: "oklch(68.1% 0.162 75.834)",
+		700: "oklch(55.4% 0.135 66.442)",
+		800: "oklch(47.6% 0.114 61.907)",
+		900: "oklch(42.1% 0.095 57.708)",
+		950: "oklch(28.6% 0.066 53.813)"
+	},
+	zinc: {
+		50: "oklch(98.5% 0 none)",
+		100: "oklch(96.7% 0.001 286.375)",
+		200: "oklch(92% 0.004 286.32)",
+		300: "oklch(87.1% 0.006 286.286)",
+		400: "oklch(70.5% 0.015 286.067)",
+		500: "oklch(55.2% 0.016 285.938)",
+		600: "oklch(44.2% 0.017 285.786)",
+		700: "oklch(37% 0.013 285.805)",
+		800: "oklch(27.4% 0.006 286.033)",
+		900: "oklch(21% 0.006 285.885)",
+		950: "oklch(14.1% 0.005 285.823)"
+	}
+};
+// src/text/index.ts
+const text = {
+	config: {
+		keyFormat: "key must match [A-Za-z0-9_]+",
+		colorScaleEmpty: "color scale must define at least one shade",
+		defaultUnitRequired: "units must define a default unit",
+		fileNotFound: (cwd, files) => `tune config not found in ${cwd}, expected one of ${files.join(", ")}`,
+		defaultExportRequired: (file) => `${file} must export default config`,
+		invalid: (file, detail) => `invalid tune config in ${file}\n${detail}`
+	},
+	postprocess: {
+		walkIncomplete: (visited, total) => `walk visited ${visited} of ${total} nodes`,
+		/** reason phrases given by the checks */
+		reason: {
+			arbitrary: "arbitrary value is not allowed",
+			family: "raw color family is not allowed",
+			opacity: "opacity outside the theme keys",
+			size: "size outside the breakpoint unit range"
+		},
+		/** one dropped node */
+		dropped: (reason, target, owner) => owner ? `dropped ${target} in ${owner} (${reason})` : `dropped ${target} (${reason})`,
+		/** prefix of one warning line */
+		warn: (line) => `tunewind: ${line}`,
+		/** header of an error listing several lines */
+		summary: (count) => `tunewind: ${count} violations`,
+		/** tail of a list cut by the limit */
+		more: (count) => `... and ${count} more`
+	},
+	preprocess: {
+		breakpointDuplicated: (first, second) => `breakpoints "${first}" and "${second}" have the same width`,
+		breakpointPrefixDuplicated: (first, second) => `breakpoints "${first}" and "${second}" share the same prefix`,
+		breakpointWidthMissing: (breakpoint) => `breakpoint "${breakpoint}" has no width and no built-in width`,
+		maxMissing: (unit) => `size unit "${unit}" has no max`,
+		rangeReversed: (unit) => `size unit "${unit}" has larger min than max`,
+		shadeMissing: (family, shade) => `color family "${family}" has no shade ${shade}`,
+		themeDuplicated: (theme) => `theme "${theme}" is defined more than once`,
+		unknownUnit: (breakpoint, unit) => `breakpoint "${breakpoint}" overrides unknown unit "${unit}"`
+	}
+};
+// src/config/schema.ts
+/** css length with an explicit unit, such as `4px` or `1rem` */
+const cssLength = z.string().regex(/^(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem)$/);
+/** any css color value */
+const colorValue = z.string().min(1);
+/** config key, limited to word characters */
+const keySchema = z.string().regex(/^\w+$/, { message: text.config.keyFormat });
+/** built-in color family name */
+const colorFamilySchema = z.enum(COLOR_FAMILIES);
+/** built-in shade number */
+const colorShadeSchema = z.literal(COLOR_SHADES);
+/** color family scale, shade number to color value */
+const colorScaleSchema = z.record(z.string().regex(/^\d+$/), colorValue).refine((scale) => Object.keys(scale).length > 0, { message: text.config.colorScaleEmpty });
+/** palette entry, an alias to a built-in family or an explicit scale */
+const paletteEntrySchema = z.union([colorFamilySchema, colorScaleSchema]);
+/** color families, alias name to family or scale */
+const paletteSchema = z.record(keySchema, paletteEntrySchema);
+/** shade mapping, semantic key to shade number */
+const shadeSchema = z.record(keySchema, colorShadeSchema);
+/** opacity mapping, semantic key to percentage */
+const opacitySchema = z.record(keySchema, z.number().min(0).max(100));
+/** color scheme, overriding the global layers */
+const schemeSchema = z.strictObject({
+	/** variant prefix, such as `dark` for `dark:bg-primary` */
+	prefix: z.string().min(1).optional(),
+	/** scheme palette */
+	palette: paletteSchema.optional(),
+	/** scheme shade mapping */
+	shade: shadeSchema.optional(),
+	/** scheme opacity mapping */
+	opacity: opacitySchema.optional()
+});
+/** color theme, global layers plus named schemes */
+const themeSchema = z.strictObject({
+	/** global palette */
+	palette: paletteSchema.optional(),
+	/** global shade mapping */
+	shade: shadeSchema.optional(),
+	/** global opacity mapping */
+	opacity: opacitySchema.optional(),
+	/** named schemes, key to scheme */
+	schemes: z.record(keySchema, schemeSchema).optional()
+});
+/** size unit, a plain length or a constrained length */
+const unitSchema = z.union([cssLength, z.strictObject({
+	/** unit length */
+	value: cssLength,
+	/** smallest usable number */
+	min: z.number().min(0).optional(),
+	/** allowed size number precision */
+	step: z.number().positive().optional(),
+	/** allowed size number upper bound */
+	max: z.number().positive().optional()
+})]);
+/** breakpoint, a plain width or a width with unit overrides */
+const breakpointSchema = z.union([cssLength, z.strictObject({
+	/** variant name, the key when omitted */
+	prefix: z.string().min(1).optional(),
+	/** breakpoint width, the built-in width when omitted */
+	value: cssLength.optional(),
+	/** units redefined in this breakpoint */
+	units: z.record(keySchema, unitSchema).optional()
+})]);
+/** size system, units and breakpoints */
+const sizeSchema = z.strictObject({
+	/** default smallest usable number for all units */
+	min: z.number().min(0).optional(),
+	/** default size number precision for all units */
+	step: z.number().positive().optional(),
+	/** default size number upper bound for all units */
+	max: z.number().positive().optional(),
+	/** units, key to unit, must define a `default` unit */
+	units: z.record(keySchema, unitSchema).refine((units) => "default" in units, { message: text.config.defaultUnitRequired }),
+	/** breakpoints, key to breakpoint */
+	breakpoints: z.record(keySchema, breakpointSchema).optional()
+});
+/** strict flags, every key allows the listed escape */
+const strictFlagsSchema = z.strictObject({
+	/** allow arbitrary values such as `w-[123px]` */
+	arbitrary: z.boolean().optional(),
+	/** allow raw color family names such as `text-sky-600` */
+	family: z.boolean().optional(),
+	/** allow the raw prefix to bypass the postprocess stage */
+	bypass: z.boolean().optional()
+});
+/** strict mode, a switch, a mode name, or explicit flags */
+const strictSchema = z.union([
+	z.boolean(),
+	z.enum(STRICT_MODES),
+	strictFlagsSchema
+]);
+/** diagnostic level, silent when omitted */
+const diagnosticsSchema = z.union([z.enum(DIAGNOSTIC_LEVELS), z.strictObject({
+	/** diagnostic level */
+	mode: z.enum(DIAGNOSTIC_LEVELS),
+	/** most lines reported, defaults to the built-in limit */
+	limit: z.number().int().positive().optional()
+})]);
+/** tunewind config */
+const configSchema = z.strictObject({
+	/** color theme */
+	theme: themeSchema.optional(),
+	/** size system */
+	size: sizeSchema.optional(),
+	/** strict mode */
+	strict: strictSchema.optional(),
+	/** diagnostic level of the dropped nodes */
+	diagnostics: diagnosticsSchema.optional()
+});
+// src/config/define.ts
+function defineConfig(input) {
+	return configSchema.parse(input);
+}
+// src/const/config.ts
+/** config file names, resolved in order */
+const CONFIG_FILES = [
+	"tune.config.ts",
+	"tune.config.mts",
+	"tune.config.js",
+	"tune.config.mjs"
+];
+// src/plugins/output.ts
+/** one expected failure of the build */
+var TuneError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TuneError";
+	}
+};
+/** read the message of an unknown thrown value */
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** sink of the build in progress */
+let sink;
+const output = {
+	/** attach the sink of the build in progress */
+	bind: (next) => {
+		sink = next;
+	},
+	/** stop the build */
+	error: (message) => {
+		throw new TuneError(message);
+	},
+	/** report a non-fatal line, a missing sink escalates to an error */
+	warn: (line) => {
+		if (sink === void 0) output.error(line);
+		sink.warn(line);
+	}
+};
+// src/config/loader.ts
+/** extensions tried when resolving an imported config file */
+const IMPORT_EXTENSIONS = [
+	"",
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+];
+/** import forms a config may use for a local file */
+const IMPORT_PATTERN = /(?:from|import|require)[\s(]*["']([^"']+)["']/g;
+/** shared loader, evaluating the config source on every call */
+const jiti = createJiti(import.meta.url, {
+	fsCache: false,
+	moduleCache: false
+});
+function findConfigFile(cwd = process.cwd()) {
+	for (const name of CONFIG_FILES) {
+		const file = resolve(cwd, name);
+		if (existsSync(file)) return file;
+	}
+}
+/** resolve one local import of a config file */
+function resolveImport(from, specifier) {
+	const base = resolve(dirname(from), specifier);
+	for (const extension of IMPORT_EXTENSIONS) {
+		const file = `${base}${extension}`;
+		if (existsSync(file)) return file;
+	}
+}
+/** collect the local files a config imports, depth first */
+function collectDependencies(file, found) {
+	if (found.has(file)) return;
+	found.add(file);
+	let source;
+	try {
+		source = readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+	for (const match of source.matchAll(IMPORT_PATTERN)) {
+		const specifier = match[1];
+		if (!specifier.startsWith(".")) continue;
+		const target = resolveImport(file, specifier);
+		if (target !== void 0) collectDependencies(target, found);
+	}
+}
+/** find the config file and every local file it imports */
+function findConfigDependencies(file) {
+	const found = /* @__PURE__ */ new Set();
+	collectDependencies(file, found);
+	return Array.from(found);
+}
+async function loadConfig(cwd = process.cwd()) {
+	const file = findConfigFile(cwd);
+	if (!file) output.error(text.config.fileNotFound(cwd, CONFIG_FILES));
+	const source = await readFile(file, "utf8");
+	const mod = jiti.evalModule(source, {
+		filename: file,
+		id: file
+	});
+	const input = mod.default ?? mod.config;
+	if (input === void 0) output.error(text.config.defaultExportRequired(file));
+	try {
+		return {
+			config: configSchema.parse(input),
+			dependencies: findConfigDependencies(file)
+		};
+	} catch (error) {
+		if (error instanceof z.ZodError) output.error(text.config.invalid(file, z.prettifyError(error)));
+		throw error;
+	}
+}
+// src/const/postcss.ts
+/** postcss plugin name of the preprocess plugin */
+const PREPROCESS_PLUGIN_NAME = "tunewind-preprocess";
+/** postcss plugin name of the postprocess plugin */
+const POSTPROCESS_PLUGIN_NAME = "tunewind-postprocess";
+/** at-rule replaced by the generated css */
+const AT_RULE_NAME = "tunewind";
+/** node types of the postcss ast */
+const NODE_TYPES = {
+	root: "root",
+	rule: "rule",
+	atRule: "atrule",
+	declaration: "decl",
+	comment: "comment"
+};
+/** at-rules removed when they lose every child */
+const EMPTY_AT_RULES = [
+	"media",
+	"supports",
+	"container",
+	"layer"
+];
+/** at-rules whose content never takes part in the checks */
+const BLOCKED_AT_RULES = [
+	"keyframes",
+	"font-face",
+	"page",
+	"property"
+];
+// src/postprocess/plugins/utils.ts
+/** whether the node sits in the given cascade layer */
+function hasLayer(atRules, name) {
+	return atRules.some((rule) => rule.name === "layer" && rule.params.split(",").some((part) => part.trim() === name));
+}
+// src/postprocess/plugins/arbitrary.ts
+/** drop every selector holding an arbitrary value */
+function createArbitraryPlugin() {
+	return { rule: (context) => {
+		if (!hasLayer(context.atRules, "utilities")) return;
+		if (context.bypassed()) return;
+		const hit = context.selectors().filter((item) => item.raw.includes("\\["));
+		if (hit.length > 0) context.dropSelectors(hit, text.postprocess.reason.arbitrary);
+	} };
+}
+// src/postprocess/plugins/family.ts
+/** collect the color variables that only exist under their raw family name */
+function collectRawVars(theme) {
+	const aliases = new Set(Object.keys(theme.palette ?? {}));
+	const keys = new Set(Object.keys(theme.shade ?? {}));
+	for (const scheme of Object.values(theme.schemes ?? {})) {
+		for (const name of Object.keys(scheme.palette ?? {})) aliases.add(name);
+		for (const key of Object.keys(scheme.shade ?? {})) keys.add(key);
+	}
+	const vars = /* @__PURE__ */ new Set();
+	for (const family of COLOR_FAMILIES) {
+		if (aliases.has(family)) continue;
+		for (const key of keys) vars.add(key === "default" ? `--color-${family}` : `--color-${family}-${key}`);
+	}
+	return vars;
+}
+/** drop every declaration referencing a raw color family name */
+function createFamilyPlugin(theme) {
+	const vars = collectRawVars(theme);
+	return { declaration: (context) => {
+		if (!hasLayer(context.atRules, "utilities")) return;
+		if (context.bypassed()) return;
+		if (context.variables().some((name) => vars.has(name))) context.drop(text.postprocess.reason.family);
+	} };
+}
+// src/postprocess/plugins/opacity.ts
+/** bodies of every call of a function, in order of appearance */
+function callBodies(value, name) {
+	const bodies = [];
+	const head = `${name}(`;
+	let from = 0;
+	while (true) {
+		const start = value.indexOf(head, from);
+		if (start < 0) break;
+		let depth = 1;
+		let end = start + head.length;
+		for (; end < value.length; end += 1) {
+			const char = value[end];
+			if (char === "(") depth += 1;
+			else if (char === ")") {
+				depth -= 1;
+				if (depth === 0) break;
+			}
+		}
+		bodies.push(value.slice(start + head.length, end));
+		from = end + 1;
+	}
+	return bodies;
+}
+/** split a call body by the commas outside brackets */
+function splitArgs(body) {
+	const args = [];
+	let depth = 0;
+	let start = 0;
+	for (let index = 0; index < body.length; index += 1) {
+		const char = body[index];
+		if (char === "(" || char === "[") depth += 1;
+		else if (char === ")" || char === "]") depth -= 1;
+		else if (char === "," && depth === 0) {
+			args.push(body.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	args.push(body.slice(start).trim());
+	return args;
+}
+/** trailing token of a value holding several, absent when it holds one */
+function trailingToken(value) {
+	const text = value.trim();
+	let depth = 0;
+	for (let index = text.length - 1; index >= 0; index -= 1) {
+		const char = text[index];
+		if (char === ")") depth += 1;
+		else if (char === "(") depth -= 1;
+		else if (/\s/.test(char) && depth === 0) return text.slice(index + 1);
+	}
+}
+/** whether a slot is a literal percentage */
+function isLiteral(slot) {
+	return /^[\d.]+%$/.test(slot.trim());
+}
+/** whether any opacity slot of a value is a literal percentage */
+function hasLiteralSlot(value) {
+	for (const body of callBodies(value, "color-mix")) {
+		const args = splitArgs(body);
+		if (args.length !== 3 || args[2] !== "transparent") continue;
+		const amount = trailingToken(args[1]);
+		if (amount !== void 0 && isLiteral(amount)) return true;
+	}
+	for (const body of callBodies(value, "opacity")) if (isLiteral(body)) return true;
+	return false;
+}
+/** whether a declaration applies an opacity outside the allowed keys */
+function hasLiteralOpacity(declaration) {
+	if (declaration.prop === "opacity") return isLiteral(declaration.value);
+	return hasLiteralSlot(declaration.value);
+}
+/** drop every declaration whose opacity does not come from a theme key */
+function createOpacityPlugin() {
+	return { declaration: (context) => {
+		if (!hasLayer(context.atRules, "utilities")) return;
+		if (hasLiteralOpacity(context.declaration)) context.drop(text.postprocess.reason.opacity);
+	} };
+}
+// src/postprocess/scan/utils.ts
+/** fallback of an invalid code point */
+const REPLACEMENT = "�";
+/** turn a code point into a character, invalid ones become the replacement */
+function codePoint(code) {
+	if (code <= 0 || code > 1114111) return REPLACEMENT;
+	return String.fromCodePoint(code);
+}
+/** collect the matches of a value, once each */
+function collect(value, pattern) {
+	const found = /* @__PURE__ */ new Set();
+	for (const match of value.matchAll(pattern)) found.add(match[1]);
+	return [...found];
+}
+/** unescape the css escapes of a selector */
+function unescape(text) {
+	let result = "";
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (char !== "\\") {
+			result += char;
+			continue;
+		}
+		const hex = /^[\da-f]{1,6}/i.exec(text.slice(index + 1));
+		if (hex) {
+			result += codePoint(Number.parseInt(hex[0], 16));
+			index += hex[0].length;
+			if (text[index + 1] === " ") index += 1;
+			continue;
+		}
+		if (index + 1 < text.length) {
+			result += text[index + 1];
+			index += 1;
+		}
+	}
+	return result;
+}
+/** split by a separator outside brackets, skipping escaped characters */
+function splitTopLevel(text, separator) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	let escaped = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "(" || char === "[") {
+			depth += 1;
+			continue;
+		}
+		if (char === ")" || char === "]") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (char === separator && depth === 0) {
+			parts.push(text.slice(start, index));
+			start = index + 1;
+		}
+	}
+	parts.push(text.slice(start));
+	return parts;
+}
+/** build one selector item from a part of a selector list */
+function toSelectorItem(part) {
+	const raw = part.trim();
+	let text = unescape(raw);
+	if (text.startsWith(".")) text = text.slice(1);
+	return {
+		raw,
+		text,
+		segments: splitTopLevel(text, ":")
+	};
+}
+/** collect the `var()` references of a value, escapes kept as written */
+function variablesOf(value) {
+	return collect(value, /var\(\s*(--(?:[\w-]|\\[^\n])+)/g);
+}
+// src/postprocess/plugins/size.ts
+/** prefix of the spacing keys */
+const SPACING_PREFIX = "--spacing-";
+/** min widths of the media at-rules, cached by node */
+const WIDTHS = /* @__PURE__ */ new WeakMap();
+/** convert a css length into pixels */
+function toPixels$1(length) {
+	return length.endsWith("rem") ? Number.parseFloat(length) * 16 : Number.parseFloat(length);
+}
+/** read the range of a unit, patched over the previous range */
+function rangeOf(unit, size, previous) {
+	const options = typeof unit === "string" ? void 0 : unit;
+	const max = options?.max ?? previous?.max ?? size.max;
+	const min = options?.min ?? previous?.min ?? size.min ?? 0;
+	if (max === void 0 || min > max) return void 0;
+	return {
+		min,
+		max,
+		step: options?.step ?? previous?.step ?? size.step ?? 1
+	};
+}
+/** patch the ranges of a scope, field by field */
+function patchRanges(scope, patch, size) {
+	const next = new Map(scope);
+	for (const [name, unit] of Object.entries(patch)) {
+		const range = rangeOf(unit, size, scope.get(name));
+		if (range !== void 0) next.set(name, range);
+	}
+	return next;
+}
+/** read the breakpoints ordered by width */
+function parseBreakpoints$1(size) {
+	const parsed = [];
+	for (const [name, breakpoint] of Object.entries(size.breakpoints ?? {})) {
+		const options = typeof breakpoint === "string" ? void 0 : breakpoint;
+		const width = options?.value ?? BREAKPOINTS[name];
+		if (width === void 0) continue;
+		parsed.push({
+			width,
+			units: options?.units ?? {}
+		});
+	}
+	return parsed.sort((a, b) => toPixels$1(a.width) - toPixels$1(b.width));
+}
+/** build the width to unit ranges table of the configured breakpoints */
+function buildScopes(size) {
+	const scopes = /* @__PURE__ */ new Map();
+	let current = patchRanges(/* @__PURE__ */ new Map(), size.units, size);
+	for (const breakpoint of parseBreakpoints$1(size)) {
+		current = patchRanges(current, breakpoint.units, size);
+		scopes.set(toPixels$1(breakpoint.width), current);
+	}
+	return scopes;
+}
+/** min width in pixels of a media query, absent when it has none */
+function minWidthOf(query) {
+	const body = query.replace(/[()\s]/g, "");
+	if (body.startsWith("min-width:")) return toPixels$1(body.slice(10));
+	if (body.startsWith("width>=")) return toPixels$1(body.slice(7));
+}
+/** min width in pixels of a media at-rule, cached by node */
+function widthOf(atRule) {
+	const cached = WIDTHS.get(atRule);
+	if (cached !== void 0) return cached ?? void 0;
+	const width = minWidthOf(atRule.params);
+	WIDTHS.set(atRule, width ?? null);
+	return width;
+}
+/** ranges of the widest matching breakpoint among the enclosing at-rules */
+function scopeOf(atRules, scopes) {
+	let found;
+	let widest = -1;
+	for (const atRule of atRules) {
+		if (atRule.name !== "media") continue;
+		const width = widthOf(atRule);
+		if (width === void 0 || width <= widest) continue;
+		const scope = scopes.get(width);
+		if (scope === void 0) continue;
+		widest = width;
+		found = scope;
+	}
+	return found;
+}
+/** whether a value stays inside the range of a unit */
+function inRange(value, range) {
+	if (value === 0) return true;
+	const steps = value / range.step;
+	const index = Math.round(steps);
+	if (Math.abs(steps - index) > 1e-6) return false;
+	return index >= Math.ceil(range.min / range.step) && index <= Math.floor(range.max / range.step);
+}
+/** read the number and the range of a spacing reference */
+function spacingOf(name, scope) {
+	const plain = unescape(name);
+	if (!plain.startsWith(SPACING_PREFIX)) return void 0;
+	const body = plain.slice(10);
+	let matched;
+	for (const [unit, range] of scope) {
+		const suffix = unit === "default" ? "" : unit;
+		if (!body.endsWith(suffix)) continue;
+		if (matched !== void 0 && matched.suffix.length >= suffix.length) continue;
+		matched = {
+			suffix,
+			range
+		};
+	}
+	if (matched === void 0) return void 0;
+	const digits = body.slice(0, body.length - matched.suffix.length);
+	if (digits === "") return void 0;
+	const value = Number(digits);
+	if (!Number.isFinite(value)) return void 0;
+	return {
+		value,
+		range: matched.range
+	};
+}
+/** whether a variable reference breaks the unit range of the scope */
+function isOutside(name, scope) {
+	const spacing = spacingOf(name, scope);
+	if (spacing === void 0) return false;
+	return !inRange(spacing.value, spacing.range);
+}
+/** drop every declaration whose size breaks the range of its breakpoint */
+function createSizePlugin(size) {
+	const scopes = buildScopes(size);
+	return { declaration: (context) => {
+		if (!hasLayer(context.atRules, "utilities")) return;
+		const scope = scopeOf(context.atRules, scopes);
+		if (scope === void 0) return;
+		if (context.variables().some((name) => isOutside(name, scope))) context.drop(text.postprocess.reason.size);
+	} };
+}
+// src/postprocess/scan/context.ts
+/** selector lists already split, keyed by rule */
+const SELECTORS = /* @__PURE__ */ new WeakMap();
+/** split the selector list of a rule, reusing the split of the same rule */
+function selectorsOf(rule) {
+	const cached = SELECTORS.get(rule);
+	if (cached) return cached;
+	const items = splitTopLevel(rule.selector, ",").map(toSelectorItem);
+	SELECTORS.set(rule, items);
+	return items;
+}
+/** whether the bypass marker of a rule exempts its nodes */
+function isBypassed(rule, enabled) {
+	if (!enabled) return false;
+	return selectorsOf(rule).some((item) => item.segments.includes("raw"));
+}
+/** build the context of a scanned rule */
+function createRuleContext(rule, atRules, recorder, bypass) {
+	return {
+		rule,
+		atRules,
+		selectors: () => selectorsOf(rule),
+		bypassed: () => isBypassed(rule, bypass),
+		drop: (reason) => {
+			recorder.rules.add(rule);
+			recorder.reports.push(text.postprocess.dropped(reason, rule.selector));
+		},
+		dropSelectors: (items, reason) => {
+			const dropped = recorder.selectors.get(rule) ?? /* @__PURE__ */ new Set();
+			for (const item of items) {
+				dropped.add(item);
+				recorder.reports.push(text.postprocess.dropped(reason, item.raw));
+			}
+			recorder.selectors.set(rule, dropped);
+		}
+	};
+}
+/** build the context of a scanned declaration */
+function createDeclarationContext(declaration, rule, atRules, recorder, bypass) {
+	return {
+		declaration,
+		rule,
+		atRules,
+		variables: () => variablesOf(declaration.value),
+		bypassed: () => isBypassed(rule, bypass),
+		drop: (reason) => {
+			recorder.declarations.add(declaration);
+			recorder.reports.push(text.postprocess.dropped(reason, `${declaration.prop}: ${declaration.value}`, rule.selector));
+		}
+	};
+}
+// src/postprocess/scan/commit.ts
+/** whether a container kind is removable once emptied */
+function cleanable(node) {
+	if (node.type === NODE_TYPES.rule) return true;
+	return EMPTY_AT_RULES.includes(node.name);
+}
+/** whether a container belongs to a removable kind */
+function prunable(node) {
+	return node.type === NODE_TYPES.rule || node.type === NODE_TYPES.atRule;
+}
+/** remove the containers emptied by the last removal, climbing up */
+function clean(start) {
+	let current = start;
+	while (current.parent && prunable(current) && cleanable(current) && current.nodes?.length === 0) {
+		const parent = current.parent;
+		current.remove();
+		current = parent;
+	}
+}
+/** remove one node, then clean up what it leaves empty */
+function remove(node) {
+	const parent = node.parent;
+	node.remove();
+	if (parent) clean(parent);
+}
+/** apply the recorded deletions, cleaning the nodes they empty */
+function commit(recorder) {
+	for (const [rule, dropped] of recorder.selectors) {
+		if (!rule.parent) continue;
+		const kept = selectorsOf(rule).filter((item) => !dropped.has(item));
+		if (kept.length === 0) {
+			remove(rule);
+			continue;
+		}
+		rule.selector = kept.map((item) => item.raw).join(", ");
+	}
+	for (const rule of recorder.rules) if (rule.parent) remove(rule);
+	for (const declaration of recorder.declarations) if (declaration.parent) remove(declaration);
+}
+// src/postprocess/scan/walk.ts
+/** extend the at-rule stack with one block */
+function enterAtRule(atRule, atRules) {
+	return atRules.concat(atRule);
+}
+/** dispatch the plugins over the subtree of a container, returning the node count */
+function visit(container, scope, plugins, recorder, bypass) {
+	const active = scope.blocked ? [] : plugins;
+	let count = 0;
+	for (const child of container.nodes ?? []) {
+		count += 1;
+		if (child.type === NODE_TYPES.rule) {
+			const context = createRuleContext(child, scope.atRules, recorder, bypass);
+			for (const plugin of active) plugin.rule?.(context);
+			count += visit(child, {
+				atRules: scope.atRules,
+				owner: child,
+				blocked: scope.blocked
+			}, plugins, recorder, bypass);
+		} else if (child.type === NODE_TYPES.atRule) {
+			if (child.nodes) count += visit(child, {
+				atRules: enterAtRule(child, scope.atRules),
+				owner: scope.owner,
+				blocked: scope.blocked || BLOCKED_AT_RULES.includes(child.name)
+			}, plugins, recorder, bypass);
+		} else if (child.type === NODE_TYPES.declaration) {
+			const owner = scope.owner;
+			if (owner !== void 0 && !recorder.rules.has(owner)) {
+				const context = createDeclarationContext(child, owner, scope.atRules, recorder, bypass);
+				for (const plugin of active) plugin.declaration?.(context);
+			}
+		}
+	}
+	return count;
+}
+/** walk the tree once, dispatching the plugins in order, returning the visited node count */
+function walk(root, plugins, recorder, options) {
+	return visit(root, {
+		atRules: [],
+		blocked: false
+	}, plugins, recorder, options.bypass ?? false);
+}
+// src/postprocess/scan/index.ts
+/** check that every node of the tree was visited */
+function verify(root, visited) {
+	let total = 0;
+	root.walk(() => {
+		total += 1;
+	});
+	if (total !== visited) throw new Error(text.postprocess.walkIncomplete(visited, total));
+}
+/** scan the built css once with the given plugins, returning the diagnostic lines */
+function scan(root, plugins, options = {}) {
+	const recorder = {
+		rules: /* @__PURE__ */ new Set(),
+		selectors: /* @__PURE__ */ new Map(),
+		declarations: /* @__PURE__ */ new Set(),
+		reports: []
+	};
+	const visited = walk(root, plugins, recorder, options);
+	if (options.verify) verify(root, visited);
+	commit(recorder);
+	return recorder.reports;
+}
+// src/postprocess/index.ts
+/** normalize the strict forms into explicit allowances */
+function normalizeStrict(strict) {
+	if (strict === void 0 || strict === false) return void 0;
+	if (typeof strict === "object") return {
+		arbitrary: strict.arbitrary === true,
+		family: strict.family === true,
+		bypass: strict.bypass === true
+	};
+	return {
+		arbitrary: false,
+		family: false,
+		bypass: strict === "bypass"
+	};
+}
+/** normalize the diagnostics forms into an explicit level and limit */
+function normalizeDiagnostics(diagnostics) {
+	if (diagnostics === void 0) return {
+		level: "off",
+		limit: 100
+	};
+	if (typeof diagnostics === "string") return {
+		level: diagnostics,
+		limit: 100
+	};
+	return {
+		level: diagnostics.mode,
+		limit: diagnostics.limit ?? 100
+	};
+}
+/** build the enabled checks for a config */
+function buildPlugins(config, policy) {
+	const plugins = [];
+	if (policy !== void 0 && !policy.arbitrary) plugins.push(createArbitraryPlugin());
+	if (policy !== void 0 && !policy.family) plugins.push(createFamilyPlugin(config.theme ?? {}));
+	plugins.push(createOpacityPlugin());
+	if (config.size !== void 0) plugins.push(createSizePlugin(config.size));
+	return plugins;
+}
+/** build the message listing the dropped nodes */
+function listing(lines, total) {
+	const body = lines.map((line) => `  ${line}`).join("\n");
+	const tail = total > lines.length ? `\n  ${text.postprocess.more(total - lines.length)}` : "";
+	return `${text.postprocess.summary(total)}\n${body}${tail}`;
+}
+/** report the dropped nodes according to the diagnostic settings */
+function report(lines, policy) {
+	if (policy.level === "off" || lines.length === 0) return;
+	const unique = Array.from(new Set(lines));
+	const shown = unique.slice(0, policy.limit);
+	if (policy.level === "warn") {
+		for (const line of shown) output.warn(text.postprocess.warn(line));
+		if (unique.length > shown.length) output.warn(text.postprocess.warn(text.postprocess.more(unique.length - shown.length)));
+		return;
+	}
+	output.error(listing(shown, unique.length));
+}
+/** entry of the postprocess stage */
+function main$1(root, config) {
+	const policy = normalizeStrict(config.strict);
+	report(scan(root, buildPlugins(config, policy), { bypass: policy?.bypass ?? false }), normalizeDiagnostics(config.diagnostics));
+}
+// src/plugins/postprocess.ts
+const postprocess = Object.assign((options = {}) => ({
+	postcssPlugin: POSTPROCESS_PLUGIN_NAME,
+	async OnceExit(root, { result }) {
+		output.bind({ warn: (line) => result.warn(line, { plugin: POSTPROCESS_PLUGIN_NAME }) });
+		try {
+			const { config, dependencies } = await loadConfig(options.cwd);
+			for (const file of dependencies) result.messages.push({
+				type: "dependency",
+				plugin: POSTPROCESS_PLUGIN_NAME,
+				file
+			});
+			main$1(root, config);
+		} catch (error) {
+			if (error instanceof TuneError) throw error;
+			output.error(messageOf(error));
+		} finally {
+			output.bind(void 0);
+		}
+	}
+}), { postcss: true });
+// src/preprocess/raw.ts
+/** register the variant exempting a class from the checks */
+function buildRaw() {
+	return `@custom-variant raw (&);`;
+}
+// src/preprocess/size/normalize.ts
+/** read a unit definition as options, a plain length becomes `{ value }` */
+function toOptions(unit) {
+	return typeof unit === "string" ? { value: unit } : unit;
+}
+/** merge a unit patch into the units, field by field */
+function mergeUnits(units, patch) {
+	const merged = { ...units };
+	for (const [name, next] of Object.entries(patch)) merged[name] = {
+		...toOptions(units[name] ?? next),
+		...toOptions(next)
+	};
+	return merged;
+}
+/** convert a css length into pixels, used to order breakpoints */
+function toPixels(length) {
+	return length.endsWith("rem") ? Number.parseFloat(length) * 16 : Number.parseFloat(length);
+}
+/** parse the breakpoints and order them by width */
+function parseBreakpoints(breakpoints) {
+	const ordered = Object.entries(breakpoints).map(([name, breakpoint]) => {
+		const options = typeof breakpoint === "string" ? void 0 : breakpoint;
+		const builtin = BREAKPOINTS[name];
+		const width = options?.value ?? builtin;
+		if (width === void 0) output.error(text.preprocess.breakpointWidthMissing(name));
+		return {
+			name,
+			prefix: options?.prefix ?? name,
+			width,
+			units: options?.units ?? {}
+		};
+	}).sort((a, b) => toPixels(a.width) - toPixels(b.width));
+	const identifiers = /* @__PURE__ */ new Map();
+	for (const [index, current] of ordered.entries()) {
+		const previous = ordered[index - 1];
+		if (previous !== void 0 && toPixels(previous.width) === toPixels(current.width)) output.error(text.preprocess.breakpointDuplicated(previous.name, current.name));
+		const first = identifiers.get(current.prefix);
+		if (first !== void 0) output.error(text.preprocess.breakpointPrefixDuplicated(first, current.name));
+		identifiers.set(current.prefix, current.name);
+	}
+	return ordered;
+}
+/** resolve one scope of units into size units */
+function resolveUnits(units, min, max, step) {
+	return Object.entries(units).map(([name, unit]) => {
+		const options = toOptions(unit);
+		const bound = options.max ?? max;
+		if (bound === void 0) output.error(text.preprocess.maxMissing(name));
+		const lower = options.min ?? min ?? 0;
+		if (lower > bound) output.error(text.preprocess.rangeReversed(name));
+		return {
+			name,
+			value: options.value,
+			min: lower,
+			max: bound,
+			step: options.step ?? step ?? 1
+		};
+	});
+}
+// src/preprocess/size/serialize.ts
+function unitName(unit) {
+	return unit.name === "default" ? "--unit" : `--unit-${unit.name}`;
+}
+/** build the unit variables of one scope */
+function buildUnits(units) {
+	return units.map((unit) => `  ${unitName(unit)}: ${unit.value};`);
+}
+/** build the spacing keys of one scope */
+function buildKeys(units) {
+	const content = [];
+	for (const unit of units) {
+		const suffix = unit.name === "default" ? "" : unit.name;
+		const precision = `${unit.step}`.split(".")[1]?.length ?? 0;
+		const numbers = /* @__PURE__ */ new Set([0]);
+		const start = Math.ceil(unit.min / unit.step);
+		const end = Math.floor(unit.max / unit.step);
+		for (let index = start; index <= end; index++) numbers.add(Number((index * unit.step).toFixed(precision)));
+		for (const number of [...numbers].sort((a, b) => a - b)) content.push(`  --spacing-${number}${suffix}: calc(${number} * var(${unitName(unit)}));`);
+	}
+	return content;
+}
+/** build the width variables of the configured breakpoints */
+function buildBreakpoints(breakpoints) {
+	return breakpoints.map((breakpoint) => `  --breakpoint-${breakpoint.prefix}: ${breakpoint.width};`);
+}
+/** keep the units whose length differs from the previous table */
+function diffUnits(previous, next) {
+	return next.filter((unit) => previous.find((item) => item.name === unit.name)?.value !== unit.value);
+}
+/** wrap the content into the theme block that resets the tailwind spacing */
+function wrapTheme$1(content) {
+	return [
+		"@theme {",
+		"  --spacing: initial;",
+		...content,
+		"}"
+	];
+}
+/** wrap the content into the media query of a breakpoint */
+function wrapBreakpoint(content, width) {
+	return [
+		`@media (min-width: ${width}) {`,
+		"  :root {",
+		...content.map((line) => `  ${line}`),
+		"  }",
+		"}"
+	];
+}
+// src/preprocess/size/index.ts
+/** build the css of the size system and its breakpoints */
+function buildSize(config) {
+	const size = config.size;
+	if (size === void 0) return "";
+	const defaults = [
+		size.min,
+		size.max,
+		size.step
+	];
+	const base = resolveUnits(size.units, ...defaults);
+	const breakpoints = parseBreakpoints(size.breakpoints ?? {});
+	const keys = new Set(buildKeys(base));
+	const blocks = [];
+	let units = size.units;
+	let previous = base;
+	for (const breakpoint of breakpoints) {
+		for (const name of Object.keys(breakpoint.units)) if (!(name in size.units)) output.error(text.preprocess.unknownUnit(breakpoint.name, name));
+		units = mergeUnits(units, breakpoint.units);
+		const scoped = resolveUnits(units, ...defaults);
+		for (const key of buildKeys(scoped)) keys.add(key);
+		const changed = diffUnits(previous, scoped);
+		if (changed.length > 0) blocks.push(wrapBreakpoint(buildUnits(changed), breakpoint.width));
+		previous = scoped;
+	}
+	return [...wrapTheme$1([
+		...buildBreakpoints(breakpoints),
+		...buildUnits(base),
+		...keys
+	]), ...blocks.flat()].join("\n");
+}
+// src/preprocess/theme/normalize.ts
+/** fold a theme config into a group, filling the absent dimensions */
+function groupOf(theme) {
+	return {
+		palette: theme.palette ?? {},
+		shade: theme.shade ?? {},
+		opacity: theme.opacity ?? {}
+	};
+}
+/** merge a scheme group over the default group, name by name */
+function mergeGroup(base, scheme) {
+	return {
+		palette: {
+			...base.palette,
+			...scheme.palette
+		},
+		shade: {
+			...base.shade,
+			...scheme.shade
+		},
+		opacity: {
+			...base.opacity,
+			...scheme.opacity
+		}
+	};
+}
+/** build the palette of every usable color name */
+function buildPalette(palette) {
+	const themePalette = /* @__PURE__ */ new Map();
+	for (const family of COLOR_FAMILIES) {
+		const scale = /* @__PURE__ */ new Map();
+		for (const shade of COLOR_SHADES) scale.set(shade, PALETTE[family][shade]);
+		themePalette.set(family, scale);
+	}
+	for (const [name, entry] of Object.entries(palette)) {
+		if (typeof entry === "string") continue;
+		const scale = themePalette.get(name) ?? /* @__PURE__ */ new Map();
+		for (const [shade, value] of Object.entries(entry)) scale.set(Number(shade), value);
+		themePalette.set(name, scale);
+	}
+	for (const [name, entry] of Object.entries(palette)) {
+		if (typeof entry !== "string") continue;
+		const scale = themePalette.get(entry) ?? /* @__PURE__ */ new Map();
+		themePalette.set(name, new Map(scale));
+	}
+	return themePalette;
+}
+/** build the color table of every usable color name by the shade mapping */
+function buildTable(themePalette, shade) {
+	const table = /* @__PURE__ */ new Map();
+	for (const [name, scale] of themePalette) {
+		const values = /* @__PURE__ */ new Map();
+		for (const [key, colorShade] of Object.entries(shade)) {
+			const value = scale.get(colorShade);
+			if (value === void 0) output.error(text.preprocess.shadeMissing(name, colorShade));
+			values.set(key, value);
+		}
+		table.set(name, values);
+	}
+	return table;
+}
+/** resolve palette and shade mapping into the color table of every usable name */
+function normalize(palette, shade) {
+	return buildTable(buildPalette(palette), shade);
+}
+// src/preprocess/theme/serialize.ts
+/** build one color declaration, omitting the suffix of the default shade */
+function buildColor(name, value, key) {
+	return `  --color-${name}${key === void 0 || key === "default" ? "" : `-${key}`}: ${value};`;
+}
+/** build the content of a theme block from the opacity mapping */
+function buildOpacity(opacity) {
+	return Object.entries(opacity).map(([key, value]) => `  --opacity-${key}: ${value}%;`);
+}
+/** build the content of a theme block from the color table */
+function buildContent(table) {
+	const content = [];
+	for (const [name, values] of table) for (const [key, value] of values) content.push(buildColor(name, value, key));
+	return content;
+}
+/** keep the opacity of a scheme that differ from the default theme */
+function diffOpacity(base, next) {
+	const opacity = {};
+	for (const [key, value] of Object.entries(next)) if (base[key] !== value) opacity[key] = value;
+	return opacity;
+}
+/** keep the colors of a scheme that differ from the default theme */
+function diffTable(base, next) {
+	const table = /* @__PURE__ */ new Map();
+	for (const [name, values] of next) {
+		const changed = /* @__PURE__ */ new Map();
+		for (const [key, value] of values) if (base.get(name)?.get(key) !== value) changed.set(key, value);
+		if (changed.size > 0) table.set(name, changed);
+	}
+	return table;
+}
+/** wrap theme content into a block, resetting the namespace for the default theme */
+function wrapTheme(content, space, theme) {
+	if (theme === void 0) {
+		const constants = space === "color" ? Object.entries(FLAT_COLORS).map(([name, value]) => buildColor(name, value)) : [];
+		return [
+			"@theme {",
+			`  --${space}-*: initial;`,
+			...constants,
+			...content,
+			"}"
+		];
+	}
+	return [
+		`[data-theme="${theme}"] {`,
+		...content,
+		"}"
+	];
+}
+/** register the variant that scopes utilities to a theme */
+function customVariant(theme) {
+	return `@custom-variant ${theme} (&:where([data-theme="${theme}"] *));`;
+}
+// src/preprocess/theme/index.ts
+/** build the css of the default theme and all schemes */
+function buildTheme(config) {
+	const theme = config.theme ?? {};
+	const base = groupOf(theme);
+	const baseTable = normalize(base.palette, base.shade);
+	const variants = [];
+	const blocks = [wrapTheme(buildContent(baseTable), "color")];
+	if (Object.keys(base.opacity).length > 0) blocks.push(wrapTheme(buildOpacity(base.opacity), "opacity"));
+	const identifiers = /* @__PURE__ */ new Set();
+	for (const [key, scheme] of Object.entries(theme.schemes ?? {})) {
+		const identifier = scheme.prefix ?? key;
+		if (identifiers.has(identifier)) output.error(text.preprocess.themeDuplicated(identifier));
+		identifiers.add(identifier);
+		variants.push(customVariant(identifier));
+		const merged = mergeGroup(base, groupOf(scheme));
+		const table = diffTable(baseTable, normalize(merged.palette, merged.shade));
+		const opacity = diffOpacity(base.opacity, merged.opacity);
+		if (table.size > 0) blocks.push(wrapTheme(buildContent(table), "color", identifier));
+		if (Object.keys(opacity).length > 0) blocks.push(wrapTheme(buildOpacity(opacity), "opacity", identifier));
+	}
+	return [...variants, ...blocks.flat()].join("\n");
+}
+// src/preprocess/index.ts
+function main(config) {
+	return [
+		buildRaw(),
+		buildTheme(config),
+		buildSize(config)
+	].filter(Boolean).join("\n");
+}
+// src/plugins/preprocess.ts
+function findAtRules(root) {
+	const atRules = [];
+	root.walkAtRules(AT_RULE_NAME, (atRule) => {
+		atRules.push(atRule);
+	});
+	return atRules;
+}
+// src/plugins/index.ts
+const tunewind = {
+	preprocess: Object.assign((options = {}) => ({
+		postcssPlugin: PREPROCESS_PLUGIN_NAME,
+		async Once(root, { result }) {
+			output.bind({ warn: (line) => result.warn(line, { plugin: PREPROCESS_PLUGIN_NAME }) });
+			try {
+				const atRules = findAtRules(root);
+				if (atRules.length === 0) return;
+				const { config, dependencies } = await loadConfig(options.cwd);
+				for (const file of dependencies) result.messages.push({
+					type: "dependency",
+					plugin: PREPROCESS_PLUGIN_NAME,
+					file
+				});
+				const css = main(config);
+				if (css.length === 0) {
+					atRules.forEach((atRule) => atRule.remove());
+					return;
+				}
+				const nodes = parse(css).nodes;
+				atRules.forEach((atRule) => atRule.replaceWith(...nodes.map((node) => node.clone())));
+			} catch (error) {
+				if (error instanceof TuneError) throw error;
+				output.error(messageOf(error));
+			} finally {
+				output.bind(void 0);
+			}
+		}
+	}), { postcss: true }),
+	postprocess
+};
+export { defineConfig, tunewind };