@vettvangur/design-system 0.0.1

package/dist/generate-tailwind-BVpI-hUx.js

@@ -0,0 +1,1057 @@
+#!/usr/bin/env node
+import fs$1 from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'os';
+import require$$3 from 'crypto';
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import process$1 from 'node:process';
+
+var config$1 = {};
+
+var main$1 = {exports: {}};
+
+var name = "dotenv";
+var version = "16.4.5";
+var description = "Loads environment variables from .env file";
+var main = "lib/main.js";
+var types = "lib/main.d.ts";
+var exports = {
+	".": {
+		types: "./lib/main.d.ts",
+		require: "./lib/main.js",
+		"default": "./lib/main.js"
+	},
+	"./config": "./config.js",
+	"./config.js": "./config.js",
+	"./lib/env-options": "./lib/env-options.js",
+	"./lib/env-options.js": "./lib/env-options.js",
+	"./lib/cli-options": "./lib/cli-options.js",
+	"./lib/cli-options.js": "./lib/cli-options.js",
+	"./package.json": "./package.json"
+};
+var scripts = {
+	"dts-check": "tsc --project tests/types/tsconfig.json",
+	lint: "standard",
+	"lint-readme": "standard-markdown",
+	pretest: "npm run lint && npm run dts-check",
+	test: "tap tests/*.js --100 -Rspec",
+	"test:coverage": "tap --coverage-report=lcov",
+	prerelease: "npm test",
+	release: "standard-version"
+};
+var repository = {
+	type: "git",
+	url: "git://github.com/motdotla/dotenv.git"
+};
+var funding = "https://dotenvx.com";
+var keywords = [
+	"dotenv",
+	"env",
+	".env",
+	"environment",
+	"variables",
+	"config",
+	"settings"
+];
+var readmeFilename = "README.md";
+var license = "BSD-2-Clause";
+var devDependencies = {
+	"@definitelytyped/dtslint": "^0.0.133",
+	"@types/node": "^18.11.3",
+	decache: "^4.6.1",
+	sinon: "^14.0.1",
+	standard: "^17.0.0",
+	"standard-markdown": "^7.1.0",
+	"standard-version": "^9.5.0",
+	tap: "^16.3.0",
+	tar: "^6.1.11",
+	typescript: "^4.8.4"
+};
+var engines = {
+	node: ">=12"
+};
+var browser = {
+	fs: false
+};
+var require$$4 = {
+	name: name,
+	version: version,
+	description: description,
+	main: main,
+	types: types,
+	exports: exports,
+	scripts: scripts,
+	repository: repository,
+	funding: funding,
+	keywords: keywords,
+	readmeFilename: readmeFilename,
+	license: license,
+	devDependencies: devDependencies,
+	engines: engines,
+	browser: browser
+};
+
+var hasRequiredMain;
+function requireMain() {
+  if (hasRequiredMain) return main$1.exports;
+  hasRequiredMain = 1;
+  const fs = require$$0;
+  const path = require$$1;
+  const os = require$$2;
+  const crypto = require$$3;
+  const packageJson = require$$4;
+  const version = packageJson.version;
+  const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+  // Parse src into an Object
+  function parse(src) {
+    const obj = {};
+
+    // Convert buffer to string
+    let lines = src.toString();
+
+    // Convert line breaks to same format
+    lines = lines.replace(/\r\n?/mg, '\n');
+    let match;
+    while ((match = LINE.exec(lines)) != null) {
+      const key = match[1];
+
+      // Default undefined or null to empty string
+      let value = match[2] || '';
+
+      // Remove whitespace
+      value = value.trim();
+
+      // Check if double quoted
+      const maybeQuote = value[0];
+
+      // Remove surrounding quotes
+      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+      // Expand newlines if double quoted
+      if (maybeQuote === '"') {
+        value = value.replace(/\\n/g, '\n');
+        value = value.replace(/\\r/g, '\r');
+      }
+
+      // Add to object
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _parseVault(options) {
+    const vaultPath = _vaultPath(options);
+
+    // Parse .env.vault
+    const result = DotenvModule.configDotenv({
+      path: vaultPath
+    });
+    if (!result.parsed) {
+      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+      err.code = 'MISSING_DATA';
+      throw err;
+    }
+
+    // handle scenario for comma separated keys - for use with key rotation
+    // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+    const keys = _dotenvKey(options).split(',');
+    const length = keys.length;
+    let decrypted;
+    for (let i = 0; i < length; i++) {
+      try {
+        // Get full key
+        const key = keys[i].trim();
+
+        // Get instructions for decrypt
+        const attrs = _instructions(result, key);
+
+        // Decrypt
+        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+        break;
+      } catch (error) {
+        // last key
+        if (i + 1 >= length) {
+          throw error;
+        }
+        // try next key
+      }
+    }
+
+    // Parse decrypted .env string
+    return DotenvModule.parse(decrypted);
+  }
+  function _log(message) {
+    console.log(`[dotenv@${version}][INFO] ${message}`);
+  }
+  function _warn(message) {
+    console.log(`[dotenv@${version}][WARN] ${message}`);
+  }
+  function _debug(message) {
+    console.log(`[dotenv@${version}][DEBUG] ${message}`);
+  }
+  function _dotenvKey(options) {
+    // prioritize developer directly setting options.DOTENV_KEY
+    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+      return options.DOTENV_KEY;
+    }
+
+    // secondary infra already contains a DOTENV_KEY environment variable
+    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+      return process.env.DOTENV_KEY;
+    }
+
+    // fallback to empty string
+    return '';
+  }
+  function _instructions(result, dotenvKey) {
+    // Parse DOTENV_KEY. Format is a URI
+    let uri;
+    try {
+      uri = new URL(dotenvKey);
+    } catch (error) {
+      if (error.code === 'ERR_INVALID_URL') {
+        const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+        err.code = 'INVALID_DOTENV_KEY';
+        throw err;
+      }
+      throw error;
+    }
+
+    // Get decrypt key
+    const key = uri.password;
+    if (!key) {
+      const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err;
+    }
+
+    // Get environment
+    const environment = uri.searchParams.get('environment');
+    if (!environment) {
+      const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err;
+    }
+
+    // Get ciphertext payload
+    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+    const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+    if (!ciphertext) {
+      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+      err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+      throw err;
+    }
+    return {
+      ciphertext,
+      key
+    };
+  }
+  function _vaultPath(options) {
+    let possibleVaultPath = null;
+    if (options && options.path && options.path.length > 0) {
+      if (Array.isArray(options.path)) {
+        for (const filepath of options.path) {
+          if (fs.existsSync(filepath)) {
+            possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+          }
+        }
+      } else {
+        possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+      }
+    } else {
+      possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
+    }
+    if (fs.existsSync(possibleVaultPath)) {
+      return possibleVaultPath;
+    }
+    return null;
+  }
+  function _resolveHome(envPath) {
+    return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+  }
+  function _configVault(options) {
+    _log('Loading env from encrypted .env.vault');
+    const parsed = DotenvModule._parseVault(options);
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsed, options);
+    return {
+      parsed
+    };
+  }
+  function configDotenv(options) {
+    const dotenvPath = path.resolve(process.cwd(), '.env');
+    let encoding = 'utf8';
+    const debug = Boolean(options && options.debug);
+    if (options && options.encoding) {
+      encoding = options.encoding;
+    } else {
+      if (debug) {
+        _debug('No encoding is specified. UTF-8 is used by default');
+      }
+    }
+    let optionPaths = [dotenvPath]; // default, look for .env
+    if (options && options.path) {
+      if (!Array.isArray(options.path)) {
+        optionPaths = [_resolveHome(options.path)];
+      } else {
+        optionPaths = []; // reset default
+        for (const filepath of options.path) {
+          optionPaths.push(_resolveHome(filepath));
+        }
+      }
+    }
+
+    // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+    // parsed data, we will combine it with process.env (or options.processEnv if provided).
+    let lastError;
+    const parsedAll = {};
+    for (const path of optionPaths) {
+      try {
+        // Specifying an encoding returns a string instead of a buffer
+        const parsed = DotenvModule.parse(fs.readFileSync(path, {
+          encoding
+        }));
+        DotenvModule.populate(parsedAll, parsed, options);
+      } catch (e) {
+        if (debug) {
+          _debug(`Failed to load ${path} ${e.message}`);
+        }
+        lastError = e;
+      }
+    }
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsedAll, options);
+    if (lastError) {
+      return {
+        parsed: parsedAll,
+        error: lastError
+      };
+    } else {
+      return {
+        parsed: parsedAll
+      };
+    }
+  }
+
+  // Populates process.env from .env file
+  function config(options) {
+    // fallback to original dotenv if DOTENV_KEY is not set
+    if (_dotenvKey(options).length === 0) {
+      return DotenvModule.configDotenv(options);
+    }
+    const vaultPath = _vaultPath(options);
+
+    // dotenvKey exists but .env.vault file does not exist
+    if (!vaultPath) {
+      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+      return DotenvModule.configDotenv(options);
+    }
+    return DotenvModule._configVault(options);
+  }
+  function decrypt(encrypted, keyStr) {
+    const key = Buffer.from(keyStr.slice(-64), 'hex');
+    let ciphertext = Buffer.from(encrypted, 'base64');
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(-16);
+    ciphertext = ciphertext.subarray(12, -16);
+    try {
+      const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+      aesgcm.setAuthTag(authTag);
+      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+    } catch (error) {
+      const isRange = error instanceof RangeError;
+      const invalidKeyLength = error.message === 'Invalid key length';
+      const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
+      if (isRange || invalidKeyLength) {
+        const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
+        err.code = 'INVALID_DOTENV_KEY';
+        throw err;
+      } else if (decryptionFailed) {
+        const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
+        err.code = 'DECRYPTION_FAILED';
+        throw err;
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  // Populate process.env with parsed values
+  function populate(processEnv, parsed, options = {}) {
+    const debug = Boolean(options && options.debug);
+    const override = Boolean(options && options.override);
+    if (typeof parsed !== 'object') {
+      const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
+      err.code = 'OBJECT_REQUIRED';
+      throw err;
+    }
+
+    // Set process.env
+    for (const key of Object.keys(parsed)) {
+      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+        if (override === true) {
+          processEnv[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _debug(`"${key}" is already defined and WAS overwritten`);
+          } else {
+            _debug(`"${key}" is already defined and was NOT overwritten`);
+          }
+        }
+      } else {
+        processEnv[key] = parsed[key];
+      }
+    }
+  }
+  const DotenvModule = {
+    configDotenv,
+    _configVault,
+    _parseVault,
+    config,
+    decrypt,
+    parse,
+    populate
+  };
+  main$1.exports.configDotenv = DotenvModule.configDotenv;
+  main$1.exports._configVault = DotenvModule._configVault;
+  main$1.exports._parseVault = DotenvModule._parseVault;
+  main$1.exports.config = DotenvModule.config;
+  main$1.exports.decrypt = DotenvModule.decrypt;
+  main$1.exports.parse = DotenvModule.parse;
+  main$1.exports.populate = DotenvModule.populate;
+  main$1.exports = DotenvModule;
+  return main$1.exports;
+}
+
+var envOptions;
+var hasRequiredEnvOptions;
+function requireEnvOptions() {
+  if (hasRequiredEnvOptions) return envOptions;
+  hasRequiredEnvOptions = 1;
+  // ../config.js accepts options via environment variables
+  const options = {};
+  if (process.env.DOTENV_CONFIG_ENCODING != null) {
+    options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+  }
+  if (process.env.DOTENV_CONFIG_PATH != null) {
+    options.path = process.env.DOTENV_CONFIG_PATH;
+  }
+  if (process.env.DOTENV_CONFIG_DEBUG != null) {
+    options.debug = process.env.DOTENV_CONFIG_DEBUG;
+  }
+  if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+    options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+  }
+  if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+    options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+  }
+  envOptions = options;
+  return envOptions;
+}
+
+var cliOptions;
+var hasRequiredCliOptions;
+function requireCliOptions() {
+  if (hasRequiredCliOptions) return cliOptions;
+  hasRequiredCliOptions = 1;
+  const re = /^dotenv_config_(encoding|path|debug|override|DOTENV_KEY)=(.+)$/;
+  cliOptions = function optionMatcher(args) {
+    return args.reduce(function (acc, cur) {
+      const matches = cur.match(re);
+      if (matches) {
+        acc[matches[1]] = matches[2];
+      }
+      return acc;
+    }, {});
+  };
+  return cliOptions;
+}
+
+var hasRequiredConfig;
+function requireConfig() {
+  if (hasRequiredConfig) return config$1;
+  hasRequiredConfig = 1;
+  (function () {
+    requireMain().config(Object.assign({}, requireEnvOptions(), requireCliOptions()(process.argv)));
+  })();
+  return config$1;
+}
+
+requireConfig();
+
+// src/load-config.mjs
+function req(name, val) {
+  if (val === undefined || val === null) {
+    throw new Error(`[vettvangur-styleguide :: load-config] Missing required config field: ${name}`);
+  }
+  return val;
+}
+
+// Also load .env.local if present (priority over .env)
+const rootCwd = process$1.cwd();
+const envLocal = path.join(rootCwd, ".env.local");
+if (fs.existsSync(envLocal)) {
+  const dotenv = await import('dotenv');
+  dotenv.config({
+    path: envLocal,
+    override: true
+  });
+}
+const cfgFile = path.resolve(rootCwd, "vettvangur.config.mjs");
+const mod = await import(pathToFileURL(cfgFile).href);
+const config = mod.default ?? mod;
+const root = rootCwd;
+
+// Accept either config.figma.key or env (FIGMA_KEY/FIGMA_TOKEN); file from config or FIGMA_FILE
+const figmaKey = config?.figma?.key ?? process$1.env.FIGMA_KEY ?? process$1.env.FIGMA_TOKEN ?? null;
+const figmaFile = config?.figma?.file ?? process$1.env.FIGMA_FILE ?? null;
+const paths = {
+  root,
+  dest: path.resolve(root, req("dest", config.dest)),
+  public: path.resolve(root, req("public", config.public)),
+  assets: path.resolve(root, req("assets", config.assets)),
+  styles: path.resolve(root, req("styles.path", config.styles.path)),
+  styleEntries: req("styles.entries", config.styles.entries).map(p => path.isAbsolute(p) ? p : path.resolve(root, p)),
+  scripts: path.resolve(root, req("scripts.path", config.scripts.path)),
+  scriptEntries: req("scripts.entries", config.scripts.entries).map(p => path.isAbsolute(p) ? p : path.resolve(root, p)),
+  views: path.resolve(root, req("views", config.views)),
+  watch: config.watch,
+  figma: {
+    key: req("figma.key", figmaKey),
+    file: req("figma.file", figmaFile)
+  }
+};
+
+// ---- HTTPS (safe, never throws) --------------------------------------------
+function makeHttpsCfg(cfg) {
+  const ds = cfg?.devserver ?? {};
+  const h = ds.https;
+  if (h === false) return false;
+  if (h && typeof h === "object") {
+    if (h.key && h.cert) return {
+      key: h.key,
+      cert: h.cert
+    };
+    if (h.keyfile && h.certfile) {
+      try {
+        if (fs.existsSync(h.keyfile) && fs.existsSync(h.certfile)) {
+          return {
+            key: fs.readFileSync(h.keyfile),
+            cert: fs.readFileSync(h.certfile)
+          };
+        }
+      } catch {
+        /* swallow */
+      }
+      return false;
+    }
+  }
+  if (ds.keyfile && ds.certfile) {
+    try {
+      if (fs.existsSync(ds.keyfile) && fs.existsSync(ds.certfile)) {
+        return {
+          key: fs.readFileSync(ds.keyfile),
+          cert: fs.readFileSync(ds.certfile)
+        };
+      }
+    } catch {
+      /* swallow */
+    }
+  }
+  return false;
+}
+makeHttpsCfg(config);
+
+// ---- flags -----------------------------------------------------------------
+({
+  useSass: config.styles?.type === "sass",
+  useTailwind: config.styles?.type === "tailwind"
+});
+
+// figma-exporter.mjs
+// Usage: import exporter from './figma-exporter.mjs'; const json = await exporter('<FILE_KEY>');
+// Requires: FIGMA_TOKEN env (or hardcode TOKEN below)
+const tag$1 = chalk.cyan('[design-system]');
+
+// ---------- utils ----------
+const toKebab = s => s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+const hex2 = n => n.toString(16).padStart(2, "0");
+function rgba255(c) {
+  const a = typeof c.a === "number" ? c.a : 1;
+  return {
+    r: Math.round(c.r * 255),
+    g: Math.round(c.g * 255),
+    b: Math.round(c.b * 255),
+    a
+  };
+}
+function colorToHexRgba(c) {
+  const r = Math.round(c.r * 255),
+    g = Math.round(c.g * 255),
+    b = Math.round(c.b * 255);
+  const a = typeof c.a === "number" ? c.a : 1;
+  return `#${hex2(r)}${hex2(g)}${hex2(b)}${a < 1 ? hex2(Math.round(a * 255)) : ""}`;
+}
+
+// ---------- text metric shims ----------
+function readLineHeight(style) {
+  const s = style || {};
+  // 1) New object form
+  if (s.lineHeight && typeof s.lineHeight === "object") {
+    const u = s.lineHeight.unit || s.lineHeight.lineHeightUnit;
+    const v = s.lineHeight.value || s.lineHeight.lineHeightPx || s.lineHeight.percent;
+    if ((u === "PERCENT" || u === "FONT_SIZE_%") && typeof v === "number" && v > 0) {
+      return {
+        unit: "%",
+        value: v
+      };
+    }
+    if (u === "PIXELS" && typeof v === "number" && v > 0) {
+      return {
+        unit: "px",
+        value: v
+      };
+    }
+  }
+
+  // 2) Legacy percent fields (prefer percent over px)
+  if (typeof s.lineHeightPercentFontSize === "number" && s.lineHeightPercentFontSize > 0) {
+    return {
+      unit: "%",
+      value: s.lineHeightPercentFontSize
+    };
+  }
+  if (typeof s.lineHeightPercent === "number" && s.lineHeightPercent > 0) {
+    return {
+      unit: "%",
+      value: s.lineHeightPercent
+    };
+  }
+
+  // 3) If unit is percent but only px is present, derive percent
+  if ((s.lineHeightUnit === "FONT_SIZE_%" || s.lineHeightUnit === "PERCENT") && typeof s.lineHeightPx === "number" && typeof s.fontSize === "number" && s.fontSize > 0) {
+    const pct = s.lineHeightPx / s.fontSize * 100;
+    return {
+      unit: "%",
+      value: Math.round(pct * 100) / 100
+    };
+  }
+
+  // 4) Plain px
+  if (typeof s.lineHeightPx === "number" && s.lineHeightPx > 0) {
+    return {
+      unit: "px",
+      value: s.lineHeightPx
+    };
+  }
+
+  // 5) Last-resort derivation from numeric lineHeight + fontSize
+  if (typeof s.lineHeight === "number" && typeof s.fontSize === "number" && s.fontSize > 0) {
+    const pct = s.lineHeight / s.fontSize * 100;
+    return {
+      unit: "%",
+      value: Math.round(pct * 100) / 100
+    };
+  }
+  return null;
+}
+function readLetterSpacing(style) {
+  if (style?.letterSpacing && typeof style.letterSpacing === "object") {
+    const u = style.letterSpacing.unit || style.letterSpacingUnit;
+    const v = style.letterSpacing.value || style.letterSpacingPx || style.letterSpacing.percent;
+    if (u === "PIXELS" && typeof v === "number") return {
+      unit: "px",
+      value: v
+    };
+    if (u === "PERCENT" && typeof v === "number") return {
+      unit: "%",
+      value: v
+    };
+  }
+  if (typeof style?.letterSpacing === "number" && style?.letterSpacingUnit === "PIXELS") return {
+    unit: "px",
+    value: style.letterSpacing
+  };
+  if (typeof style?.letterSpacingPercent === "number") return {
+    unit: "%",
+    value: style.letterSpacingPercent
+  };
+  if (typeof style?.letterSpacingPercentFontSize === "number") return {
+    unit: "%",
+    value: style.letterSpacingPercentFontSize
+  };
+  return null;
+}
+
+// ---------- HTTP ----------
+async function jget(url) {
+  const HEADERS = {
+    "X-Figma-Token": paths.figma.key,
+    "Content-Type": "application/json"
+  };
+  const r = await fetch(url, {
+    headers: HEADERS
+  });
+  if (!r.ok) {
+    const body = await r.text().catch(() => "");
+    throw new Error(`${r.status} ${r.statusText} – ${url}\n${body}`);
+  }
+  return r.json();
+}
+
+// ---------- variables (optional; Enterprise + file_variables:read) ----------
+async function fetchVariablesLocal(fileKey) {
+  console.log(`${tag$1} fetching variables...`);
+  try {
+    const res = await jget(`https://api.figma.com/v1/files/${fileKey}/variables/local`);
+    const meta = res?.meta ?? {};
+    const vars = meta.variables ?? {};
+    const cols = meta.variableCollections ?? {};
+    const byCollection = {};
+    for (const colId of Object.keys(cols)) {
+      const c = cols[colId];
+      const colKey = toKebab(c.name);
+      byCollection[colKey] = {
+        id: c.id,
+        name: c.name,
+        modes: (c.modes || []).map(m => ({
+          id: m.modeId,
+          name: m.name,
+          key: toKebab(m.name)
+        })),
+        tokens: {}
+      };
+    }
+    function resolveAlias(value, depth = 0) {
+      if (!value || typeof value !== "object") return value;
+      if (value.type === "VARIABLE_ALIAS" && value.id && depth < 20) {
+        const aliased = vars[value.id];
+        if (!aliased) return value;
+        const coll = cols[aliased.variableCollectionId];
+        const modeOrder = (coll?.modes || []).map(m => m.modeId);
+        const pick = modeOrder[0] || Object.keys(aliased.valuesByMode || {})[0];
+        return resolveAlias(aliased.valuesByMode?.[pick], depth + 1);
+      }
+      return value;
+    }
+    for (const vId of Object.keys(vars)) {
+      const v = vars[vId];
+      const coll = cols[v.variableCollectionId];
+      if (!coll) continue;
+      const colKey = toKebab(coll.name);
+      const nameKey = toKebab(v.name);
+      const token = {
+        id: v.id,
+        name: v.name,
+        type: v.resolvedType,
+        values: {}
+      };
+      for (const [modeId, raw] of Object.entries(v.valuesByMode || {})) {
+        const mode = (coll.modes || []).find(m => m.modeId === modeId);
+        if (!mode) continue;
+        const val = resolveAlias(raw);
+        if (v.resolvedType === "FLOAT" || v.resolvedType === "BOOLEAN" || v.resolvedType === "STRING") {
+          token.values[mode.name] = val ?? null;
+        } else if (v.resolvedType === "COLOR" && val && typeof val === "object" && "r" in val) {
+          token.values[mode.name] = {
+            hex: colorToHexRgba(val),
+            rgba: rgba255(val)
+          };
+        } else {
+          token.values[mode.name] = null;
+        }
+      }
+      byCollection[colKey].tokens[nameKey] = token;
+    }
+    return byCollection;
+  } catch {
+    return {};
+  }
+}
+
+// ---------- styles (two sources) ----------
+async function fetchStyleNodeIds_fromFile(fileKey) {
+  const file = await jget(`https://api.figma.com/v1/files/${fileKey}`);
+  return file?.styles || {};
+}
+async function fetchStyleNodeIds_published(fileKey) {
+  try {
+    const res = await jget(`https://api.figma.com/v1/files/${fileKey}/styles`);
+    const arr = Array.isArray(res?.meta?.styles) ? res.meta.styles : [];
+    const map = {};
+    for (const s of arr) map[s.key] = s;
+    return map;
+  } catch {
+    return {};
+  }
+}
+async function fetchMergedStyleNodeIds(fileKey) {
+  const a = await fetchStyleNodeIds_fromFile(fileKey);
+  const b = await fetchStyleNodeIds_published(fileKey);
+  return {
+    ...a,
+    ...b
+  };
+}
+
+// ---------- nodes (batched) ----------
+async function fetchNodesByIds(fileKey, allIds) {
+  console.log(`${tag$1} reading nodes by id...`);
+  const ids = Array.from(new Set((allIds || []).filter(Boolean).map(String).map(s => s.trim()).filter(s => s.length > 0)));
+  const out = [];
+  const CHUNK = 50;
+  for (let i = 0; i < ids.length; i += CHUNK) {
+    const slice = ids.slice(i, i + CHUNK);
+    const qs = slice.map(encodeURIComponent).join(",");
+    const url = `https://api.figma.com/v1/files/${fileKey}/nodes?ids=${qs}`;
+    const res = await jget(url);
+    const nodes = res?.nodes || {};
+    for (const k of Object.keys(nodes)) {
+      const doc = nodes[k]?.document;
+      if (doc) out.push(doc);
+    }
+  }
+  return out;
+}
+
+// ---------- text props derivation ----------
+function weightFromStyleName(s) {
+  if (!s) return undefined;
+  const x = s.toLowerCase();
+  if (/\b(100|thin)\b/.test(x)) return 100;
+  if (/\b(200|extralight|ultralight)\b/.test(x)) return 200;
+  if (/\b(300|light)\b/.test(x)) return 300;
+  if (/\b(400|regular|book|normal)\b/.test(x)) return 400;
+  if (/\b(500|medium)\b/.test(x)) return 500;
+  if (/\b(600|semibold|demibold)\b/.test(x)) return 600;
+  if (/\b(700|bold)\b/.test(x)) return 700;
+  if (/\b(800|extrabold|ultrabold|heavy)\b/.test(x)) return 800;
+  if (/\b(900|black|heavy)\b/.test(x)) return 900;
+  const m = s.match(/\b(100|200|300|400|500|600|700|800|900)\b/);
+  return m ? Number(m[1]) : undefined;
+}
+function deriveFontStyle(style) {
+  if (typeof style?.fontStyle === "string" && style.fontStyle.trim()) return style.fontStyle;
+  const ps = style?.fontPostScriptName || "";
+  const tail = ps.includes("-") ? ps.split("-")[1] : ps;
+  if (/italic/i.test(tail)) return "Italic";
+  if (/oblique/i.test(tail)) return "Oblique";
+  if (/regular|book|normal/i.test(tail)) return "Regular";
+  const token = (tail.match(/[A-Za-z]+$/) || [])[0];
+  return token ? token[0].toUpperCase() + token.slice(1) : undefined;
+}
+function readTextProps(n) {
+  const s = n.style || n;
+  const styleName = s.fontStyle || s.fontPostScriptName || "";
+  return {
+    fontFamily: s.fontFamily || n.fontFamily,
+    fontStyle: deriveFontStyle(s),
+    fontWeight: typeof s.fontWeight === "number" ? s.fontWeight : weightFromStyleName(styleName),
+    fontSize: s.fontSize ?? n.fontSize,
+    lineHeight: readLineHeight(s),
+    letterSpacing: readLetterSpacing(s),
+    paragraphSpacing: typeof s.paragraphSpacing === "number" ? s.paragraphSpacing : typeof n.paragraphSpacing === "number" ? n.paragraphSpacing : 0,
+    textCase: s.textCase || n.textCase || "ORIGINAL",
+    textDecoration: s.textDecoration || n.textDecoration || "NONE"
+  };
+}
+
+// ---------- normalizers ----------
+function emitPaintStylesJson(styleMetas, nodes) {
+  const byId = {};
+  for (const n of nodes) {
+    const paints = Array.isArray(n.paints) ? n.paints : Array.isArray(n.fills) ? n.fills : null;
+    if (!paints) continue;
+    const meta = Object.values(styleMetas).find(m => m.node_id === n.id && m.style_type === "FILL");
+    if (!meta) continue;
+    const solids = [];
+    for (const p of paints) {
+      if (p?.type !== "SOLID" || p?.visible === false) continue;
+      const a = typeof p.opacity === "number" ? p.opacity : 1;
+      solids.push({
+        hex: colorToHexRgba({
+          ...p.color,
+          a
+        }),
+        rgba: rgba255({
+          ...p.color,
+          a
+        })
+      });
+    }
+    if (solids.length) {
+      const key = toKebab(meta.name);
+      byId[key] = {
+        id: meta.key || meta.node_id,
+        name: meta.name,
+        paints: solids
+      };
+    }
+  }
+  console.log(`${tag$1} finished reading paint styles`);
+  return byId;
+}
+function emitTextStylesJson(styleMetas, nodes) {
+  const out = {};
+  for (const n of nodes) {
+    const meta = Object.values(styleMetas).find(m => m.node_id === n.id && m.style_type === "TEXT");
+    if (!meta) continue;
+    const key = toKebab(meta.name);
+    const p = readTextProps(n);
+    out[key] = {
+      id: meta.key || meta.node_id,
+      name: meta.name,
+      fontFamily: p.fontFamily,
+      fontStyle: p.fontStyle,
+      fontWeight: p.fontWeight,
+      fontSize: p.fontSize,
+      lineHeight: p.lineHeight,
+      letterSpacing: p.letterSpacing,
+      paragraphSpacing: p.paragraphSpacing,
+      textCase: p.textCase,
+      textDecoration: p.textDecoration
+    };
+  }
+  console.log(`${tag$1} finished reading text styles`);
+  return out;
+}
+function effectToJson(e) {
+  if (e?.visible === false) return null;
+  if (e?.type === "DROP_SHADOW" || e?.type === "INNER_SHADOW") {
+    const spread = typeof e.spread === "number" ? Math.round(e.spread) : 0;
+    return {
+      kind: e.type,
+      offset: {
+        x: Math.round(e.offset?.x ?? 0),
+        y: Math.round(e.offset?.y ?? 0)
+      },
+      radius: Math.round(e.radius ?? 0),
+      spread,
+      color: {
+        hex: colorToHexRgba(e.color),
+        rgba: rgba255(e.color)
+      }
+    };
+  }
+  if (e?.type === "LAYER_BLUR" || e?.type === "BACKGROUND_BLUR") {
+    return {
+      kind: e.type,
+      radius: Math.round(e.radius ?? 0)
+    };
+  }
+  return null;
+}
+function emitEffectStylesJson(styleMetas, nodes) {
+  const out = {};
+  for (const n of nodes) {
+    const meta = Object.values(styleMetas).find(m => m.node_id === n.id && m.style_type === "EFFECT");
+    if (!meta) continue;
+    const list = [];
+    const effects = Array.isArray(n.effects) ? n.effects : [];
+    for (const e of effects) {
+      const obj = effectToJson(e);
+      if (obj) list.push(obj);
+    }
+    if (list.length) {
+      const key = toKebab(meta.name);
+      out[key] = {
+        id: meta.key || meta.node_id,
+        name: meta.name,
+        effects: list
+      };
+    }
+  }
+  console.log(`${tag$1} finished reading effect styles`);
+  return out;
+}
+
+// ---------- exporter ----------
+const exporter = async function (fileKey) {
+  if (!fileKey) throw new Error("Missing FILE_KEY");
+  console.log(`${tag$1} reading from figma`);
+  const variablesByCollection = await fetchVariablesLocal(fileKey);
+  const stylesMap = await fetchMergedStyleNodeIds(fileKey);
+  const styleNodeIds = Object.values(stylesMap).filter(s => s && (s.style_type === "FILL" || s.style_type === "TEXT" || s.style_type === "EFFECT")).map(s => s.node_id);
+  if (styleNodeIds.length === 0) {
+    return {
+      paint: {},
+      text: {},
+      effect: {},
+      variables: variablesByCollection
+    };
+  }
+  const styleNodes = await fetchNodesByIds(fileKey, styleNodeIds);
+  const paint = emitPaintStylesJson(stylesMap, styleNodes);
+  const text = emitTextStylesJson(stylesMap, styleNodes);
+  const effect = emitEffectStylesJson(stylesMap, styleNodes);
+  console.log('text', text);
+  return {
+    paint,
+    text,
+    effect,
+    variables: variablesByCollection
+  };
+};
+
+const tag = chalk.cyan('[design-system]');
+
+/*
+  * This needs to genrate:
+  * variables:
+    * color.css
+    * font.css
+    * radius.css
+    * shadow.css
+    * typography.css
+  * core:
+    * body.css
+    * headline.css
+*/
+
+async function generateTailwind() {
+  console.log(`${chalk.cyan(tag)} starting tailwind...`);
+  const figmaStyles = await exporter(paths.figma.file);
+  await generateColors(figmaStyles.paint);
+  console.log(`${tag} completed tailwind`);
+}
+
+// ------- VARIABLES -------
+async function generateColors(data) {
+  console.log(`${tag} generating colors...`);
+  const outDir = path.join(paths.styles, 'config');
+  await fs$1.mkdir(outDir, {
+    recursive: true
+  });
+  const lines = [];
+  for (const [key, entry] of Object.entries(data ?? {})) {
+    const paints = entry?.paints ?? [];
+    const p = paints[0] ?? {};
+    // exporter already normalizes; prefer .hex/.value, else stringify fallback
+    const value = (p.hex && String(p.hex)) ?? (p.value && String(p.value)) ?? (p.css && String(p.css)) ?? String(p);
+    if (!value) {
+      continue;
+    }
+    lines.push(`  --color-${key}: ${value};`);
+  }
+  const css = `/* Auto-generated. Do not edit by hand. */
+@theme {
+${lines.join('\n')}
+}
+`;
+  const filePath = path.join(outDir, 'color.css');
+  await fs$1.writeFile(filePath, css, 'utf8');
+  console.log(`${tag} finished generating colors`);
+}
+
+export { generateTailwind as default, generateTailwind };