@nice2dev/design-tokens 1.0.28

package/dist/cli/index.cjs

@@ -0,0 +1,3018 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@nice2dev/design-tokens",
+      version: "1.0.28",
+      description: "W3C Design Tokens for Nice2Dev UI with CLI generator",
+      type: "module",
+      main: "./dist/index.cjs",
+      module: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      sideEffects: false,
+      exports: {
+        ".": {
+          import: "./dist/index.js",
+          require: "./dist/index.cjs",
+          types: "./dist/index.d.ts"
+        },
+        "./tokens/*": "./tokens/*",
+        "./cli": "./dist/cli/index.js"
+      },
+      bin: {
+        "nice-tokens": "./dist/cli/index.js"
+      },
+      files: [
+        "dist",
+        "tokens"
+      ],
+      scripts: {
+        build: "tsup src/index.ts src/cli/index.ts --format esm,cjs --dts --clean",
+        dev: "tsup src/index.ts src/cli/index.ts --format esm,cjs --dts --watch",
+        generate: "node dist/cli/index.js generate",
+        test: "vitest run --passWithNoTests",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "chroma-js": "^2.4.2",
+        commander: "^12.1.0",
+        "fast-glob": "^3.3.2"
+      },
+      devDependencies: {
+        "@types/chroma-js": "^2.4.4",
+        "@types/node": "^20.14.10",
+        tsup: "^8.3.5",
+        typescript: "^5.7.2",
+        vitest: "^2.1.8"
+      },
+      keywords: [
+        "design-tokens",
+        "w3c",
+        "css-variables",
+        "nice2dev",
+        "design-system"
+      ],
+      author: "Nice2Dev",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/nicetogit/nice2dev-ui.git",
+        directory: "packages/design-tokens"
+      }
+    };
+  }
+});
+
+// ../../node_modules/readdirp/esm/index.js
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+var import_promises, import_node_stream, import_node_path, EntryTypes, defaultOptions2, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
+var init_esm = __esm({
+  "../../node_modules/readdirp/esm/index.js"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_stream = require("stream");
+    import_node_path = require("path");
+    EntryTypes = {
+      FILE_TYPE: "files",
+      DIR_TYPE: "directories",
+      FILE_DIR_TYPE: "files_directories",
+      EVERYTHING_TYPE: "all"
+    };
+    defaultOptions2 = {
+      root: ".",
+      fileFilter: (_entryInfo) => true,
+      directoryFilter: (_entryInfo) => true,
+      type: EntryTypes.FILE_TYPE,
+      lstat: false,
+      depth: 2147483648,
+      alwaysStat: false,
+      highWaterMark: 4096
+    };
+    Object.freeze(defaultOptions2);
+    RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+    NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+    ALL_TYPES = [
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ];
+    DIR_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE
+    ]);
+    FILE_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ]);
+    isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+    wantBigintFsStats = process.platform === "win32";
+    emptyFn = (_entryInfo) => true;
+    normalizeFilter = (filter) => {
+      if (filter === void 0)
+        return emptyFn;
+      if (typeof filter === "function")
+        return filter;
+      if (typeof filter === "string") {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+      }
+      if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+      }
+      return emptyFn;
+    };
+    ReaddirpStream = class extends import_node_stream.Readable {
+      constructor(options = {}) {
+        super({
+          objectMode: true,
+          autoDestroy: true,
+          highWaterMark: options.highWaterMark
+        });
+        const opts = { ...defaultOptions2, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
+        if (wantBigintFsStats) {
+          this._stat = (path3) => statMethod(path3, { bigint: true });
+        } else {
+          this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions2.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, import_node_path.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? "dirent" : "stats";
+        this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = void 0;
+      }
+      async _read(batch) {
+        if (this.reading)
+          return;
+        this.reading = true;
+        try {
+          while (!this.destroyed && batch > 0) {
+            const par = this.parent;
+            const fil = par && par.files;
+            if (fil && fil.length > 0) {
+              const { path: path3, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path3));
+              const awaited = await Promise.all(slice);
+              for (const entry of awaited) {
+                if (!entry)
+                  continue;
+                if (this.destroyed)
+                  return;
+                const entryType = await this._getEntryType(entry);
+                if (entryType === "directory" && this._directoryFilter(entry)) {
+                  if (depth <= this._maxDepth) {
+                    this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                  }
+                  if (this._wantsDir) {
+                    this.push(entry);
+                    batch--;
+                  }
+                } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+                  if (this._wantsFile) {
+                    this.push(entry);
+                    batch--;
+                  }
+                }
+              }
+            } else {
+              const parent = this.parents.pop();
+              if (!parent) {
+                this.push(null);
+                break;
+              }
+              this.parent = await parent;
+              if (this.destroyed)
+                return;
+            }
+          }
+        } catch (error) {
+          this.destroy(error);
+        } finally {
+          this.reading = false;
+        }
+      }
+      async _exploreDir(path3, depth) {
+        let files;
+        try {
+          files = await (0, import_promises.readdir)(path3, this._rdOptions);
+        } catch (error) {
+          this._onError(error);
+        }
+        return { files, depth, path: path3 };
+      }
+      async _formatEntry(dirent, path3) {
+        let entry;
+        const basename4 = this._isDirent ? dirent.name : dirent;
+        try {
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path3, basename4));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename4 };
+          entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        } catch (err) {
+          this._onError(err);
+          return;
+        }
+        return entry;
+      }
+      _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+          this.emit("warn", err);
+        } else {
+          this.destroy(err);
+        }
+      }
+      async _getEntryType(entry) {
+        if (!entry && this._statsProp in entry) {
+          return "";
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+          return "file";
+        if (stats.isDirectory())
+          return "directory";
+        if (stats && stats.isSymbolicLink()) {
+          const full = entry.fullPath;
+          try {
+            const entryRealPath = await (0, import_promises.realpath)(full);
+            const entryRealPathStats = await (0, import_promises.lstat)(entryRealPath);
+            if (entryRealPathStats.isFile()) {
+              return "file";
+            }
+            if (entryRealPathStats.isDirectory()) {
+              const len = entryRealPath.length;
+              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path.sep) {
+                const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                recursiveError.code = RECURSIVE_ERROR_CODE;
+                return this._onError(recursiveError);
+              }
+              return "directory";
+            }
+          } catch (error) {
+            this._onError(error);
+            return "";
+          }
+        }
+      }
+      _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+      }
+    };
+  }
+});
+
+// ../../node_modules/chokidar/esm/handler.js
+function createFsWatchInstance(path3, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path3);
+    emitRaw(rawEvent, evPath, { watchedPath: path3 });
+    if (evPath && path3 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path3, evPath), KEY_LISTENERS, sysPath.join(path3, evPath));
+    }
+  };
+  try {
+    return (0, import_fs.watch)(path3, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var import_fs, import_promises2, sysPath, import_os, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var init_handler = __esm({
+  "../../node_modules/chokidar/esm/handler.js"() {
+    "use strict";
+    import_fs = require("fs");
+    import_promises2 = require("fs/promises");
+    sysPath = __toESM(require("path"), 1);
+    import_os = require("os");
+    STR_DATA = "data";
+    STR_END = "end";
+    STR_CLOSE = "close";
+    EMPTY_FN = () => {
+    };
+    pl = process.platform;
+    isWindows = pl === "win32";
+    isMacos = pl === "darwin";
+    isLinux = pl === "linux";
+    isFreeBSD = pl === "freebsd";
+    isIBMi = (0, import_os.type)() === "OS400";
+    EVENTS = {
+      ALL: "all",
+      READY: "ready",
+      ADD: "add",
+      CHANGE: "change",
+      ADD_DIR: "addDir",
+      UNLINK: "unlink",
+      UNLINK_DIR: "unlinkDir",
+      RAW: "raw",
+      ERROR: "error"
+    };
+    EV = EVENTS;
+    THROTTLE_MODE_WATCH = "watch";
+    statMethods = { lstat: import_promises2.lstat, stat: import_promises2.stat };
+    KEY_LISTENERS = "listeners";
+    KEY_ERR = "errHandlers";
+    KEY_RAW = "rawEmitters";
+    HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+    binaryExtensions = /* @__PURE__ */ new Set([
+      "3dm",
+      "3ds",
+      "3g2",
+      "3gp",
+      "7z",
+      "a",
+      "aac",
+      "adp",
+      "afdesign",
+      "afphoto",
+      "afpub",
+      "ai",
+      "aif",
+      "aiff",
+      "alz",
+      "ape",
+      "apk",
+      "appimage",
+      "ar",
+      "arj",
+      "asf",
+      "au",
+      "avi",
+      "bak",
+      "baml",
+      "bh",
+      "bin",
+      "bk",
+      "bmp",
+      "btif",
+      "bz2",
+      "bzip2",
+      "cab",
+      "caf",
+      "cgm",
+      "class",
+      "cmx",
+      "cpio",
+      "cr2",
+      "cur",
+      "dat",
+      "dcm",
+      "deb",
+      "dex",
+      "djvu",
+      "dll",
+      "dmg",
+      "dng",
+      "doc",
+      "docm",
+      "docx",
+      "dot",
+      "dotm",
+      "dra",
+      "DS_Store",
+      "dsk",
+      "dts",
+      "dtshd",
+      "dvb",
+      "dwg",
+      "dxf",
+      "ecelp4800",
+      "ecelp7470",
+      "ecelp9600",
+      "egg",
+      "eol",
+      "eot",
+      "epub",
+      "exe",
+      "f4v",
+      "fbs",
+      "fh",
+      "fla",
+      "flac",
+      "flatpak",
+      "fli",
+      "flv",
+      "fpx",
+      "fst",
+      "fvt",
+      "g3",
+      "gh",
+      "gif",
+      "graffle",
+      "gz",
+      "gzip",
+      "h261",
+      "h263",
+      "h264",
+      "icns",
+      "ico",
+      "ief",
+      "img",
+      "ipa",
+      "iso",
+      "jar",
+      "jpeg",
+      "jpg",
+      "jpgv",
+      "jpm",
+      "jxr",
+      "key",
+      "ktx",
+      "lha",
+      "lib",
+      "lvp",
+      "lz",
+      "lzh",
+      "lzma",
+      "lzo",
+      "m3u",
+      "m4a",
+      "m4v",
+      "mar",
+      "mdi",
+      "mht",
+      "mid",
+      "midi",
+      "mj2",
+      "mka",
+      "mkv",
+      "mmr",
+      "mng",
+      "mobi",
+      "mov",
+      "movie",
+      "mp3",
+      "mp4",
+      "mp4a",
+      "mpeg",
+      "mpg",
+      "mpga",
+      "mxu",
+      "nef",
+      "npx",
+      "numbers",
+      "nupkg",
+      "o",
+      "odp",
+      "ods",
+      "odt",
+      "oga",
+      "ogg",
+      "ogv",
+      "otf",
+      "ott",
+      "pages",
+      "pbm",
+      "pcx",
+      "pdb",
+      "pdf",
+      "pea",
+      "pgm",
+      "pic",
+      "png",
+      "pnm",
+      "pot",
+      "potm",
+      "potx",
+      "ppa",
+      "ppam",
+      "ppm",
+      "pps",
+      "ppsm",
+      "ppsx",
+      "ppt",
+      "pptm",
+      "pptx",
+      "psd",
+      "pya",
+      "pyc",
+      "pyo",
+      "pyv",
+      "qt",
+      "rar",
+      "ras",
+      "raw",
+      "resources",
+      "rgb",
+      "rip",
+      "rlc",
+      "rmf",
+      "rmvb",
+      "rpm",
+      "rtf",
+      "rz",
+      "s3m",
+      "s7z",
+      "scpt",
+      "sgi",
+      "shar",
+      "snap",
+      "sil",
+      "sketch",
+      "slk",
+      "smv",
+      "snk",
+      "so",
+      "stl",
+      "suo",
+      "sub",
+      "swf",
+      "tar",
+      "tbz",
+      "tbz2",
+      "tga",
+      "tgz",
+      "thmx",
+      "tif",
+      "tiff",
+      "tlz",
+      "ttc",
+      "ttf",
+      "txz",
+      "udf",
+      "uvh",
+      "uvi",
+      "uvm",
+      "uvp",
+      "uvs",
+      "uvu",
+      "viv",
+      "vob",
+      "war",
+      "wav",
+      "wax",
+      "wbmp",
+      "wdp",
+      "weba",
+      "webm",
+      "webp",
+      "whl",
+      "wim",
+      "wm",
+      "wma",
+      "wmv",
+      "wmx",
+      "woff",
+      "woff2",
+      "wrm",
+      "wvx",
+      "xbm",
+      "xif",
+      "xla",
+      "xlam",
+      "xls",
+      "xlsb",
+      "xlsm",
+      "xlsx",
+      "xlt",
+      "xltm",
+      "xltx",
+      "xm",
+      "xmind",
+      "xpi",
+      "xpm",
+      "xwd",
+      "xz",
+      "z",
+      "zip",
+      "zipx"
+    ]);
+    isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+    foreach = (val, fn) => {
+      if (val instanceof Set) {
+        val.forEach(fn);
+      } else {
+        fn(val);
+      }
+    };
+    addAndConvert = (main, prop, item) => {
+      let container = main[prop];
+      if (!(container instanceof Set)) {
+        main[prop] = container = /* @__PURE__ */ new Set([container]);
+      }
+      container.add(item);
+    };
+    clearItem = (cont) => (key) => {
+      const set = cont[key];
+      if (set instanceof Set) {
+        set.clear();
+      } else {
+        delete cont[key];
+      }
+    };
+    delFromSet = (main, prop, item) => {
+      const container = main[prop];
+      if (container instanceof Set) {
+        container.delete(item);
+      } else if (container === item) {
+        delete main[prop];
+      }
+    };
+    isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+    FsWatchInstances = /* @__PURE__ */ new Map();
+    fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+      const cont = FsWatchInstances.get(fullPath);
+      if (!cont)
+        return;
+      foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+      });
+    };
+    setFsWatchListener = (path3, fullPath, options, handlers) => {
+      const { listener, errHandler, rawEmitter } = handlers;
+      let cont = FsWatchInstances.get(fullPath);
+      let watcher;
+      if (!options.persistent) {
+        watcher = createFsWatchInstance(path3, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+          return;
+        return watcher.close.bind(watcher);
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        watcher = createFsWatchInstance(
+          path3,
+          options,
+          fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+          errHandler,
+          // no need to use broadcast here
+          fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+        );
+        if (!watcher)
+          return;
+        watcher.on(EV.ERROR, async (error) => {
+          const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+          if (cont)
+            cont.watcherUnusable = true;
+          if (isWindows && error.code === "EPERM") {
+            try {
+              const fd = await (0, import_promises2.open)(path3, "r");
+              await fd.close();
+              broadcastErr(error);
+            } catch (err) {
+            }
+          } else {
+            broadcastErr(error);
+          }
+        });
+        cont = {
+          listeners: listener,
+          errHandlers: errHandler,
+          rawEmitters: rawEmitter,
+          watcher
+        };
+        FsWatchInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          cont.watcher.close();
+          FsWatchInstances.delete(fullPath);
+          HANDLER_KEYS.forEach(clearItem(cont));
+          cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    FsWatchFileInstances = /* @__PURE__ */ new Map();
+    setFsWatchFileListener = (path3, fullPath, options, handlers) => {
+      const { listener, rawEmitter } = handlers;
+      let cont = FsWatchFileInstances.get(fullPath);
+      const copts = cont && cont.options;
+      if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        (0, import_fs.unwatchFile)(fullPath);
+        cont = void 0;
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        cont = {
+          listeners: listener,
+          rawEmitters: rawEmitter,
+          options,
+          watcher: (0, import_fs.watchFile)(fullPath, options, (curr, prev) => {
+            foreach(cont.rawEmitters, (rawEmitter2) => {
+              rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+            });
+            const currmtime = curr.mtimeMs;
+            if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+              foreach(cont.listeners, (listener2) => listener2(path3, curr));
+            }
+          })
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          FsWatchFileInstances.delete(fullPath);
+          (0, import_fs.unwatchFile)(fullPath);
+          cont.options = cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    NodeFsHandler = class {
+      constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+      }
+      /**
+       * Watch file for changes with fs_watchFile or fs_watch.
+       * @param path to file or dir
+       * @param listener on fs change
+       * @returns closer for the watcher instance
+       */
+      _watchWithNodeFs(path3, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path3);
+        const basename4 = sysPath.basename(path3);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename4);
+        const absolutePath = sysPath.resolve(path3);
+        const options = {
+          persistent: opts.persistent
+        };
+        if (!listener)
+          listener = EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+          const enableBin = opts.interval !== opts.binaryInterval;
+          options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path3, absolutePath, options, {
+            listener,
+            rawEmitter: this.fsw._emitRaw
+          });
+        } else {
+          closer = setFsWatchListener(path3, absolutePath, options, {
+            listener,
+            errHandler: this._boundHandleError,
+            rawEmitter: this.fsw._emitRaw
+          });
+        }
+        return closer;
+      }
+      /**
+       * Watch a file and emit add event if warranted.
+       * @returns closer for the watcher instance
+       */
+      _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const dirname4 = sysPath.dirname(file);
+        const basename4 = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname4);
+        let prevStats = stats;
+        if (parent.has(basename4))
+          return;
+        const listener = async (path3, newStats) => {
+          if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+            return;
+          if (!newStats || newStats.mtimeMs === 0) {
+            try {
+              const newStats2 = await (0, import_promises2.stat)(file);
+              if (this.fsw.closed)
+                return;
+              const at = newStats2.atimeMs;
+              const mt = newStats2.mtimeMs;
+              if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                this.fsw._emit(EV.CHANGE, file, newStats2);
+              }
+              if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+                this.fsw._closeFile(path3);
+                prevStats = newStats2;
+                const closer2 = this._watchWithNodeFs(file, listener);
+                if (closer2)
+                  this.fsw._addPathCloser(path3, closer2);
+              } else {
+                prevStats = newStats2;
+              }
+            } catch (error) {
+              this.fsw._remove(dirname4, basename4);
+            }
+          } else if (parent.has(basename4)) {
+            const at = newStats.atimeMs;
+            const mt = newStats.mtimeMs;
+            if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+              this.fsw._emit(EV.CHANGE, file, newStats);
+            }
+            prevStats = newStats;
+          }
+        };
+        const closer = this._watchWithNodeFs(file, listener);
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+          if (!this.fsw._throttle(EV.ADD, file, 0))
+            return;
+          this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+      }
+      /**
+       * Handle symlinks encountered while reading a dir.
+       * @param entry returned by readdirp
+       * @param directory path of dir being read
+       * @param path of this item
+       * @param item basename of this item
+       * @returns true if no more processing is needed for this entry.
+       */
+      async _handleSymlink(entry, directory, path3, item) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+          this.fsw._incrReadyCount();
+          let linkPath;
+          try {
+            linkPath = await (0, import_promises2.realpath)(path3);
+          } catch (e) {
+            this.fsw._emitReady();
+            return true;
+          }
+          if (this.fsw.closed)
+            return;
+          if (dir.has(item)) {
+            if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+              this.fsw._symlinkPaths.set(full, linkPath);
+              this.fsw._emit(EV.CHANGE, path3, entry.stats);
+            }
+          } else {
+            dir.add(item);
+            this.fsw._symlinkPaths.set(full, linkPath);
+            this.fsw._emit(EV.ADD, path3, entry.stats);
+          }
+          this.fsw._emitReady();
+          return true;
+        }
+        if (this.fsw._symlinkPaths.has(full)) {
+          return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+      }
+      _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        directory = sysPath.join(directory, "");
+        throttler = this.fsw._throttle("readdir", directory, 1e3);
+        if (!throttler)
+          return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = /* @__PURE__ */ new Set();
+        let stream = this.fsw._readdirp(directory, {
+          fileFilter: (entry) => wh.filterPath(entry),
+          directoryFilter: (entry) => wh.filterDir(entry)
+        });
+        if (!stream)
+          return;
+        stream.on(STR_DATA, async (entry) => {
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          const item = entry.path;
+          let path3 = sysPath.join(directory, item);
+          current.add(item);
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path3, item)) {
+            return;
+          }
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          if (item === target || !target && !previous.has(item)) {
+            this.fsw._incrReadyCount();
+            path3 = sysPath.join(dir, sysPath.relative(dir, path3));
+            this._addToNodeFs(path3, initialAdd, wh, depth + 1);
+          }
+        }).on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve4, reject) => {
+          if (!stream)
+            return reject();
+          stream.once(STR_END, () => {
+            if (this.fsw.closed) {
+              stream = void 0;
+              return;
+            }
+            const wasThrottled = throttler ? throttler.clear() : false;
+            resolve4(void 0);
+            previous.getChildren().filter((item) => {
+              return item !== directory && !current.has(item);
+            }).forEach((item) => {
+              this.fsw._remove(directory, item);
+            });
+            stream = void 0;
+            if (wasThrottled)
+              this._handleRead(directory, false, wh, target, dir, depth, throttler);
+          });
+        });
+      }
+      /**
+       * Read directory to add / remove files from `@watched` list and re-read it on change.
+       * @param dir fs path
+       * @param stats
+       * @param initialAdd
+       * @param depth relative to user-supplied path
+       * @param target child path targeted for watch
+       * @param wh Common watch helpers for this path
+       * @param realpath
+       * @returns closer for the watcher instance.
+       */
+      async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+          this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+          if (!target) {
+            await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+            if (this.fsw.closed)
+              return;
+          }
+          closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+            if (stats2 && stats2.mtimeMs === 0)
+              return;
+            this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+          });
+        }
+        return closer;
+      }
+      /**
+       * Handle added file, directory, or glob pattern.
+       * Delegates call to _handleFile / _handleDir after checks.
+       * @param path to file or ir
+       * @param initialAdd was the file added at watch instantiation?
+       * @param priorWh depth relative to user-supplied path
+       * @param depth Child path actually targeted for watch
+       * @param target Child path actually targeted for watch
+       */
+      async _addToNodeFs(path3, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path3) || this.fsw.closed) {
+          ready();
+          return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path3);
+        if (priorWh) {
+          wh.filterPath = (entry) => priorWh.filterPath(entry);
+          wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        try {
+          const stats = await statMethods[wh.statMethod](wh.watchPath);
+          if (this.fsw.closed)
+            return;
+          if (this.fsw._isIgnored(wh.watchPath, stats)) {
+            ready();
+            return false;
+          }
+          const follow = this.fsw.options.followSymlinks;
+          let closer;
+          if (stats.isDirectory()) {
+            const absPath = sysPath.resolve(path3);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path3) : path3;
+            if (this.fsw.closed)
+              return;
+            closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (absPath !== targetPath && targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(absPath, targetPath);
+            }
+          } else if (stats.isSymbolicLink()) {
+            const targetPath = follow ? await (0, import_promises2.realpath)(path3) : path3;
+            if (this.fsw.closed)
+              return;
+            const parent = sysPath.dirname(wh.watchPath);
+            this.fsw._getWatchedDir(parent).add(wh.watchPath);
+            this.fsw._emit(EV.ADD, wh.watchPath, stats);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path3, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(sysPath.resolve(path3), targetPath);
+            }
+          } else {
+            closer = this._handleFile(wh.watchPath, stats, initialAdd);
+          }
+          ready();
+          if (closer)
+            this.fsw._addPathCloser(path3, closer);
+          return false;
+        } catch (error) {
+          if (this.fsw._handleError(error)) {
+            ready();
+            return path3;
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/chokidar/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  FSWatcher: () => FSWatcher,
+  WatchHelper: () => WatchHelper,
+  default: () => esm_default,
+  watch: () => watch
+});
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sysPath2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path3) {
+  if (typeof path3 !== "string")
+    throw new Error("string expected");
+  path3 = sysPath2.normalize(path3);
+  path3 = path3.replace(/\\/g, "/");
+  let prepend = false;
+  if (path3.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path3.match(DOUBLE_SLASH_RE2))
+    path3 = path3.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path3 = "/" + path3;
+  return path3;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path3 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path3, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var import_fs2, import_promises3, import_events, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher, esm_default;
+var init_esm2 = __esm({
+  "../../node_modules/chokidar/esm/index.js"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_promises3 = require("fs/promises");
+    import_events = require("events");
+    sysPath2 = __toESM(require("path"), 1);
+    init_esm();
+    init_handler();
+    SLASH = "/";
+    SLASH_SLASH = "//";
+    ONE_DOT = ".";
+    TWO_DOTS = "..";
+    STRING_TYPE = "string";
+    BACK_SLASH_RE = /\\/g;
+    DOUBLE_SLASH_RE = /\/\//;
+    DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+    REPLACER_RE = /^\.[/\\]/;
+    isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+    unifyPaths = (paths_) => {
+      const paths = arrify(paths_).flat();
+      if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+      }
+      return paths.map(normalizePathToUnix);
+    };
+    toUnix = (string) => {
+      let str = string.replace(BACK_SLASH_RE, SLASH);
+      let prepend = false;
+      if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+      }
+      while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+      }
+      if (prepend) {
+        str = SLASH + str;
+      }
+      return str;
+    };
+    normalizePathToUnix = (path3) => toUnix(sysPath2.normalize(toUnix(path3)));
+    normalizeIgnored = (cwd = "") => (path3) => {
+      if (typeof path3 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path3) ? path3 : sysPath2.join(cwd, path3));
+      } else {
+        return path3;
+      }
+    };
+    getAbsolutePath = (path3, cwd) => {
+      if (sysPath2.isAbsolute(path3)) {
+        return path3;
+      }
+      return sysPath2.join(cwd, path3);
+    };
+    EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+    DirEntry = class {
+      constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = /* @__PURE__ */ new Set();
+      }
+      add(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+          items.add(item);
+      }
+      async remove(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        items.delete(item);
+        if (items.size > 0)
+          return;
+        const dir = this.path;
+        try {
+          await (0, import_promises3.readdir)(dir);
+        } catch (err) {
+          if (this._removeWatcher) {
+            this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+          }
+        }
+      }
+      has(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        return items.has(item);
+      }
+      getChildren() {
+        const { items } = this;
+        if (!items)
+          return [];
+        return [...items.values()];
+      }
+      dispose() {
+        this.items.clear();
+        this.path = "";
+        this._removeWatcher = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+      }
+    };
+    STAT_METHOD_F = "stat";
+    STAT_METHOD_L = "lstat";
+    WatchHelper = class {
+      constructor(path3, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path3;
+        this.path = path3 = path3.replace(REPLACER_RE, "");
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath2.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+          if (parts.length > 1)
+            parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+      }
+      entryPath(entry) {
+        return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+      }
+      filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+          return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+      }
+      filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+      }
+    };
+    FSWatcher = class extends import_events.EventEmitter {
+      // Not indenting methods for history sake; for now.
+      constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = /* @__PURE__ */ new Map();
+        this._ignoredPaths = /* @__PURE__ */ new Set();
+        this._throttled = /* @__PURE__ */ new Map();
+        this._streams = /* @__PURE__ */ new Set();
+        this._symlinkPaths = /* @__PURE__ */ new Map();
+        this._watched = /* @__PURE__ */ new Map();
+        this._pendingWrites = /* @__PURE__ */ new Map();
+        this._pendingUnlinks = /* @__PURE__ */ new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+        const opts = {
+          // Defaults
+          persistent: true,
+          ignoreInitial: false,
+          ignorePermissionErrors: false,
+          interval: 100,
+          binaryInterval: 300,
+          followSymlinks: true,
+          usePolling: false,
+          // useAsync: false,
+          atomic: true,
+          // NOTE: overwritten later (depends on usePolling)
+          ..._opts,
+          // Change format
+          ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+          awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+        };
+        if (isIBMi)
+          opts.usePolling = true;
+        if (opts.atomic === void 0)
+          opts.atomic = !opts.usePolling;
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== void 0) {
+          const envLower = envPoll.toLowerCase();
+          if (envLower === "false" || envLower === "0")
+            opts.usePolling = false;
+          else if (envLower === "true" || envLower === "1")
+            opts.usePolling = true;
+          else
+            opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+          opts.interval = Number.parseInt(envInterval, 10);
+        let readyCalls = 0;
+        this._emitReady = () => {
+          readyCalls++;
+          if (readyCalls >= this._readyCount) {
+            this._emitReady = EMPTY_FN;
+            this._readyEmitted = true;
+            process.nextTick(() => this.emit(EVENTS.READY));
+          }
+        };
+        this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        Object.freeze(opts);
+      }
+      _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+              return;
+            }
+          }
+        }
+        this._ignoredPaths.add(matcher);
+      }
+      _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        if (typeof matcher === "string") {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher) {
+              this._ignoredPaths.delete(ignored);
+            }
+          }
+        }
+      }
+      // Public methods
+      /**
+       * Adds paths to be watched on an existing FSWatcher instance.
+       * @param paths_ file or file list. Other arguments are unused
+       */
+      add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = void 0;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+          paths = paths.map((path3) => {
+            const absPath = getAbsolutePath(path3, cwd);
+            return absPath;
+          });
+        }
+        paths.forEach((path3) => {
+          this._removeIgnoredPath(path3);
+        });
+        this._userIgnored = void 0;
+        if (!this._readyCount)
+          this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path3) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path3, !_internal, void 0, 0, _origAdd);
+          if (res)
+            this._emitReady();
+          return res;
+        })).then((results) => {
+          if (this.closed)
+            return;
+          results.forEach((item) => {
+            if (item)
+              this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+          });
+        });
+        return this;
+      }
+      /**
+       * Close watchers or start ignoring events from specified paths.
+       */
+      unwatch(paths_) {
+        if (this.closed)
+          return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path3) => {
+          if (!sysPath2.isAbsolute(path3) && !this._closers.has(path3)) {
+            if (cwd)
+              path3 = sysPath2.join(cwd, path3);
+            path3 = sysPath2.resolve(path3);
+          }
+          this._closePath(path3);
+          this._addIgnoredPath(path3);
+          if (this._watched.has(path3)) {
+            this._addIgnoredPath({
+              path: path3,
+              recursive: true
+            });
+          }
+          this._userIgnored = void 0;
+        });
+        return this;
+      }
+      /**
+       * Close watchers and remove all listeners from watched paths.
+       */
+      close() {
+        if (this._closePromise) {
+          return this._closePromise;
+        }
+        this.closed = true;
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+          const promise = closer();
+          if (promise instanceof Promise)
+            closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = void 0;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+        return this._closePromise;
+      }
+      /**
+       * Expose list of watched paths
+       * @returns for chaining
+       */
+      getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+          const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+          const index = key || ONE_DOT;
+          watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+      }
+      emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== EVENTS.ERROR)
+          this.emit(EVENTS.ALL, event, ...args);
+      }
+      // Common helpers
+      // --------------
+      /**
+       * Normalize and emit events.
+       * Calling _emit DOES NOT MEAN emit() would be called!
+       * @param event Type of event
+       * @param path File or directory path
+       * @param stats arguments to be passed with event
+       * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
+      async _emit(event, path3, stats) {
+        if (this.closed)
+          return;
+        const opts = this.options;
+        if (isWindows)
+          path3 = sysPath2.normalize(path3);
+        if (opts.cwd)
+          path3 = sysPath2.relative(opts.cwd, path3);
+        const args = [path3];
+        if (stats != null)
+          args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path3))) {
+          pw.lastChange = /* @__PURE__ */ new Date();
+          return this;
+        }
+        if (opts.atomic) {
+          if (event === EVENTS.UNLINK) {
+            this._pendingUnlinks.set(path3, [event, ...args]);
+            setTimeout(() => {
+              this._pendingUnlinks.forEach((entry, path4) => {
+                this.emit(...entry);
+                this.emit(EVENTS.ALL, ...entry);
+                this._pendingUnlinks.delete(path4);
+              });
+            }, typeof opts.atomic === "number" ? opts.atomic : 100);
+            return this;
+          }
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path3)) {
+            event = EVENTS.CHANGE;
+            this._pendingUnlinks.delete(path3);
+          }
+        }
+        if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+          const awfEmit = (err, stats2) => {
+            if (err) {
+              event = EVENTS.ERROR;
+              args[0] = err;
+              this.emitWithAll(event, args);
+            } else if (stats2) {
+              if (args.length > 1) {
+                args[1] = stats2;
+              } else {
+                args.push(stats2);
+              }
+              this.emitWithAll(event, args);
+            }
+          };
+          this._awaitWriteFinish(path3, awf.stabilityThreshold, event, awfEmit);
+          return this;
+        }
+        if (event === EVENTS.CHANGE) {
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path3, 50);
+          if (isThrottled)
+            return this;
+        }
+        if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path3) : path3;
+          let stats2;
+          try {
+            stats2 = await (0, import_promises3.stat)(fullPath);
+          } catch (err) {
+          }
+          if (!stats2 || this.closed)
+            return;
+          args.push(stats2);
+        }
+        this.emitWithAll(event, args);
+        return this;
+      }
+      /**
+       * Common handler for errors
+       * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
+      _handleError(error) {
+        const code = error && error.code;
+        if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+          this.emit(EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+      }
+      /**
+       * Helper utility for throttling
+       * @param actionType type being throttled
+       * @param path being acted upon
+       * @param timeout duration of time to suppress duplicate actions
+       * @returns tracking object or false if action should be suppressed
+       */
+      _throttle(actionType, path3, timeout) {
+        if (!this._throttled.has(actionType)) {
+          this._throttled.set(actionType, /* @__PURE__ */ new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+          throw new Error("invalid throttle");
+        const actionPath = action.get(path3);
+        if (actionPath) {
+          actionPath.count++;
+          return false;
+        }
+        let timeoutObject;
+        const clear = () => {
+          const item = action.get(path3);
+          const count = item ? item.count : 0;
+          action.delete(path3);
+          clearTimeout(timeoutObject);
+          if (item)
+            clearTimeout(item.timeoutObject);
+          return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path3, thr);
+        return thr;
+      }
+      _incrReadyCount() {
+        return this._readyCount++;
+      }
+      /**
+       * Awaits write operation to finish.
+       * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+       * @param path being acted upon
+       * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+       * @param event
+       * @param awfEmit Callback to be called when ready for event to be emitted.
+       */
+      _awaitWriteFinish(path3, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== "object")
+          return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path3;
+        if (this.options.cwd && !sysPath2.isAbsolute(path3)) {
+          fullPath = sysPath2.join(this.options.cwd, path3);
+        }
+        const now = /* @__PURE__ */ new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+          (0, import_fs2.stat)(fullPath, (err, curStat) => {
+            if (err || !writes.has(path3)) {
+              if (err && err.code !== "ENOENT")
+                awfEmit(err);
+              return;
+            }
+            const now2 = Number(/* @__PURE__ */ new Date());
+            if (prevStat && curStat.size !== prevStat.size) {
+              writes.get(path3).lastChange = now2;
+            }
+            const pw = writes.get(path3);
+            const df = now2 - pw.lastChange;
+            if (df >= threshold) {
+              writes.delete(path3);
+              awfEmit(void 0, curStat);
+            } else {
+              timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+            }
+          });
+        }
+        if (!writes.has(path3)) {
+          writes.set(path3, {
+            lastChange: now,
+            cancelWait: () => {
+              writes.delete(path3);
+              clearTimeout(timeoutHandler);
+              return event;
+            }
+          });
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+      }
+      /**
+       * Determines whether user has asked to ignore this path.
+       */
+      _isIgnored(path3, stats) {
+        if (this.options.atomic && DOT_RE.test(path3))
+          return true;
+        if (!this._userIgnored) {
+          const { cwd } = this.options;
+          const ign = this.options.ignored;
+          const ignored = (ign || []).map(normalizeIgnored(cwd));
+          const ignoredPaths = [...this._ignoredPaths];
+          const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+          this._userIgnored = anymatch(list, void 0);
+        }
+        return this._userIgnored(path3, stats);
+      }
+      _isntIgnored(path3, stat4) {
+        return !this._isIgnored(path3, stat4);
+      }
+      /**
+       * Provides a set of common helpers and properties relating to symlink handling.
+       * @param path file or directory pattern being watched
+       */
+      _getWatchHelpers(path3) {
+        return new WatchHelper(path3, this.options.followSymlinks, this);
+      }
+      // Directory helpers
+      // -----------------
+      /**
+       * Provides directory tracking objects
+       * @param directory path of the directory
+       */
+      _getWatchedDir(directory) {
+        const dir = sysPath2.resolve(directory);
+        if (!this._watched.has(dir))
+          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+      }
+      // File helpers
+      // ------------
+      /**
+       * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+       */
+      _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+          return true;
+        return Boolean(Number(stats.mode) & 256);
+      }
+      /**
+       * Handles emitting unlink events for
+       * files and directories, and via recursion, for
+       * files and directories within directories that are unlinked
+       * @param directory within which the following item is located
+       * @param item      base path of item/directory
+       */
+      _remove(directory, item, isDirectory) {
+        const path3 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path3);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path3) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path3, 100))
+          return;
+        if (!isDirectory && this._watched.size === 1) {
+          this.add(directory, item, true);
+        }
+        const wp = this._getWatchedDir(path3);
+        const nestedDirectoryChildren = wp.getChildren();
+        nestedDirectoryChildren.forEach((nested) => this._remove(path3, nested));
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        if (this._symlinkPaths.has(fullPath)) {
+          this._symlinkPaths.delete(fullPath);
+        }
+        let relPath = path3;
+        if (this.options.cwd)
+          relPath = sysPath2.relative(this.options.cwd, path3);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+          const event = this._pendingWrites.get(relPath).cancelWait();
+          if (event === EVENTS.ADD)
+            return;
+        }
+        this._watched.delete(path3);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path3))
+          this._emit(eventName, path3);
+        this._closePath(path3);
+      }
+      /**
+       * Closes all watchers for a path
+       */
+      _closePath(path3) {
+        this._closeFile(path3);
+        const dir = sysPath2.dirname(path3);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path3));
+      }
+      /**
+       * Closes only file-specific watchers
+       */
+      _closeFile(path3) {
+        const closers = this._closers.get(path3);
+        if (!closers)
+          return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path3);
+      }
+      _addPathCloser(path3, closer) {
+        if (!closer)
+          return;
+        let list = this._closers.get(path3);
+        if (!list) {
+          list = [];
+          this._closers.set(path3, list);
+        }
+        list.push(closer);
+      }
+      _readdirp(root, opts) {
+        if (this.closed)
+          return;
+        const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+          stream = void 0;
+        });
+        stream.once(STR_END, () => {
+          if (stream) {
+            this._streams.delete(stream);
+            stream = void 0;
+          }
+        });
+        return stream;
+      }
+    };
+    esm_default = { watch, FSWatcher };
+  }
+});
+
+// src/cli/index.ts
+var fs3 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_commander = require("commander");
+
+// src/generator.ts
+var fs2 = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// src/parser.ts
+var fs = __toESM(require("fs"), 1);
+function isDesignToken(obj) {
+  return typeof obj === "object" && obj !== null && "$value" in obj && obj.$value !== void 0;
+}
+function isTokenGroup(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  if (isDesignToken(obj)) {
+    return false;
+  }
+  return Object.keys(obj).some((key) => !key.startsWith("$"));
+}
+function isReference(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return /^\{[\w.]+\}$/.test(value);
+}
+function extractReferencePath(ref) {
+  const match = ref.match(/^\{([\w.]+)\}$/);
+  if (!match) {
+    throw new Error(`Invalid reference: ${ref}`);
+  }
+  return match[1].split(".");
+}
+function pathToCssVariable(path3, prefix = "nice") {
+  return `--${prefix}-${path3.join("-")}`;
+}
+function pathToString(path3) {
+  return path3.join(".");
+}
+function parseTokenFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(content);
+  return parsed;
+}
+function parseTokenFiles(filePaths) {
+  const merged = {};
+  for (const filePath of filePaths) {
+    const tokens = parseTokenFile(filePath);
+    mergeTokenFiles(merged, tokens);
+  }
+  return merged;
+}
+function mergeTokenFiles(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (key.startsWith("$")) {
+      if (!(key in target)) {
+        target[key] = value;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (!(key in target)) {
+        target[key] = {};
+      }
+      const targetValue = target[key];
+      if (typeof targetValue === "object" && targetValue !== null) {
+        mergeTokenFiles(targetValue, value);
+      }
+    } else {
+      target[key] = value;
+    }
+  }
+}
+function flattenTokens(tokenFile, prefix = [], inheritedType) {
+  const tokens = [];
+  const currentType = tokenFile.$type ?? inheritedType;
+  for (const [key, value] of Object.entries(tokenFile)) {
+    if (key.startsWith("$")) {
+      continue;
+    }
+    const currentPath = [...prefix, key];
+    if (isDesignToken(value)) {
+      const token = value;
+      const tokenType = token.$type ?? currentType;
+      const references = [];
+      findReferences(token.$value, references);
+      tokens.push({
+        path: currentPath,
+        name: key,
+        value: token.$value,
+        resolvedValue: "",
+        // Will be populated by resolver
+        type: tokenType,
+        description: token.$description,
+        cssVariable: pathToCssVariable(currentPath),
+        references: references.length > 0 ? references : void 0
+      });
+    } else if (isTokenGroup(value)) {
+      const group = value;
+      const groupType = group.$type ?? currentType;
+      tokens.push(...flattenTokens(group, currentPath, groupType));
+    }
+  }
+  return tokens;
+}
+function findReferences(value, refs) {
+  if (typeof value === "string" && isReference(value)) {
+    refs.push(extractReferencePath(value).join("."));
+  } else if (typeof value === "object" && value !== null) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        findReferences(item, refs);
+      }
+    } else {
+      for (const v of Object.values(value)) {
+        findReferences(v, refs);
+      }
+    }
+  }
+}
+function createTokenCollection(tokens) {
+  const byPath = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const pathStr = pathToString(token.path);
+    byPath.set(pathStr, token);
+    const existing = byName.get(token.name);
+    if (!existing || token.path.length > existing.path.length) {
+      byName.set(token.name, token);
+    }
+  }
+  return { tokens, byPath, byName };
+}
+function getCategories(collection) {
+  const categories = /* @__PURE__ */ new Set();
+  for (const token of collection.tokens) {
+    if (token.path.length > 0) {
+      categories.add(token.path[0]);
+    }
+  }
+  return Array.from(categories);
+}
+
+// src/resolver.ts
+var MAX_RESOLUTION_DEPTH = 10;
+function resolveTokens(collection) {
+  const resolvedTokens = collection.tokens.map((token) => {
+    const resolved = { ...token };
+    resolved.resolvedValue = resolveTokenValue(token.value, collection, 0);
+    return resolved;
+  });
+  return {
+    tokens: resolvedTokens,
+    byPath: new Map(resolvedTokens.map((t) => [pathToString(t.path), t])),
+    byName: new Map(resolvedTokens.map((t) => [t.name, t]))
+  };
+}
+function resolveTokenValue(value, collection, depth) {
+  if (depth > MAX_RESOLUTION_DEPTH) {
+    throw new Error(`Maximum reference depth exceeded while resolving token`);
+  }
+  if (typeof value === "string") {
+    if (isReference(value)) {
+      const refPath = extractReferencePath(value);
+      const refPathStr = pathToString(refPath);
+      const refToken = collection.byPath.get(refPathStr);
+      if (!refToken) {
+        console.warn(`Reference not found: ${value}`);
+        return value;
+      }
+      return resolveTokenValue(refToken.value, collection, depth + 1);
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => {
+      if (typeof v === "string") {
+        return v.includes(" ") ? `"${v}"` : v;
+      }
+      return String(v);
+    }).join(", ");
+  }
+  if (isShadowValue(value)) {
+    return resolveShadowValue(value, collection, depth);
+  }
+  if (Array.isArray(value) && value.length > 0 && isShadowValue(value[0])) {
+    return value.map((s) => resolveShadowValue(s, collection, depth)).join(", ");
+  }
+  if (isTypographyValue(value)) {
+    return resolveTypographyValue(value, collection, depth);
+  }
+  if (isBorderValue(value)) {
+    return resolveBorderValue(value, collection, depth);
+  }
+  return JSON.stringify(value);
+}
+function isShadowValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "offsetX" in value && "offsetY" in value && "blur" in value;
+}
+function resolveShadowValue(shadow, collection, depth) {
+  const offsetX = resolveTokenValue(shadow.offsetX, collection, depth);
+  const offsetY = resolveTokenValue(shadow.offsetY, collection, depth);
+  const blur = resolveTokenValue(shadow.blur, collection, depth);
+  const spread = resolveTokenValue(shadow.spread, collection, depth);
+  const color = resolveTokenValue(shadow.color, collection, depth);
+  const inset = shadow.inset ? "inset " : "";
+  return `${inset}${offsetX} ${offsetY} ${blur} ${spread} ${color}`;
+}
+function isTypographyValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "fontFamily" in value && "fontSize" in value;
+}
+function resolveTypographyValue(typography, collection, depth) {
+  const fontFamily = resolveTokenValue(typography.fontFamily, collection, depth);
+  const fontSize = resolveTokenValue(typography.fontSize, collection, depth);
+  const fontWeight = resolveTokenValue(typography.fontWeight, collection, depth);
+  const lineHeight = typography.lineHeight ? resolveTokenValue(typography.lineHeight, collection, depth) : "normal";
+  const fontStyle = typography.fontStyle || "normal";
+  return `${fontStyle} ${fontWeight} ${fontSize}/${lineHeight} ${fontFamily}`;
+}
+function isBorderValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "color" in value && "width" in value && "style" in value;
+}
+function resolveBorderValue(border, collection, depth) {
+  const width = resolveTokenValue(border.width, collection, depth);
+  const style = resolveTokenValue(border.style, collection, depth);
+  const color = resolveTokenValue(border.color, collection, depth);
+  return `${width} ${style} ${color}`;
+}
+
+// src/transforms.ts
+function transformToCss(collection, prefix = "nice") {
+  const lines = [];
+  for (const token of collection.tokens) {
+    const varName = `--${prefix}-${token.path.join("-")}`;
+    lines.push(`  ${varName}: ${token.resolvedValue};`);
+  }
+  return `:root {
+${lines.join("\n")}
+}`;
+}
+function transformToScss(collection, prefix = "nice") {
+  const lines = [];
+  for (const token of collection.tokens) {
+    const varName = `$${prefix}-${token.path.join("-")}`;
+    lines.push(`${varName}: ${token.resolvedValue};`);
+  }
+  return lines.join("\n");
+}
+function transformToJs(collection, variableName = "tokens") {
+  const obj = buildTokenObject(collection);
+  return `export const ${variableName} = ${JSON.stringify(obj, null, 2)};`;
+}
+function transformToTs(collection, variableName = "tokens") {
+  const obj = buildTokenObject(collection);
+  const types = generateTokenTypes(collection);
+  return `${types}
+
+export const ${variableName}: Tokens = ${JSON.stringify(obj, null, 2)};`;
+}
+function buildTokenObject(collection) {
+  const result = {};
+  for (const token of collection.tokens) {
+    let current = result;
+    for (let i = 0; i < token.path.length - 1; i++) {
+      const key = token.path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = token.path[token.path.length - 1];
+    current[lastKey] = token.resolvedValue;
+  }
+  return result;
+}
+function generateTokenTypes(collection) {
+  const typeObj = buildTypeStructure(collection);
+  return `interface Tokens ${formatTypeStructure(typeObj)}`;
+}
+function buildTypeStructure(collection) {
+  const result = {};
+  for (const token of collection.tokens) {
+    let current = result;
+    for (let i = 0; i < token.path.length - 1; i++) {
+      const key = token.path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = token.path[token.path.length - 1];
+    current[lastKey] = "string";
+  }
+  return result;
+}
+function formatTypeStructure(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = ["{"];
+  for (const [key, value] of Object.entries(obj)) {
+    const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+    if (typeof value === "string") {
+      lines.push(`${spaces}  ${safeKey}: ${value};`);
+    } else {
+      lines.push(
+        `${spaces}  ${safeKey}: ${formatTypeStructure(value, indent + 1)};`
+      );
+    }
+  }
+  lines.push(`${spaces}}`);
+  return lines.join("\n");
+}
+function transformToTailwind(collection) {
+  const colors = {};
+  const spacing = {};
+  const fontSize = {};
+  const fontFamily = {};
+  const borderRadius = {};
+  const boxShadow = {};
+  for (const token of collection.tokens) {
+    const path3 = token.path;
+    const value = token.resolvedValue;
+    if (path3[0] === "color" || path3[0] === "colors") {
+      setNestedValue(colors, path3.slice(1), value);
+    } else if (path3[0] === "spacing") {
+      spacing[path3.slice(1).join("-")] = value;
+    } else if (path3[0] === "typography" && path3[1] === "fontSize") {
+      fontSize[path3[2]] = value;
+    } else if (path3[0] === "typography" && path3[1] === "fontFamily") {
+      fontFamily[path3[2]] = value.split(",").map((f) => f.trim());
+    } else if (path3[0] === "effects" && path3[1] === "radius") {
+      borderRadius[path3[2]] = value;
+    } else if (path3[0] === "effects" && path3[1] === "shadow") {
+      boxShadow[path3[2]] = value;
+    }
+  }
+  const config = {
+    theme: {
+      extend: {
+        colors,
+        spacing,
+        fontSize,
+        fontFamily,
+        borderRadius,
+        boxShadow
+      }
+    }
+  };
+  return `module.exports = ${JSON.stringify(config, null, 2)};`;
+}
+function setNestedValue(obj, path3, value) {
+  let current = obj;
+  for (let i = 0; i < path3.length - 1; i++) {
+    const key = path3[i];
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[path3[path3.length - 1]] = value;
+}
+function applyThemeOverrides(baseCollection, overrides) {
+  const mergedTokens = [...baseCollection.tokens];
+  for (const override of overrides.tokens) {
+    const pathStr = pathToString(override.path);
+    const existingIndex = mergedTokens.findIndex((t) => pathToString(t.path) === pathStr);
+    if (existingIndex >= 0) {
+      mergedTokens[existingIndex] = { ...mergedTokens[existingIndex], ...override };
+    } else {
+      mergedTokens.push(override);
+    }
+  }
+  return {
+    tokens: mergedTokens,
+    byPath: new Map(mergedTokens.map((t) => [pathToString(t.path), t])),
+    byName: new Map(mergedTokens.map((t) => [t.name, t]))
+  };
+}
+
+// src/themes.ts
+var defaultThemes = {
+  light: {
+    name: "light",
+    displayName: "Light",
+    mode: "light",
+    selector: ':root, [data-theme="light"]'
+  },
+  dark: {
+    name: "dark",
+    displayName: "Dark",
+    mode: "dark",
+    selector: '[data-theme="dark"]',
+    mediaQuery: "(prefers-color-scheme: dark)",
+    extends: "light"
+  },
+  "high-contrast": {
+    name: "high-contrast",
+    displayName: "High Contrast",
+    mode: "high-contrast",
+    selector: '[data-theme="high-contrast"]',
+    mediaQuery: "(prefers-contrast: more)",
+    extends: "light"
+  },
+  "high-contrast-dark": {
+    name: "high-contrast-dark",
+    displayName: "High Contrast Dark",
+    mode: "high-contrast-dark",
+    selector: '[data-theme="high-contrast-dark"]',
+    extends: "dark"
+  },
+  dim: {
+    name: "dim",
+    displayName: "Dim",
+    mode: "dim",
+    selector: '[data-theme="dim"]',
+    extends: "dark"
+  }
+};
+function createTheme(name, baseTokens, overrideTokens, config) {
+  const tokens = overrideTokens ? applyThemeOverrides(baseTokens, overrideTokens) : baseTokens;
+  const resolvedTokens = resolveTokens(tokens);
+  const themeConfig = { ...defaultThemes.light, ...config, name };
+  return {
+    name,
+    tokens: resolvedTokens,
+    extends: themeConfig.extends,
+    selector: themeConfig.selector,
+    mediaQuery: themeConfig.mediaQuery
+  };
+}
+function generateThemesCss(themes, prefix = "nice") {
+  const sections = [];
+  for (const theme of themes) {
+    const vars = generateThemeVariables(theme, prefix);
+    sections.push(`${theme.selector} {
+${vars}
+}`);
+    if (theme.mediaQuery) {
+      sections.push(
+        `@media ${theme.mediaQuery} {
+  :root {
+${vars.split("\n").map((l) => `  ${l}`).join("\n")}
+  }
+}`
+      );
+    }
+  }
+  return sections.join("\n\n");
+}
+function generateThemeVariables(theme, prefix) {
+  const lines = [];
+  for (const token of theme.tokens.tokens) {
+    const varName = `--${prefix}-${token.path.join("-")}`;
+    lines.push(`  ${varName}: ${token.resolvedValue};`);
+  }
+  return lines.join("\n");
+}
+function generateThemeSwitcher() {
+  return `
+/**
+ * Nice2Dev Theme Switcher
+ * Auto-generated by @nice2dev/design-tokens
+ */
+
+const THEME_KEY = 'nice-theme';
+const THEMES = ['light', 'dark', 'high-contrast', 'high-contrast-dark', 'dim'];
+
+/**
+ * Get current theme
+ */
+function getTheme() {
+  return document.documentElement.getAttribute('data-theme') || 'light';
+}
+
+/**
+ * Set theme
+ */
+function setTheme(theme) {
+  if (!THEMES.includes(theme)) {
+    console.warn(\`Invalid theme: \${theme}\`);
+    return;
+  }
+  
+  document.documentElement.setAttribute('data-theme', theme);
+  localStorage.setItem(THEME_KEY, theme);
+  
+  // Dispatch event
+  window.dispatchEvent(new CustomEvent('nice-theme-change', { detail: { theme } }));
+}
+
+/**
+ * Toggle between light and dark
+ */
+function toggleTheme() {
+  const current = getTheme();
+  const next = current === 'dark' ? 'light' : 'dark';
+  setTheme(next);
+  return next;
+}
+
+/**
+ * Use system preference
+ */
+function useSystemTheme() {
+  const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+  const prefersHighContrast = window.matchMedia('(prefers-contrast: more)').matches;
+  
+  let theme = 'light';
+  if (prefersDark && prefersHighContrast) {
+    theme = 'high-contrast-dark';
+  } else if (prefersDark) {
+    theme = 'dark';
+  } else if (prefersHighContrast) {
+    theme = 'high-contrast';
+  }
+  
+  setTheme(theme);
+  return theme;
+}
+
+/**
+ * Initialize theme on page load
+ */
+function initTheme() {
+  const saved = localStorage.getItem(THEME_KEY);
+  
+  if (saved && THEMES.includes(saved)) {
+    setTheme(saved);
+  } else {
+    useSystemTheme();
+  }
+  
+  // Listen for system changes
+  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
+    if (!localStorage.getItem(THEME_KEY)) {
+      useSystemTheme();
+    }
+  });
+}
+
+// Auto-init
+if (typeof document !== 'undefined') {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initTheme);
+  } else {
+    initTheme();
+  }
+}
+
+export { getTheme, setTheme, toggleTheme, useSystemTheme, initTheme, THEMES };
+`.trim();
+}
+function generateReactThemeContext() {
+  return `
+'use client';
+
+import React, { createContext, useContext, useEffect, useState, useCallback } from 'react';
+
+type Theme = 'light' | 'dark' | 'high-contrast' | 'high-contrast-dark' | 'dim';
+
+interface ThemeContextValue {
+  theme: Theme;
+  setTheme: (theme: Theme) => void;
+  toggleTheme: () => void;
+  useSystemTheme: () => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | undefined>(undefined);
+
+const THEME_KEY = 'nice-theme';
+const THEMES: Theme[] = ['light', 'dark', 'high-contrast', 'high-contrast-dark', 'dim'];
+
+interface ThemeProviderProps {
+  children: React.ReactNode;
+  defaultTheme?: Theme;
+}
+
+export function ThemeProvider({ children, defaultTheme = 'light' }: ThemeProviderProps) {
+  const [theme, setThemeState] = useState<Theme>(defaultTheme);
+
+  useEffect(() => {
+    const saved = localStorage.getItem(THEME_KEY) as Theme | null;
+    if (saved && THEMES.includes(saved)) {
+      setThemeState(saved);
+      document.documentElement.setAttribute('data-theme', saved);
+    } else {
+      const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+      const initial = prefersDark ? 'dark' : 'light';
+      setThemeState(initial);
+      document.documentElement.setAttribute('data-theme', initial);
+    }
+  }, []);
+
+  const setTheme = useCallback((newTheme: Theme) => {
+    setThemeState(newTheme);
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem(THEME_KEY, newTheme);
+  }, []);
+
+  const toggleTheme = useCallback(() => {
+    setTheme(theme === 'dark' ? 'light' : 'dark');
+  }, [theme, setTheme]);
+
+  const useSystemTheme = useCallback(() => {
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const prefersHighContrast = window.matchMedia('(prefers-contrast: more)').matches;
+    
+    let systemTheme: Theme = 'light';
+    if (prefersDark && prefersHighContrast) {
+      systemTheme = 'high-contrast-dark';
+    } else if (prefersDark) {
+      systemTheme = 'dark';
+    } else if (prefersHighContrast) {
+      systemTheme = 'high-contrast';
+    }
+    
+    setTheme(systemTheme);
+    localStorage.removeItem(THEME_KEY);
+  }, [setTheme]);
+
+  return (
+    <ThemeContext.Provider value={{ theme, setTheme, toggleTheme, useSystemTheme }}>
+      {children}
+    </ThemeContext.Provider>
+  );
+}
+
+export function useTheme(): ThemeContextValue {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    throw new Error('useTheme must be used within a ThemeProvider');
+  }
+  return context;
+}
+
+export { THEMES };
+export type { Theme };
+`.trim();
+}
+
+// src/generator.ts
+var defaultOptions = {
+  formats: ["css"],
+  outputDir: "./dist",
+  prefix: "nice",
+  includePrimitives: true,
+  separateFiles: false,
+  includeDarkMode: true,
+  includeComponents: true
+};
+var TokenGenerator = class {
+  constructor(options = {}) {
+    this.plugins = [];
+    this.collection = null;
+    this.themes = [];
+    this.options = { ...defaultOptions, ...options };
+  }
+  /**
+   * Add plugin
+   */
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  /**
+   * Load tokens from files
+   */
+  load(files) {
+    const tokenFile = parseTokenFiles(files);
+    let processedTokens = [tokenFile];
+    for (const plugin of this.plugins) {
+      if (plugin.beforeResolve) {
+        processedTokens = plugin.beforeResolve(processedTokens);
+      }
+    }
+    const flatTokens = flattenTokens(processedTokens[0]);
+    let collection = createTokenCollection(flatTokens);
+    collection = resolveTokens(collection);
+    for (const plugin of this.plugins) {
+      if (plugin.afterResolve) {
+        collection = plugin.afterResolve(collection);
+      }
+    }
+    this.collection = collection;
+    return this;
+  }
+  /**
+   * Load tokens from directory
+   */
+  loadDirectory(dir, pattern = "**/*.json") {
+    const glob = require("fast-glob");
+    const files = glob.sync(path.join(dir, pattern));
+    return this.load(files);
+  }
+  /**
+   * Add theme
+   */
+  addTheme(name, overrideTokens) {
+    if (!this.collection) {
+      throw new Error("Load tokens first before adding themes");
+    }
+    const theme = createTheme(name, this.collection, overrideTokens);
+    this.themes.push(theme);
+    return this;
+  }
+  /**
+   * Generate output files
+   */
+  async generate() {
+    if (!this.collection) {
+      throw new Error("No tokens loaded");
+    }
+    fs2.mkdirSync(this.options.outputDir, { recursive: true });
+    for (const format of this.options.formats) {
+      await this.generateFormat(format);
+    }
+    if (this.themes.length > 0) {
+      await this.generateThemeFiles();
+    }
+  }
+  /**
+   * Generate single format
+   */
+  async generateFormat(format) {
+    if (!this.collection) {
+      return;
+    }
+    for (const plugin of this.plugins) {
+      if (plugin.customFormat) {
+        const output = plugin.customFormat(this.collection, this.options);
+        if (output) {
+          const ext = this.getExtension(format);
+          fs2.writeFileSync(
+            path.join(this.options.outputDir, `tokens.${plugin.name}.${ext}`),
+            output
+          );
+        }
+      }
+    }
+    if (this.options.separateFiles) {
+      await this.generateSeparateFiles(format);
+    } else {
+      await this.generateSingleFile(format);
+    }
+  }
+  /**
+   * Generate single output file
+   */
+  async generateSingleFile(format) {
+    if (!this.collection) {
+      return;
+    }
+    const content = this.transform(this.collection, format);
+    const filename = `tokens.${this.getExtension(format)}`;
+    const filepath = path.join(this.options.outputDir, filename);
+    fs2.writeFileSync(filepath, content);
+    console.log(`Generated: ${filepath}`);
+  }
+  /**
+   * Generate separate files by category
+   */
+  async generateSeparateFiles(format) {
+    if (!this.collection) {
+      return;
+    }
+    const categories = getCategories(this.collection);
+    const ext = this.getExtension(format);
+    for (const category of categories) {
+      const tokens = this.collection.tokens.filter((t) => t.path[0] === category);
+      const catCollection = {
+        tokens,
+        byPath: new Map(tokens.map((t) => [t.path.join("."), t])),
+        byName: new Map(tokens.map((t) => [t.name, t]))
+      };
+      const content = this.transform(catCollection, format);
+      const filename = `${category}.${ext}`;
+      const filepath = path.join(this.options.outputDir, filename);
+      fs2.writeFileSync(filepath, content);
+      console.log(`Generated: ${filepath}`);
+    }
+    this.generateIndexFile(categories, format);
+  }
+  /**
+   * Generate index file for separated files
+   */
+  generateIndexFile(categories, format) {
+    const ext = this.getExtension(format);
+    let content = "";
+    switch (format) {
+      case "css":
+        content = categories.map((c) => `@import './${c}.css';`).join("\n");
+        break;
+      case "scss":
+        content = categories.map((c) => `@import './${c}';`).join("\n");
+        break;
+      case "js":
+      case "ts":
+        content = categories.map((c) => `export * from './${c}';`).join("\n");
+        break;
+      default:
+        return;
+    }
+    const filepath = path.join(this.options.outputDir, `index.${ext}`);
+    fs2.writeFileSync(filepath, content);
+    console.log(`Generated: ${filepath}`);
+  }
+  /**
+   * Transform collection to format
+   */
+  transform(collection, format) {
+    const prefix = this.options.prefix ?? "nice";
+    switch (format) {
+      case "css":
+        return transformToCss(collection, prefix);
+      case "scss":
+        return transformToScss(collection, prefix);
+      case "js":
+        return transformToJs(collection);
+      case "ts":
+        return transformToTs(collection);
+      case "json":
+        return JSON.stringify(this.buildNestedObject(collection), null, 2);
+      case "tailwind":
+        return transformToTailwind(collection);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Build nested object from flat tokens
+   */
+  buildNestedObject(collection) {
+    const result = {};
+    for (const token of collection.tokens) {
+      let current = result;
+      for (let i = 0; i < token.path.length - 1; i++) {
+        const key = token.path[i];
+        if (!(key in current)) {
+          current[key] = {};
+        }
+        current = current[key];
+      }
+      current[token.path[token.path.length - 1]] = token.resolvedValue;
+    }
+    return result;
+  }
+  /**
+   * Get file extension for format
+   */
+  getExtension(format) {
+    switch (format) {
+      case "css":
+        return "css";
+      case "scss":
+        return "scss";
+      case "js":
+        return "js";
+      case "ts":
+        return "ts";
+      case "json":
+        return "json";
+      case "tailwind":
+        return "tailwind.js";
+      default:
+        return "txt";
+    }
+  }
+  /**
+   * Generate theme-related files
+   */
+  async generateThemeFiles() {
+    const prefix = this.options.prefix ?? "nice";
+    const themesCss = generateThemesCss(this.themes, prefix);
+    fs2.writeFileSync(path.join(this.options.outputDir, "themes.css"), themesCss);
+    console.log(`Generated: themes.css`);
+    const switcherJs = generateThemeSwitcher();
+    fs2.writeFileSync(path.join(this.options.outputDir, "theme-switcher.js"), switcherJs);
+    console.log(`Generated: theme-switcher.js`);
+    const reactContext = generateReactThemeContext();
+    fs2.writeFileSync(path.join(this.options.outputDir, "ThemeContext.tsx"), reactContext);
+    console.log(`Generated: ThemeContext.tsx`);
+  }
+  /**
+   * Get generated token collection
+   */
+  getCollection() {
+    return this.collection;
+  }
+  /**
+   * Get generated themes
+   */
+  getThemes() {
+    return this.themes;
+  }
+};
+function createGenerator(options) {
+  return new TokenGenerator(options);
+}
+
+// src/cli/index.ts
+var pkg = require_package();
+var program = new import_commander.Command();
+program.name("nice-tokens").description("Generate design tokens in various formats").version(pkg.version);
+program.command("build").description("Build design tokens from JSON source files").option("-i, --input <dir>", "Input directory containing token JSON files", "./tokens").option("-o, --output <dir>", "Output directory for generated files", "./dist").option(
+  "-f, --formats <formats>",
+  "Output formats (comma-separated: css,scss,js,ts,json,tailwind)",
+  "css"
+).option("-p, --prefix <prefix>", "CSS variable prefix", "nice").option("--separate", "Generate separate files by category").option("--no-dark", "Exclude dark mode tokens").option("--no-components", "Exclude component tokens").option("--watch", "Watch for changes and rebuild").action(async (options) => {
+  const formats = options.formats.split(",").map((f) => f.trim());
+  console.log("\u{1F3A8} Nice2Dev Design Tokens Generator\n");
+  console.log(`\u{1F4C1} Input:  ${path2.resolve(options.input)}`);
+  console.log(`\u{1F4C1} Output: ${path2.resolve(options.output)}`);
+  console.log(`\u{1F4C4} Formats: ${formats.join(", ")}`);
+  console.log("");
+  try {
+    const generator = createGenerator({
+      outputDir: options.output,
+      formats,
+      prefix: options.prefix,
+      separateFiles: options.separate,
+      includeDarkMode: options.dark !== false,
+      includeComponents: options.components !== false
+    });
+    generator.loadDirectory(options.input);
+    await generator.generate();
+    console.log("\n\u2705 Build complete!");
+    if (options.watch) {
+      console.log("\n\u{1F440} Watching for changes...");
+      const chokidar = await Promise.resolve().then(() => (init_esm2(), esm_exports));
+      const watcher = chokidar.watch(path2.join(options.input, "**/*.json"), {
+        ignoreInitial: true
+      });
+      watcher.on("change", async (file) => {
+        console.log(`
+\u{1F504} File changed: ${path2.basename(file)}`);
+        try {
+          const gen = createGenerator({
+            outputDir: options.output,
+            formats,
+            prefix: options.prefix,
+            separateFiles: options.separate,
+            includeDarkMode: options.dark !== false,
+            includeComponents: options.components !== false
+          });
+          gen.loadDirectory(options.input);
+          await gen.generate();
+          console.log("\u2705 Rebuild complete!");
+        } catch (err) {
+          console.error("\u274C Rebuild failed:", err.message);
+        }
+      });
+    }
+  } catch (err) {
+    console.error("\u274C Build failed:", err.message);
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize a new design tokens project").option("-d, --dir <dir>", "Directory to initialize", ".").action(async (options) => {
+  const dir = path2.resolve(options.dir);
+  const tokensDir = path2.join(dir, "tokens");
+  console.log("\u{1F3A8} Initializing Nice2Dev Design Tokens\n");
+  fs3.mkdirSync(tokensDir, { recursive: true });
+  fs3.mkdirSync(path2.join(dir, "dist"), { recursive: true });
+  const colorsJson = {
+    color: {
+      $type: "color",
+      primary: {
+        "50": { $value: "#eff6ff" },
+        "100": { $value: "#dbeafe" },
+        "500": { $value: "#3b82f6" },
+        "600": { $value: "#2563eb" },
+        "700": { $value: "#1d4ed8" },
+        "900": { $value: "#1e3a8a" }
+      },
+      gray: {
+        "50": { $value: "#f9fafb" },
+        "100": { $value: "#f3f4f6" },
+        "500": { $value: "#6b7280" },
+        "700": { $value: "#374151" },
+        "900": { $value: "#111827" }
+      }
+    }
+  };
+  fs3.writeFileSync(path2.join(tokensDir, "colors.json"), JSON.stringify(colorsJson, null, 2));
+  const typographyJson = {
+    typography: {
+      fontFamily: {
+        $type: "fontFamily",
+        sans: { $value: ["Inter", "system-ui", "sans-serif"] },
+        mono: { $value: ["JetBrains Mono", "monospace"] }
+      },
+      fontSize: {
+        $type: "dimension",
+        xs: { $value: "0.75rem" },
+        sm: { $value: "0.875rem" },
+        base: { $value: "1rem" },
+        lg: { $value: "1.125rem" },
+        xl: { $value: "1.25rem" }
+      }
+    }
+  };
+  fs3.writeFileSync(
+    path2.join(tokensDir, "typography.json"),
+    JSON.stringify(typographyJson, null, 2)
+  );
+  const spacingJson = {
+    spacing: {
+      $type: "dimension",
+      "0": { $value: "0" },
+      "1": { $value: "0.25rem" },
+      "2": { $value: "0.5rem" },
+      "4": { $value: "1rem" },
+      "6": { $value: "1.5rem" },
+      "8": { $value: "2rem" }
+    }
+  };
+  fs3.writeFileSync(path2.join(tokensDir, "spacing.json"), JSON.stringify(spacingJson, null, 2));
+  console.log("\u2705 Created token files in ./tokens/");
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Edit tokens in ./tokens/*.json");
+  console.log("  2. Run: nice-tokens build");
+  console.log("  3. Import generated CSS/JS from ./dist/");
+});
+program.command("validate").description("Validate design token files").argument("[files...]", "Token files to validate").option("-d, --dir <dir>", "Directory containing token files").action(async (files, options) => {
+  const glob = require("fast-glob");
+  let tokenFiles = files;
+  if (options.dir) {
+    tokenFiles = await glob(path2.join(options.dir, "**/*.json"));
+  }
+  if (tokenFiles.length === 0) {
+    console.log("No token files specified");
+    process.exit(1);
+  }
+  console.log("\u{1F50D} Validating design tokens\n");
+  let hasErrors = false;
+  for (const file of tokenFiles) {
+    try {
+      const content = fs3.readFileSync(file, "utf-8");
+      JSON.parse(content);
+      console.log(`\u2705 ${path2.basename(file)}`);
+    } catch (err) {
+      console.log(`\u274C ${path2.basename(file)}: ${err.message}`);
+      hasErrors = true;
+    }
+  }
+  if (hasErrors) {
+    console.log("\n\u274C Validation failed");
+    process.exit(1);
+  } else {
+    console.log("\n\u2705 All files valid");
+  }
+});
+program.command("convert").description("Convert between token formats").argument("<input>", "Input file or directory").argument("<output>", "Output file").option("-f, --format <format>", "Output format", "css").action(async (input, output, options) => {
+  const format = options.format;
+  console.log(`\u{1F504} Converting to ${format}...
+`);
+  try {
+    const generator = createGenerator({
+      formats: [format],
+      outputDir: path2.dirname(output)
+    });
+    const inputStat = fs3.statSync(input);
+    if (inputStat.isDirectory()) {
+      generator.loadDirectory(input);
+    } else {
+      generator.load([input]);
+    }
+    await generator.generate();
+    console.log(`\u2705 Converted to ${output}`);
+  } catch (err) {
+    console.error("\u274C Conversion failed:", err.message);
+    process.exit(1);
+  }
+});
+program.command("info").description("Show information about token files").argument("<dir>", "Directory containing token files").action(async (dir) => {
+  const glob = require("fast-glob");
+  const files = await glob(path2.join(dir, "**/*.json"));
+  console.log("\u{1F4CA} Token Information\n");
+  console.log(`Directory: ${path2.resolve(dir)}`);
+  console.log(`Files: ${files.length}`);
+  console.log("");
+  const generator = createGenerator();
+  generator.loadDirectory(dir);
+  const collection = generator.getCollection();
+  if (collection) {
+    console.log(`Total tokens: ${collection.tokens.length}`);
+    console.log("");
+    const byType = /* @__PURE__ */ new Map();
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const token of collection.tokens) {
+      const type = token.type || "unknown";
+      byType.set(type, (byType.get(type) || 0) + 1);
+      const category = token.path[0] || "root";
+      byCategory.set(category, (byCategory.get(category) || 0) + 1);
+    }
+    console.log("By type:");
+    for (const [type, count] of byType.entries()) {
+      console.log(`  ${type}: ${count}`);
+    }
+    console.log("\nBy category:");
+    for (const [category, count] of byCategory.entries()) {
+      console.log(`  ${category}: ${count}`);
+    }
+  }
+});
+program.command("diff").description("Compare two token files or directories").argument("<source>", "Source file or directory").argument("<target>", "Target file or directory").action(async (source, target) => {
+  console.log("\u{1F50D} Comparing tokens\n");
+  const generatorA = createGenerator();
+  const generatorB = createGenerator();
+  const statA = fs3.statSync(source);
+  const statB = fs3.statSync(target);
+  if (statA.isDirectory()) {
+    generatorA.loadDirectory(source);
+  } else {
+    generatorA.load([source]);
+  }
+  if (statB.isDirectory()) {
+    generatorB.loadDirectory(target);
+  } else {
+    generatorB.load([target]);
+  }
+  const collectionA = generatorA.getCollection();
+  const collectionB = generatorB.getCollection();
+  if (!collectionA || !collectionB) {
+    console.error("Failed to load tokens");
+    process.exit(1);
+  }
+  const pathsA = new Set(collectionA.tokens.map((t) => t.path.join(".")));
+  const pathsB = new Set(collectionB.tokens.map((t) => t.path.join(".")));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const path3 of pathsB) {
+    if (!pathsA.has(path3)) {
+      added.push(path3);
+    }
+  }
+  for (const path3 of pathsA) {
+    if (!pathsB.has(path3)) {
+      removed.push(path3);
+    }
+  }
+  for (const tokenA of collectionA.tokens) {
+    const path3 = tokenA.path.join(".");
+    const tokenB = collectionB.byPath.get(path3);
+    if (tokenB && tokenA.resolvedValue !== tokenB.resolvedValue) {
+      changed.push(`${path3}: ${tokenA.resolvedValue} \u2192 ${tokenB.resolvedValue}`);
+    }
+  }
+  if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+    console.log("No differences found");
+    return;
+  }
+  if (added.length > 0) {
+    console.log(`\u2795 Added (${added.length}):`);
+    for (const p of added.slice(0, 10)) {
+      console.log(`  ${p}`);
+    }
+    if (added.length > 10) {
+      console.log(`  ... and ${added.length - 10} more`);
+    }
+    console.log("");
+  }
+  if (removed.length > 0) {
+    console.log(`\u2796 Removed (${removed.length}):`);
+    for (const p of removed.slice(0, 10)) {
+      console.log(`  ${p}`);
+    }
+    if (removed.length > 10) {
+      console.log(`  ... and ${removed.length - 10} more`);
+    }
+    console.log("");
+  }
+  if (changed.length > 0) {
+    console.log(`\u{1F4DD} Changed (${changed.length}):`);
+    for (const p of changed.slice(0, 10)) {
+      console.log(`  ${p}`);
+    }
+    if (changed.length > 10) {
+      console.log(`  ... and ${changed.length - 10} more`);
+    }
+  }
+});
+program.parse();
+/*! Bundled license information:
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/