@ai.to.design/design-token-extractor 1.3.4

package/dist/cli.js

@@ -0,0 +1,1597 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import ora from "ora";
+import { z as z2 } from "zod";
+
+// src/errors.ts
+var DteError = class extends Error {
+  exitCode;
+  constructor(message, exitCode, options) {
+    super(message, options);
+    this.exitCode = exitCode;
+    this.name = "DteError";
+  }
+};
+var UserError = class extends DteError {
+  constructor(message, options) {
+    super(message, 1, options);
+    this.name = "UserError";
+  }
+};
+var ExtractionError = class extends DteError {
+  constructor(message, options) {
+    super(message, 2, options);
+    this.name = "ExtractionError";
+  }
+};
+
+// src/extract.ts
+import { basename } from "path";
+
+// src/score.ts
+function scoreConfidence(usageCount) {
+  if (usageCount >= 10) return 0.9;
+  if (usageCount >= 5) return 0.7;
+  if (usageCount >= 2) return 0.5;
+  return 0.2;
+}
+
+// src/apply-score.ts
+function applyScores(tokens) {
+  return tokens.map((token) => ({
+    ...token,
+    $extensions: {
+      ...token.$extensions,
+      "com.dte.confidence": scoreConfidence(
+        token.$extensions["com.dte.usage"].count
+      )
+    }
+  }));
+}
+
+// src/categorize/color.ts
+var COLOR_PROPERTIES = /* @__PURE__ */ new Set([
+  "color",
+  "background-color",
+  "border-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "outline-color"
+]);
+var SKIPPED_KEYWORDS = /* @__PURE__ */ new Set([
+  "currentcolor",
+  "inherit",
+  "initial",
+  "unset",
+  "transparent",
+  "revert",
+  "revert-layer",
+  "none",
+  "auto"
+]);
+var NAMED_COLORS = {
+  black: "#000000",
+  silver: "#c0c0c0",
+  gray: "#808080",
+  grey: "#808080",
+  white: "#ffffff",
+  maroon: "#800000",
+  red: "#ff0000",
+  purple: "#800080",
+  fuchsia: "#ff00ff",
+  magenta: "#ff00ff",
+  green: "#008000",
+  lime: "#00ff00",
+  olive: "#808000",
+  yellow: "#ffff00",
+  navy: "#000080",
+  blue: "#0000ff",
+  teal: "#008080",
+  aqua: "#00ffff",
+  cyan: "#00ffff",
+  orange: "#ffa500",
+  pink: "#ffc0cb"
+};
+function isGradient(value) {
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.startsWith("linear-gradient(") || trimmed.startsWith("radial-gradient(") || trimmed.startsWith("conic-gradient(") || trimmed.startsWith("repeating-linear-gradient(") || trimmed.startsWith("repeating-radial-gradient(") || trimmed.startsWith("repeating-conic-gradient(");
+}
+function normalizeHex(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("#")) return null;
+  const digits = trimmed.slice(1);
+  if (!/^[0-9a-fA-F]+$/.test(digits)) return null;
+  if (digits.length === 3 || digits.length === 4) {
+    const expanded = digits.split("").map((ch) => ch + ch).join("");
+    return `#${expanded.toLowerCase()}`;
+  }
+  if (digits.length === 6 || digits.length === 8) {
+    return `#${digits.toLowerCase()}`;
+  }
+  return null;
+}
+function rgbToHex(value) {
+  const match = /^rgb\(\s*([^)]+)\s*\)$/i.exec(value.trim());
+  if (!match) return null;
+  const parts = match[1].split(",").map((p) => p.trim());
+  if (parts.length !== 3) return null;
+  const channels = [];
+  for (const part of parts) {
+    if (!/^\d+$/.test(part)) return null;
+    const n = Number.parseInt(part, 10);
+    if (n < 0 || n > 255) return null;
+    channels.push(n);
+  }
+  const hex = channels.map((n) => n.toString(16).padStart(2, "0")).join("");
+  return `#${hex}`;
+}
+function canonicalizeRgba(value) {
+  const match = /^rgba\(\s*([^)]+)\s*\)$/i.exec(value.trim());
+  if (!match) return null;
+  const parts = match[1].split(",").map((p) => p.trim());
+  if (parts.length !== 4) return null;
+  return `rgba(${parts.join(", ")})`;
+}
+function canonicalizeHsl(value) {
+  const match = /^(hsla?)\(\s*([^)]+)\s*\)$/i.exec(value.trim());
+  if (!match) return null;
+  const fn = match[1].toLowerCase();
+  const parts = match[2].split(",").map((p) => p.trim());
+  return `${fn}(${parts.join(", ")})`;
+}
+function normalizeColor(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  if (SKIPPED_KEYWORDS.has(trimmed.toLowerCase())) return null;
+  if (isGradient(trimmed)) return trimmed;
+  const hex = normalizeHex(trimmed);
+  if (hex !== null) return hex;
+  if (/^rgb\(/i.test(trimmed)) {
+    const hexForm = rgbToHex(trimmed);
+    if (hexForm !== null) return hexForm;
+  }
+  if (/^rgba\(/i.test(trimmed)) {
+    const canonical = canonicalizeRgba(trimmed);
+    if (canonical !== null) return canonical;
+  }
+  if (/^hsla?\(/i.test(trimmed)) {
+    const canonical = canonicalizeHsl(trimmed);
+    if (canonical !== null) return canonical;
+  }
+  const named = NAMED_COLORS[trimmed.toLowerCase()];
+  if (named !== void 0) return named;
+  return trimmed;
+}
+function categorizeColors(records) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!COLOR_PROPERTIES.has(record.property)) continue;
+    const canonical = normalizeColor(record.value);
+    if (canonical === null) continue;
+    const existing = groups.get(canonical);
+    if (existing === void 0) {
+      groups.set(canonical, {
+        canonical,
+        isGradientValue: isGradient(canonical),
+        first: record,
+        selectors: [record.selector]
+      });
+      continue;
+    }
+    existing.selectors.push(record.selector);
+  }
+  const tokens = [];
+  for (const group of groups.values()) {
+    tokens.push({
+      $value: group.canonical,
+      $type: group.isGradientValue ? "other" : "color",
+      $extensions: {
+        "com.dte.usage": {
+          selectors: group.selectors,
+          count: group.selectors.length
+        },
+        "com.dte.confidence": 0,
+        "com.dte.source": group.first.source,
+        "com.dte.theme": group.first.theme
+      }
+    });
+  }
+  return tokens;
+}
+
+// src/categorize/motion.ts
+var DURATION_PROPERTIES = /* @__PURE__ */ new Set([
+  "transition-duration",
+  "animation-duration"
+]);
+var EASING_PROPERTIES = /* @__PURE__ */ new Set([
+  "transition-timing-function",
+  "animation-timing-function"
+]);
+var SKIPPED_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "initial",
+  "inherit"
+]);
+var EASING_KEYWORDS = /* @__PURE__ */ new Set([
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "linear",
+  "step-start",
+  "step-end"
+]);
+function classifyEasing(value) {
+  const lower = value.trim().toLowerCase();
+  if (lower.startsWith("cubic-bezier(")) return "cubicBezier";
+  if (EASING_KEYWORDS.has(lower)) return "other";
+  return "other";
+}
+function upsert(map, key, type, record) {
+  const existing = map.get(key);
+  if (existing) {
+    existing.selectors.add(record.selector);
+    existing.sources.add(record.source);
+    return;
+  }
+  map.set(key, {
+    $value: record.value,
+    $type: type,
+    selectors: /* @__PURE__ */ new Set([record.selector]),
+    sources: /* @__PURE__ */ new Set([record.source])
+  });
+}
+function toToken(agg) {
+  const selectors = [...agg.selectors];
+  const token = {
+    $value: agg.$value,
+    $type: agg.$type,
+    $extensions: {
+      "com.dte.usage": {
+        selectors,
+        count: selectors.length
+      },
+      "com.dte.confidence": 0
+    }
+  };
+  if (agg.sources.size === 1) {
+    const [onlySource] = agg.sources;
+    token.$extensions["com.dte.source"] = onlySource;
+  }
+  return token;
+}
+function categorizeMotion(records) {
+  const durationAgg = /* @__PURE__ */ new Map();
+  const easingAgg = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const value = record.value.trim();
+    if (SKIPPED_VALUES.has(value.toLowerCase())) continue;
+    if (DURATION_PROPERTIES.has(record.property)) {
+      upsert(durationAgg, value, "duration", record);
+      continue;
+    }
+    if (EASING_PROPERTIES.has(record.property)) {
+      const type = classifyEasing(value);
+      upsert(easingAgg, value, type, record);
+      continue;
+    }
+  }
+  return {
+    duration: [...durationAgg.values()].map(toToken),
+    easing: [...easingAgg.values()].map(toToken)
+  };
+}
+
+// src/categorize/radius.ts
+var RADIUS_PROPERTIES = [
+  "border-radius",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius"
+];
+var RADIUS_PROPERTY_SET = new Set(RADIUS_PROPERTIES);
+function normalizeRadiusValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed === "0" || trimmed === "0px") return "0";
+  return trimmed;
+}
+function dedupKey(property, normalizedValue) {
+  return `${property}::${normalizedValue}`;
+}
+function categorizeRadius(records) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!RADIUS_PROPERTY_SET.has(record.property)) continue;
+    const normalized = normalizeRadiusValue(record.value);
+    if (normalized === null) continue;
+    const key = dedupKey(record.property, normalized);
+    const existing = byKey.get(key);
+    if (existing) {
+      const selectors = existing.$extensions["com.dte.usage"].selectors;
+      if (!selectors.includes(record.selector)) {
+        selectors.push(record.selector);
+      }
+      continue;
+    }
+    byKey.set(key, {
+      $value: normalized,
+      $type: "dimension",
+      $extensions: {
+        "com.dte.usage": {
+          selectors: [record.selector],
+          count: 0
+        },
+        "com.dte.confidence": 0
+      }
+    });
+  }
+  return Array.from(byKey.values());
+}
+
+// src/categorize/shadow.ts
+var SHADOW_PROPERTIES = /* @__PURE__ */ new Set([
+  "box-shadow",
+  "text-shadow"
+]);
+var SKIPPED_VALUES2 = /* @__PURE__ */ new Set([
+  "none",
+  "inherit",
+  "initial",
+  "unset"
+]);
+function isShadowRecord(record) {
+  if (!SHADOW_PROPERTIES.has(record.property)) return false;
+  if (SKIPPED_VALUES2.has(record.value)) return false;
+  return true;
+}
+function bucketToToken(bucket) {
+  return {
+    $value: bucket.value,
+    $type: "shadow",
+    $extensions: {
+      "com.dte.usage": {
+        selectors: bucket.selectors,
+        count: bucket.selectors.length
+      },
+      "com.dte.confidence": 0,
+      "com.dte.source": bucket.firstRecord.source,
+      "com.dte.theme": bucket.firstRecord.theme
+    }
+  };
+}
+function categorizeShadow(records) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!isShadowRecord(record)) continue;
+    const existing = buckets.get(record.value);
+    if (existing) {
+      existing.selectors.push(record.selector);
+      continue;
+    }
+    buckets.set(record.value, {
+      value: record.value,
+      selectors: [record.selector],
+      firstRecord: record
+    });
+  }
+  return Array.from(buckets.values(), bucketToToken);
+}
+
+// src/categorize/spacing.ts
+var SPACING_PROPERTIES = [
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "gap",
+  "row-gap",
+  "column-gap"
+];
+var SKIPPED_VALUES3 = /* @__PURE__ */ new Set(["auto", "inherit"]);
+function isSpacingProperty(property) {
+  return SPACING_PROPERTIES.includes(property);
+}
+function canonicalize(rawValue) {
+  const value = rawValue.trim();
+  if (value === "") return null;
+  const lowered = value.toLowerCase();
+  if (SKIPPED_VALUES3.has(lowered)) return null;
+  if (value === "0" || lowered === "0px") return "0";
+  return value;
+}
+function buildToken(bucket) {
+  const extensions = {
+    "com.dte.usage": {
+      selectors: bucket.selectors.slice(),
+      count: bucket.count
+    },
+    "com.dte.confidence": 0,
+    "com.dte.source": bucket.source
+  };
+  return {
+    $value: bucket.value,
+    $type: "dimension",
+    $extensions: extensions
+  };
+}
+function categorizeSpacing(records) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!isSpacingProperty(record.property)) continue;
+    const canonicalValue = canonicalize(record.value);
+    if (canonicalValue === null) continue;
+    const existing = buckets.get(canonicalValue);
+    if (existing === void 0) {
+      buckets.set(canonicalValue, {
+        value: canonicalValue,
+        selectors: [record.selector],
+        count: 1,
+        source: record.source
+      });
+      continue;
+    }
+    existing.count += 1;
+    if (!existing.selectors.includes(record.selector)) {
+      existing.selectors.push(record.selector);
+    }
+  }
+  const tokens = [];
+  for (const bucket of buckets.values()) {
+    tokens.push(buildToken(bucket));
+  }
+  return tokens;
+}
+
+// src/categorize/typography.ts
+var SKIP_KEYWORDS = /* @__PURE__ */ new Set(["normal", "inherit", "initial"]);
+function parsePlainNumber(value) {
+  const trimmed = value.trim();
+  if (!/^-?\d+(?:\.\d+)?$/.test(trimmed)) return void 0;
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalize(record) {
+  const { property, value } = record;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  if (SKIP_KEYWORDS.has(trimmed.toLowerCase())) return void 0;
+  switch (property) {
+    case "font-family":
+      return { bucket: "family", value: trimmed, type: "fontFamily" };
+    case "font-size":
+      return { bucket: "size", value: trimmed, type: "dimension" };
+    case "font-weight": {
+      const numeric = parsePlainNumber(trimmed);
+      if (numeric !== void 0) {
+        return { bucket: "weight", value: numeric, type: "fontWeight" };
+      }
+      return { bucket: "weight", value: trimmed, type: "fontWeight" };
+    }
+    case "line-height": {
+      const numeric = parsePlainNumber(trimmed);
+      if (numeric !== void 0) {
+        return { bucket: "lineHeight", value: numeric, type: "number" };
+      }
+      return { bucket: "lineHeight", value: trimmed, type: "dimension" };
+    }
+    case "letter-spacing":
+      return { bucket: "letterSpacing", value: trimmed, type: "dimension" };
+    default:
+      return void 0;
+  }
+}
+function makeToken(entry, record) {
+  const token = {
+    $value: entry.value,
+    $type: entry.type,
+    $extensions: {
+      "com.dte.usage": { selectors: [record.selector], count: 1 },
+      "com.dte.confidence": 0
+    }
+  };
+  token.$extensions["com.dte.source"] = record.source;
+  token.$extensions["com.dte.theme"] = record.theme;
+  if (record.originalVar !== void 0) {
+    token.$extensions["com.dte.unresolvedVar"] = record.originalVar;
+  }
+  return token;
+}
+function accumulate(existing, record) {
+  const usage = existing.$extensions["com.dte.usage"];
+  usage.selectors.push(record.selector);
+  usage.count += 1;
+}
+function categorizeTypography(records) {
+  const buckets = {
+    family: [],
+    size: [],
+    weight: [],
+    lineHeight: [],
+    letterSpacing: []
+  };
+  const dedup = {
+    family: /* @__PURE__ */ new Map(),
+    size: /* @__PURE__ */ new Map(),
+    weight: /* @__PURE__ */ new Map(),
+    lineHeight: /* @__PURE__ */ new Map(),
+    letterSpacing: /* @__PURE__ */ new Map()
+  };
+  for (const record of records) {
+    const entry = normalize(record);
+    if (entry === void 0) continue;
+    const key = `${typeof entry.value}:${String(entry.value)}`;
+    const bucketMap = dedup[entry.bucket];
+    const existing = bucketMap.get(key);
+    if (existing !== void 0) {
+      accumulate(existing, record);
+      continue;
+    }
+    const token = makeToken(entry, record);
+    bucketMap.set(key, token);
+    buckets[entry.bucket].push(token);
+  }
+  return buckets;
+}
+
+// src/categorize/zindex.ts
+function categorizeZIndex(records) {
+  const tokensByValue = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.property !== "z-index") continue;
+    const numericValue = parseZIndexValue(record.value);
+    if (numericValue === null) continue;
+    const existing = tokensByValue.get(numericValue);
+    if (existing) {
+      appendUsage(existing, record.selector);
+      continue;
+    }
+    tokensByValue.set(numericValue, buildToken2(numericValue, record.selector));
+  }
+  return Array.from(tokensByValue.values());
+}
+function parseZIndexValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return null;
+  const parsed = parseInt(trimmed, 10);
+  if (Number.isNaN(parsed)) return null;
+  return parsed;
+}
+function buildToken2(value, selector) {
+  return {
+    $value: value,
+    $type: "number",
+    $extensions: {
+      "com.dte.usage": { selectors: [selector], count: 1 },
+      "com.dte.confidence": 0
+    }
+  };
+}
+function appendUsage(token, selector) {
+  const usage = token.$extensions["com.dte.usage"];
+  usage.count += 1;
+  if (!usage.selectors.includes(selector)) {
+    usage.selectors.push(selector);
+  }
+}
+
+// src/dedup.ts
+function stringifyValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  const keys = Object.keys(value).sort();
+  const ordered = {};
+  for (const key of keys) {
+    ordered[key] = value[key];
+  }
+  return JSON.stringify(ordered);
+}
+function mergeKey(token) {
+  const theme = token.$extensions["com.dte.theme"] ?? "none";
+  return `${token.$type}::${stringifyValue(token.$value)}::${theme}`;
+}
+function unionSelectors(a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const selector of a) {
+    if (seen.has(selector)) continue;
+    seen.add(selector);
+    out.push(selector);
+  }
+  for (const selector of b) {
+    if (seen.has(selector)) continue;
+    seen.add(selector);
+    out.push(selector);
+  }
+  return out;
+}
+function mergeTokens(existing, incoming) {
+  const existingUsage = existing.$extensions["com.dte.usage"];
+  const incomingUsage = incoming.$extensions["com.dte.usage"];
+  const mergedExtensions = {
+    ...existing.$extensions,
+    "com.dte.usage": {
+      selectors: unionSelectors(existingUsage.selectors, incomingUsage.selectors),
+      count: existingUsage.count + incomingUsage.count
+    }
+  };
+  const existingSource = existing.$extensions["com.dte.source"];
+  const incomingSource = incoming.$extensions["com.dte.source"];
+  if (existingSource === "stylesheet" || incomingSource === "stylesheet") {
+    mergedExtensions["com.dte.source"] = "stylesheet";
+  }
+  return {
+    ...existing,
+    $extensions: mergedExtensions
+  };
+}
+function dedupTokens(tokens) {
+  const order = [];
+  const merged = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const key = mergeKey(token);
+    const existing = merged.get(key);
+    if (existing === void 0) {
+      order.push(key);
+      merged.set(key, token);
+      continue;
+    }
+    merged.set(key, mergeTokens(existing, token));
+  }
+  return order.map((key) => merged.get(key));
+}
+
+// src/name.ts
+function tieBreakKey(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  const keys = Object.keys(value).sort();
+  const ordered = {};
+  for (const key of keys) {
+    ordered[key] = value[key];
+  }
+  return JSON.stringify(ordered);
+}
+function nameBucket(tokens, prefix) {
+  const sorted = tokens.slice().sort((a, b) => {
+    const countDiff = b.$extensions["com.dte.usage"].count - a.$extensions["com.dte.usage"].count;
+    if (countDiff !== 0) return countDiff;
+    const aKey = tieBreakKey(a.$value);
+    const bKey = tieBreakKey(b.$value);
+    if (aKey < bKey) return -1;
+    if (aKey > bKey) return 1;
+    return 0;
+  });
+  const named = {};
+  sorted.forEach((token, index) => {
+    named[`${prefix}-${index + 1}`] = token;
+  });
+  return named;
+}
+
+// src/render/playwright.ts
+import { stat } from "fs/promises";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import { chromium } from "playwright";
+
+// src/render/extract-in-page.ts
+var extractInPageFromGlobals = (theme) => {
+  const properties = [
+    // Color
+    "color",
+    "background-color",
+    "border-color",
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color",
+    "outline-color",
+    // Typography
+    "font-family",
+    "font-size",
+    "font-weight",
+    "line-height",
+    "letter-spacing",
+    "text-transform",
+    "text-decoration",
+    // Spacing — padding
+    "padding",
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    // Spacing — margin & gap
+    "margin",
+    "margin-top",
+    "margin-right",
+    "margin-bottom",
+    "margin-left",
+    "gap",
+    // Radius
+    "border-radius",
+    "border-top-left-radius",
+    "border-top-right-radius",
+    "border-bottom-right-radius",
+    "border-bottom-left-radius",
+    // Shadow
+    "box-shadow",
+    "text-shadow",
+    // Z-index
+    "z-index",
+    // Motion
+    "transition-duration",
+    "transition-timing-function",
+    "animation-duration",
+    "animation-timing-function"
+  ];
+  const buildSelectorLocal = (element) => {
+    const tag = element.tagName.toLowerCase();
+    const id = element.id ? `#${element.id}` : "";
+    const classList = element.classList.length > 0 ? `.${Array.from(element.classList).join(".")}` : "";
+    return `${tag}${id}${classList}`;
+  };
+  const resolveSourceLocal = (element, property) => {
+    const styledElement = element;
+    const inline = styledElement.style?.getPropertyValue(property) ?? "";
+    return inline !== "" ? "inline" : "stylesheet";
+  };
+  const records = [];
+  const elements = /* @__PURE__ */ new Set();
+  elements.add(document.documentElement);
+  document.querySelectorAll("*").forEach((el) => elements.add(el));
+  for (const element of elements) {
+    const computed = window.getComputedStyle(element);
+    const selector = buildSelectorLocal(element);
+    for (const property of properties) {
+      const value = computed.getPropertyValue(property).trim();
+      if (value === "") continue;
+      if (property === "z-index" && value === "auto") continue;
+      records.push({
+        selector,
+        property,
+        value,
+        source: resolveSourceLocal(element, property),
+        theme,
+        scope: ":root"
+      });
+    }
+  }
+  return records;
+};
+
+// src/render/playwright.ts
+var isPrivateHost = (hostname) => {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h === "ip6-localhost" || h === "ip6-loopback") {
+    return true;
+  }
+  if (h === "::1" || h.startsWith("fe80:") || /^f[cd][0-9a-f]{2}:/i.test(h)) {
+    return true;
+  }
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!m) return false;
+  const [a, b] = [Number(m[1]), Number(m[2])];
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 0) return true;
+  return false;
+};
+var resolveTargetUrl = async (input) => {
+  if (input.kind === "url") {
+    return input.url;
+  }
+  const absolute = resolve(input.path);
+  try {
+    await stat(absolute);
+  } catch (err) {
+    throw new ExtractionError(`File not found: ${absolute}`, { cause: err });
+  }
+  return pathToFileURL(absolute).href;
+};
+var withTimeout = (operation, timeoutMs) => {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const seconds = timeoutMs / 1e3;
+      reject(
+        new ExtractionError(
+          `Extraction timed out after ${seconds}s \u2014 consider --file or --fast`
+        )
+      );
+    }, timeoutMs);
+  });
+  return {
+    result: Promise.race([operation, timeout]),
+    cancel: () => {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+};
+var asExtractionError = (err) => {
+  if (err instanceof ExtractionError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new ExtractionError(`Render failed: ${message}`, { cause: err });
+};
+var render = async (input, theme, timeoutMs, opts) => {
+  const targetUrl = await resolveTargetUrl(input);
+  let browser;
+  const onSigint = () => {
+    if (browser && browser.isConnected()) {
+      void browser.close();
+    }
+  };
+  process.once("SIGINT", onSigint);
+  const allowPrivate = opts?.allowPrivateHosts === true;
+  if (input.kind === "url" && !allowPrivate) {
+    const hostname = new URL(targetUrl).hostname;
+    if (isPrivateHost(hostname)) {
+      throw new ExtractionError(
+        `Refusing to navigate to private host ${hostname} \u2014 pass --allow-private-hosts to override`
+      );
+    }
+  }
+  const operation = (async () => {
+    browser = await chromium.launch({ headless: true });
+    opts?.onBrowser?.(browser);
+    const context = await browser.newContext();
+    if (!allowPrivate) {
+      await context.route("**/*", async (route) => {
+        try {
+          const hostname = new URL(route.request().url()).hostname;
+          if (hostname && isPrivateHost(hostname)) {
+            await route.abort("blockedbyclient");
+            return;
+          }
+        } catch {
+        }
+        await route.continue();
+      });
+    }
+    const page = await context.newPage();
+    await page.emulateMedia({ colorScheme: theme });
+    await page.goto(targetUrl, { waitUntil: "networkidle" });
+    const records = await page.evaluate(extractInPageFromGlobals, theme);
+    return records;
+  })();
+  const { result, cancel } = withTimeout(operation, timeoutMs);
+  try {
+    return await result;
+  } catch (err) {
+    throw asExtractionError(err);
+  } finally {
+    cancel();
+    process.removeListener("SIGINT", onSigint);
+    if (browser) {
+      try {
+        await browser.close();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/sources/file.ts
+import { lstat, readFile } from "fs/promises";
+import { extname, resolve as resolve2 } from "path";
+async function loadFile(inputPath) {
+  const absPath = resolve2(inputPath.trim());
+  const stats = await statOrThrow(absPath);
+  if (stats.isDirectory()) {
+    throw new UserError(`Not a file: ${absPath}`);
+  }
+  if (stats.isSymbolicLink()) {
+    throw new UserError(`Symlinks are not supported: ${absPath}`);
+  }
+  if (extname(absPath).toLowerCase() !== ".html") {
+    process.stderr.write(
+      `warning: ${absPath} does not have a .html extension
+`
+    );
+  }
+  const html = await readFile(absPath, "utf8");
+  return { absPath, html };
+}
+async function statOrThrow(absPath) {
+  try {
+    return await lstat(absPath);
+  } catch (error) {
+    if (isNodeErrnoException(error) && error.code === "ENOENT") {
+      throw new UserError(`File not found: ${absPath}`, { cause: error });
+    }
+    throw error;
+  }
+}
+function isNodeErrnoException(error) {
+  return error instanceof Error && typeof error.code === "string";
+}
+
+// src/sources/url.ts
+var ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+function parseUrl(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new UserError("URL is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch (cause) {
+    throw new UserError(`Invalid URL: ${redactUserinfo(trimmed)}`, { cause });
+  }
+  if (!ALLOWED_PROTOCOLS.has(parsed.protocol)) {
+    throw new UserError(
+      `Only http:// or https:// URLs are supported, got: ${parsed.protocol}`
+    );
+  }
+  return parsed;
+}
+function redactUserinfo(raw) {
+  return raw.replace(/^(\w+:\/\/)[^/@]+@/, "$1[REDACTED]@");
+}
+
+// src/extract.ts
+var VERSION = true ? "1.3.4" : "0.0.0-dev";
+async function extract(opts) {
+  const sourceValue = await resolveInput(opts);
+  const records = await gatherRecords(opts);
+  const tokenSet = buildTokenSet(records, {
+    extractor: "design-token-extractor",
+    version: VERSION,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: { kind: opts.input.kind, value: sourceValue }
+  });
+  return tokenSet;
+}
+async function resolveInput(opts) {
+  if (opts.input.kind === "url") {
+    const parsed = parseUrl(opts.input.url);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  }
+  const { absPath } = await loadFile(opts.input.path);
+  return basename(absPath);
+}
+async function gatherRecords(opts) {
+  const renderOpts = { allowPrivateHosts: opts.allowPrivateHosts };
+  if (opts.theme === "light" || opts.theme === "dark") {
+    return render(opts.input, opts.theme, opts.timeoutMs, renderOpts);
+  }
+  const lightRecords = await render(opts.input, "light", opts.timeoutMs, renderOpts);
+  const darkRecords = await render(opts.input, "dark", opts.timeoutMs, renderOpts);
+  if (recordsEqual(lightRecords, darkRecords)) {
+    return lightRecords.map((r) => ({ ...r, theme: "light" }));
+  }
+  return [...lightRecords, ...darkRecords];
+}
+function recordsEqual(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    const a = left[i];
+    const b = right[i];
+    if (a === void 0 || b === void 0) return false;
+    if (a.selector !== b.selector || a.property !== b.property || a.value !== b.value || a.source !== b.source || a.scope !== b.scope || a.originalVar !== b.originalVar) {
+      return false;
+    }
+  }
+  return true;
+}
+function finalizeBucket(tokens, prefix) {
+  const deduped = dedupTokens(tokens);
+  const scored = applyScores(deduped);
+  return nameBucket(scored, prefix);
+}
+function categorizeOne(records) {
+  const typography = categorizeTypography(records);
+  const motion = categorizeMotion(records);
+  return {
+    color: categorizeColors(records),
+    family: typography.family,
+    size: typography.size,
+    weight: typography.weight,
+    lineHeight: typography.lineHeight,
+    letterSpacing: typography.letterSpacing,
+    spacing: categorizeSpacing(records),
+    radius: categorizeRadius(records),
+    shadow: categorizeShadow(records),
+    zIndex: categorizeZIndex(records),
+    durationMotion: motion.duration,
+    easingMotion: motion.easing
+  };
+}
+function categorizeByTheme(records) {
+  const lightRecords = records.filter((r) => r.theme === "light");
+  const darkRecords = records.filter((r) => r.theme === "dark");
+  if (lightRecords.length === 0 || darkRecords.length === 0) {
+    return categorizeOne(records);
+  }
+  const light = categorizeOne(lightRecords);
+  const dark = categorizeOne(darkRecords);
+  return {
+    color: [...light.color, ...dark.color],
+    family: [...light.family, ...dark.family],
+    size: [...light.size, ...dark.size],
+    weight: [...light.weight, ...dark.weight],
+    lineHeight: [...light.lineHeight, ...dark.lineHeight],
+    letterSpacing: [...light.letterSpacing, ...dark.letterSpacing],
+    spacing: [...light.spacing, ...dark.spacing],
+    radius: [...light.radius, ...dark.radius],
+    shadow: [...light.shadow, ...dark.shadow],
+    zIndex: [...light.zIndex, ...dark.zIndex],
+    durationMotion: [...light.durationMotion, ...dark.durationMotion],
+    easingMotion: [...light.easingMotion, ...dark.easingMotion]
+  };
+}
+function buildTokenSet(records, metadata) {
+  const buckets = categorizeByTheme(records);
+  const color = finalizeBucket(buckets.color, "color");
+  const typography = {
+    family: finalizeBucket(buckets.family, "font-family"),
+    size: finalizeBucket(buckets.size, "font-size"),
+    weight: finalizeBucket(buckets.weight, "font-weight"),
+    lineHeight: finalizeBucket(buckets.lineHeight, "line-height"),
+    letterSpacing: finalizeBucket(buckets.letterSpacing, "letter-spacing")
+  };
+  const spacing = finalizeBucket(buckets.spacing, "spacing");
+  const radius = finalizeBucket(buckets.radius, "radius");
+  const shadow = finalizeBucket(buckets.shadow, "shadow");
+  const zIndex = finalizeBucket(buckets.zIndex, "z");
+  const breakpoint = {};
+  const motion = {
+    duration: finalizeBucket(buckets.durationMotion, "duration"),
+    easing: finalizeBucket(buckets.easingMotion, "easing")
+  };
+  return {
+    $schema: "https://design-tokens.github.io/community-group/format/",
+    $metadata: metadata,
+    color,
+    typography,
+    spacing,
+    radius,
+    shadow,
+    zIndex,
+    breakpoint,
+    motion
+  };
+}
+
+// src/format/css.ts
+import postcss from "postcss";
+var FLAT_CATEGORIES = [
+  "color",
+  "spacing",
+  "radius",
+  "shadow",
+  "zIndex",
+  "breakpoint"
+];
+var SUB_CATEGORIES = ["typography", "motion"];
+var CATEGORY_ORDER = [
+  "color",
+  "typography",
+  "spacing",
+  "radius",
+  "shadow",
+  "zIndex",
+  "breakpoint",
+  "motion"
+];
+function themeOf(token) {
+  return token.$extensions["com.dte.theme"] ?? "light";
+}
+function renderValue(value) {
+  const raw = typeof value === "string" ? value : typeof value === "number" ? String(value) : JSON.stringify(value);
+  if (/[{}]/.test(raw)) {
+    return raw.replace(/[{}]/g, "");
+  }
+  return raw;
+}
+function flatEntriesForTheme(collection, theme) {
+  return Object.entries(collection).filter(
+    ([, token]) => themeOf(token) === theme
+  );
+}
+function subEntriesForTheme(collection, theme) {
+  const out = [];
+  for (const subkey of Object.keys(collection)) {
+    const bucket = collection[subkey] ?? {};
+    for (const [name, token] of Object.entries(bucket)) {
+      if (themeOf(token) === theme) {
+        out.push([name, token]);
+      }
+    }
+  }
+  return out;
+}
+function entriesForCategory(set, category, theme) {
+  if (SUB_CATEGORIES.includes(category)) {
+    return subEntriesForTheme(set[category], theme);
+  }
+  return flatEntriesForTheme(set[category], theme);
+}
+function emitCategory(name, entries, indent) {
+  if (entries.length === 0) return "";
+  const header = `${indent}/* ==== ${name} ==== */
+`;
+  const decls = entries.map(([key, token]) => `${indent}--${key}: ${renderValue(token.$value)};`).join("\n");
+  return `${header}${decls}
+`;
+}
+function emitRoot(set, theme, indent) {
+  const sections = [];
+  for (const category of CATEGORY_ORDER) {
+    const entries = entriesForCategory(set, category, theme);
+    const section = emitCategory(category, entries, indent);
+    if (section.length > 0) sections.push(section);
+  }
+  return sections.join("\n");
+}
+function hasDarkTokens(set) {
+  for (const category of FLAT_CATEGORIES) {
+    if (flatEntriesForTheme(set[category], "dark").length > 0) return true;
+  }
+  for (const category of SUB_CATEGORIES) {
+    if (subEntriesForTheme(set[category], "dark").length > 0) return true;
+  }
+  return false;
+}
+function formatCss(tokenSet) {
+  const lightBody = emitRoot(tokenSet, "light", "  ");
+  let output = `:root {
+${lightBody}}
+`;
+  if (hasDarkTokens(tokenSet)) {
+    const darkBody = emitRoot(tokenSet, "dark", "    ");
+    output += `
+@media (prefers-color-scheme: dark) {
+  :root {
+${darkBody}  }
+}
+`;
+  }
+  return output;
+}
+
+// src/format/js.ts
+var INDENT = 2;
+function formatJs(tokenSet) {
+  const body = JSON.stringify(tokenSet, null, INDENT);
+  return `export default ${body};
+`;
+}
+
+// src/format/json.ts
+import { z } from "zod";
+var DTCG_SCHEMA_URL = "https://design-tokens.github.io/community-group/format/";
+var tokenTypeSchema = z.enum([
+  "color",
+  "dimension",
+  "fontFamily",
+  "fontWeight",
+  "duration",
+  "cubicBezier",
+  "shadow",
+  "number",
+  "other"
+]);
+var tokenValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.record(z.string(), z.unknown())
+]);
+var tokenUsageSchema = z.object({
+  selectors: z.array(z.string()),
+  count: z.number().int().min(0)
+});
+var tokenExtensionsSchema = z.object({
+  "com.dte.usage": tokenUsageSchema,
+  "com.dte.confidence": z.number().min(0).max(1),
+  "com.dte.source": z.enum(["stylesheet", "inline"]).optional(),
+  "com.dte.unresolvedVar": z.string().optional(),
+  "com.dte.theme": z.enum(["light", "dark"]).optional()
+});
+var tokenSchema = z.object({
+  $value: tokenValueSchema,
+  $type: tokenTypeSchema,
+  $description: z.string().optional(),
+  $extensions: tokenExtensionsSchema
+});
+var tokenCollectionSchema = z.record(z.string(), tokenSchema);
+var subcategoryCollectionSchema = z.record(z.string(), tokenCollectionSchema);
+var tokenSetMetadataSchema = z.object({
+  extractor: z.literal("design-token-extractor"),
+  version: z.string(),
+  extractedAt: z.string(),
+  source: z.object({
+    kind: z.enum(["url", "file"]),
+    value: z.string()
+  })
+});
+var tokenSetSchema = z.object({
+  $schema: z.literal(DTCG_SCHEMA_URL),
+  $metadata: tokenSetMetadataSchema,
+  color: tokenCollectionSchema,
+  typography: subcategoryCollectionSchema,
+  spacing: tokenCollectionSchema,
+  radius: tokenCollectionSchema,
+  shadow: tokenCollectionSchema,
+  zIndex: tokenCollectionSchema,
+  breakpoint: tokenCollectionSchema,
+  motion: subcategoryCollectionSchema
+});
+function formatJson(tokenSet) {
+  const validated = tokenSetSchema.parse(tokenSet);
+  return JSON.stringify(validated, null, 2);
+}
+
+// src/format/md.ts
+var FLAT_CATEGORIES2 = [
+  "color",
+  "spacing",
+  "radius",
+  "shadow",
+  "zIndex",
+  "breakpoint"
+];
+var NESTED_CATEGORIES = [
+  "typography",
+  "motion"
+];
+function formatMarkdown(tokenSet) {
+  const sections = [];
+  sections.push(renderIntro(tokenSet));
+  for (const key of FLAT_CATEGORIES2) {
+    const section = renderFlatSection(key, tokenSet[key]);
+    if (section !== null) {
+      sections.push(section);
+    }
+  }
+  for (const key of NESTED_CATEGORIES) {
+    const section = renderNestedSection(key, tokenSet[key]);
+    if (section !== null) {
+      sections.push(section);
+    }
+  }
+  return sections.join("\n") + "\n";
+}
+function renderIntro(tokenSet) {
+  const { extractedAt } = tokenSet.$metadata;
+  return `# Design Tokens
+
+Extracted at ${extractedAt}.
+`;
+}
+function renderFlatSection(key, tokens) {
+  const entries = Object.entries(tokens);
+  if (entries.length === 0) {
+    return null;
+  }
+  const heading = `## ${capitalize(key)}`;
+  const table = key === "color" ? renderColorTable(entries) : renderPlainTable(entries);
+  return `${heading}
+
+${table}`;
+}
+function renderNestedSection(key, subcategories) {
+  const nonEmptySubcategories = Object.entries(subcategories).filter(
+    ([, collection]) => Object.keys(collection).length > 0
+  );
+  if (nonEmptySubcategories.length === 0) {
+    return null;
+  }
+  const parts = [`## ${capitalize(key)}`, ""];
+  for (const [subKey, collection] of nonEmptySubcategories) {
+    const entries = Object.entries(collection);
+    parts.push(`### ${capitalize(subKey)}`);
+    parts.push("");
+    parts.push(renderPlainTable(entries));
+    parts.push("");
+  }
+  while (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts.join("\n") + "\n";
+}
+function renderColorTable(entries) {
+  const header = "| Name | Swatch | Value | Count | Confidence |";
+  const separator = "| --- | --- | --- | --- | --- |";
+  const rows = entries.map(([name, token]) => {
+    const value = formatValue(token.$value);
+    const swatch = renderSwatch(value);
+    const count = token.$extensions["com.dte.usage"].count;
+    const confidence = token.$extensions["com.dte.confidence"];
+    return `| ${escapeMdCell(name)} | ${swatch} | ${escapeMdCell(value)} | ${count} | ${confidence} |`;
+  });
+  return [header, separator, ...rows].join("\n") + "\n";
+}
+function renderPlainTable(entries) {
+  const header = "| Name | Value | Count | Confidence |";
+  const separator = "| --- | --- | --- | --- |";
+  const rows = entries.map(([name, token]) => {
+    const value = formatValue(token.$value);
+    const count = token.$extensions["com.dte.usage"].count;
+    const confidence = token.$extensions["com.dte.confidence"];
+    return `| ${escapeMdCell(name)} | ${escapeMdCell(value)} | ${count} | ${confidence} |`;
+  });
+  return [header, separator, ...rows].join("\n") + "\n";
+}
+function renderSwatch(value) {
+  return `<span style="display:inline-block;width:16px;height:16px;background:${escapeHtml(value)};border:1px solid #ccc;"></span>`;
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeMdCell(input) {
+  return input.replace(/\|/g, "\\|").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function capitalize(input) {
+  if (input.length === 0) {
+    return input;
+  }
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+
+// src/io/write.ts
+import { rename, unlink, writeFile } from "fs/promises";
+import { dirname, resolve as resolve3, basename as basename2 } from "path";
+import { randomBytes } from "crypto";
+async function writeAtomic(content, outPath) {
+  if (outPath === void 0 || outPath === "-") {
+    process.stdout.write(content);
+    return;
+  }
+  const absolute = resolve3(outPath);
+  const targetDir = dirname(absolute);
+  const targetName = basename2(absolute);
+  const suffix = randomBytes(8).toString("hex");
+  const tempPath = resolve3(targetDir, `.${targetName}.tmp-${suffix}`);
+  try {
+    await writeFile(tempPath, content, "utf8");
+    await rename(tempPath, absolute);
+  } catch (error) {
+    try {
+      await unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// src/cli.ts
+var CLI_VERSION = true ? "1.3.4" : "0.0.0-dev";
+var inputSchema = z2.union([
+  z2.object({ kind: z2.literal("url"), url: z2.string().url() }),
+  z2.object({ kind: z2.literal("file"), path: z2.string().min(1) })
+]);
+var cliOptionsSchema = z2.object({
+  input: inputSchema,
+  format: z2.enum(["json", "css", "js", "md"]),
+  out: z2.string().min(1).optional(),
+  timeoutMs: z2.number().int().positive(),
+  minConfidence: z2.number().min(0).max(1),
+  theme: z2.enum(["auto", "light", "dark"]),
+  fast: z2.boolean(),
+  allowPrivateHosts: z2.boolean()
+});
+async function resolveInput2(urlArg, fileFlag) {
+  if (urlArg !== void 0 && fileFlag !== void 0) {
+    throw new UserError("Specify either a URL or --file, not both");
+  }
+  if (urlArg === void 0 && fileFlag === void 0) {
+    throw new UserError("Must specify a URL or --file <path>");
+  }
+  if (urlArg !== void 0) {
+    const parsed = parseUrl(urlArg);
+    return { kind: "url", url: parsed.toString() };
+  }
+  const { absPath } = await loadFile(fileFlag);
+  return { kind: "file", path: absPath };
+}
+var MAX_TIMEOUT_SECONDS = 3600;
+function parseTimeoutMs(raw, fallbackMs) {
+  if (raw === void 0) return fallbackMs;
+  const seconds = Number.parseFloat(raw);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new UserError(`--timeout must be a positive number, got: ${raw}`);
+  }
+  if (seconds > MAX_TIMEOUT_SECONDS) {
+    throw new UserError(
+      `--timeout must not exceed ${MAX_TIMEOUT_SECONDS}s, got: ${raw}`
+    );
+  }
+  return Math.round(seconds * 1e3);
+}
+function parseMinConfidence(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const value = Number.parseFloat(raw);
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new UserError(
+      `--min-confidence must be between 0 and 1, got: ${raw}`
+    );
+  }
+  return value;
+}
+function parseFormatFlag(raw) {
+  const value = raw ?? "json";
+  if (value !== "json" && value !== "css" && value !== "js" && value !== "md") {
+    throw new UserError(
+      `--format must be one of json|css|js|md, got: ${value}`
+    );
+  }
+  return value;
+}
+function parseThemeFlag(raw) {
+  const value = raw ?? "auto";
+  if (value !== "auto" && value !== "light" && value !== "dark") {
+    throw new UserError(
+      `--theme must be one of auto|light|dark, got: ${value}`
+    );
+  }
+  return value;
+}
+function filterByConfidence(tokenSet, threshold) {
+  if (threshold <= 0) return tokenSet;
+  const filterCollection = (collection) => {
+    const out = {};
+    for (const [key, token] of Object.entries(collection)) {
+      if (token.$extensions["com.dte.confidence"] >= threshold) {
+        out[key] = token;
+      }
+    }
+    return out;
+  };
+  const filterSubcollection = (subcollection) => {
+    const out = {};
+    for (const [subKey, collection] of Object.entries(subcollection)) {
+      out[subKey] = filterCollection(collection);
+    }
+    return out;
+  };
+  return {
+    ...tokenSet,
+    color: filterCollection(tokenSet.color),
+    typography: filterSubcollection(tokenSet.typography),
+    spacing: filterCollection(tokenSet.spacing),
+    radius: filterCollection(tokenSet.radius),
+    shadow: filterCollection(tokenSet.shadow),
+    zIndex: filterCollection(tokenSet.zIndex),
+    breakpoint: filterCollection(tokenSet.breakpoint),
+    motion: filterSubcollection(tokenSet.motion)
+  };
+}
+function serialize(tokenSet, format) {
+  switch (format) {
+    case "json":
+      return formatJson(tokenSet);
+    case "css":
+      return formatCss(tokenSet);
+    case "js":
+      return formatJs(tokenSet);
+    case "md":
+      return formatMarkdown(tokenSet);
+  }
+}
+function createSpinner(text) {
+  if (!process.stdout.isTTY) return null;
+  return ora({ text, stream: process.stderr }).start();
+}
+async function runExtract(urlArg, flags) {
+  let spinner = null;
+  try {
+    const input = await resolveInput2(urlArg, flags.file);
+    const rawOpts = {
+      input,
+      format: parseFormatFlag(flags.format),
+      out: flags.out,
+      timeoutMs: parseTimeoutMs(flags.timeout, 6e4),
+      minConfidence: parseMinConfidence(flags.minConfidence, 0),
+      theme: parseThemeFlag(flags.theme),
+      fast: flags.fast === true,
+      allowPrivateHosts: flags.allowPrivateHosts === true
+    };
+    const parsedOpts = cliOptionsSchema.parse(rawOpts);
+    if (parsedOpts.fast) {
+      process.stderr.write(
+        "warning: --fast is not implemented in v1; proceeding with headless renderer\n"
+      );
+    }
+    spinner = createSpinner("Extracting design tokens...");
+    const tokenSet = await extract(parsedOpts);
+    const filtered = filterByConfidence(tokenSet, parsedOpts.minConfidence);
+    const serialized = serialize(filtered, parsedOpts.format);
+    await writeAtomic(serialized, parsedOpts.out);
+    if (spinner !== null) spinner.succeed("Done");
+  } catch (err) {
+    if (spinner !== null) spinner.fail();
+    handleError(err);
+  }
+}
+function handleError(err) {
+  if (err instanceof z2.ZodError) {
+    const messages = err.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+    process.stderr.write(`Invalid options: ${messages}
+`);
+    process.exit(1);
+  }
+  if (err instanceof ExtractionError) {
+    process.stderr.write(`${err.message}
+`);
+    process.exit(err.exitCode);
+  }
+  if (err instanceof UserError) {
+    process.stderr.write(`${err.message}
+`);
+    process.exit(err.exitCode);
+  }
+  if (err instanceof DteError) {
+    process.stderr.write(`${err.message}
+`);
+    process.exit(err.exitCode);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Internal error: ${message}
+`);
+  process.exit(3);
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("design-token-extractor").description("Extract design tokens from any website into W3C DTCG JSON").version(CLI_VERSION, "-V, --version", "Print version");
+  program.command("extract").description("Extract tokens from a URL or local HTML file").argument(
+    "[url]",
+    "Target URL (http/https). Mutually exclusive with --file."
+  ).option("--file <path>", "Extract from local HTML file").option("-f, --format <fmt>", "Output format: json | css | js | md", "json").option("-o, --out <path>", "Output file path (default: stdout)").option("--timeout <seconds>", "Extraction timeout", "60").option(
+    "--min-confidence <num>",
+    "Filter tokens below this confidence",
+    "0"
+  ).option(
+    "--theme <mode>",
+    "Theme emulation: auto | light | dark",
+    "auto"
+  ).option("--fast", "Skip headless browser; static HTML only (v2)").option("--user-agent <string>", "Override User-Agent (reserved for v2)").option(
+    "--allow-private-hosts",
+    "Allow navigation to private / loopback / link-local addresses"
+  ).action(async (urlArg, flags) => {
+    await runExtract(urlArg, flags);
+  });
+  program.exitOverride((err) => {
+    if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+      process.exit(0);
+    }
+    process.exit(1);
+  });
+  return program;
+}
+async function main() {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    handleError(err);
+  }
+}
+void main();