@digdir/designsystemet 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/bin/designsystemet.js

@@ -0,0 +1,3445 @@
+#!/usr/bin/env node
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  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
+));
+
+// ../../node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../../node_modules/universalify/index.js"(exports) {
+    "use strict";
+    exports.fromCallback = function(fn) {
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+        else {
+          return new Promise((resolve, reject) => {
+            fn.call(
+              this,
+              ...args,
+              (err, res) => err != null ? reject(err) : resolve(res)
+            );
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function") return fn.apply(this, args);
+        else fn.apply(this, args.slice(0, -1)).then((r) => cb(null, r), cb);
+      }, "name", { value: fn.name });
+    };
+  }
+});
+
+// ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/graceful-fs/polyfills.js"(exports, module) {
+    "use strict";
+    var constants = __require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module.exports = patch;
+    function patch(fs4) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs4);
+      }
+      if (!fs4.lutimes) {
+        patchLutimes(fs4);
+      }
+      fs4.chown = chownFix(fs4.chown);
+      fs4.fchown = chownFix(fs4.fchown);
+      fs4.lchown = chownFix(fs4.lchown);
+      fs4.chmod = chmodFix(fs4.chmod);
+      fs4.fchmod = chmodFix(fs4.fchmod);
+      fs4.lchmod = chmodFix(fs4.lchmod);
+      fs4.chownSync = chownFixSync(fs4.chownSync);
+      fs4.fchownSync = chownFixSync(fs4.fchownSync);
+      fs4.lchownSync = chownFixSync(fs4.lchownSync);
+      fs4.chmodSync = chmodFixSync(fs4.chmodSync);
+      fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
+      fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
+      fs4.stat = statFix(fs4.stat);
+      fs4.fstat = statFix(fs4.fstat);
+      fs4.lstat = statFix(fs4.lstat);
+      fs4.statSync = statFixSync(fs4.statSync);
+      fs4.fstatSync = statFixSync(fs4.fstatSync);
+      fs4.lstatSync = statFixSync(fs4.lstatSync);
+      if (fs4.chmod && !fs4.lchmod) {
+        fs4.lchmod = function(path2, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchmodSync = function() {
+        };
+      }
+      if (fs4.chown && !fs4.lchown) {
+        fs4.lchown = function(path2, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs4.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            });
+          }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs4.rename);
+      }
+      fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs4.read);
+      fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs4, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs4.readSync);
+      function patchLchmod(fs5) {
+        fs5.lchmod = function(path2, mode, callback) {
+          fs5.open(
+            path2,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs5.fchmod(fd, mode, function(err2) {
+                fs5.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs5.lchmodSync = function(path2, mode) {
+          var fd = fs5.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs5.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs5.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs5.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs5) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
+          fs5.lutimes = function(path2, at, mt, cb) {
+            fs5.open(path2, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs5.futimes(fd, at, mt, function(er2) {
+                fs5.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs5.lutimesSync = function(path2, at, mt) {
+            var fd = fs5.openSync(path2, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs5.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs5.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs5.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs5.futimes) {
+          fs5.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs5.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs4, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs4, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs4, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs4, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    "use strict";
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs4) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path2, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path2, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path2;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs4.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path2, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path2, options);
+        Stream.call(this);
+        this.path = path2;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs4.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/graceful-fs/clone.js"(exports, module) {
+    "use strict";
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+
+// ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
+    "use strict";
+    var fs4 = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = __require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs4[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs4, queue);
+      fs4.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs4, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs4.close);
+      fs4.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs4, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs4.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs4[gracefulQueue]);
+          __require("assert").equal(fs4[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs4[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs4));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
+      module.exports = patch(fs4);
+      fs4.__patched = true;
+    }
+    function patch(fs5) {
+      polyfills(fs5);
+      fs5.gracefulify = patch;
+      fs5.createReadStream = createReadStream;
+      fs5.createWriteStream = createWriteStream;
+      var fs$readFile = fs5.readFile;
+      fs5.readFile = readFile;
+      function readFile(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path2, options, cb);
+        function go$readFile(path3, options2, cb2, startTime) {
+          return fs$readFile(path3, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs5.writeFile;
+      fs5.writeFile = writeFile;
+      function writeFile(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path2, data, options, cb);
+        function go$writeFile(path3, data2, options2, cb2, startTime) {
+          return fs$writeFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs5.appendFile;
+      if (fs$appendFile)
+        fs5.appendFile = appendFile;
+      function appendFile(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path2, data, options, cb);
+        function go$appendFile(path3, data2, options2, cb2, startTime) {
+          return fs$appendFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs5.copyFile;
+      if (fs$copyFile)
+        fs5.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs5.readdir;
+      fs5.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, options2, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path2, options, cb);
+        function fs$readdirCallback(path3, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path3, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs5);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs5.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs5.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs5, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs5, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs5, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs5, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path2, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path2, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path2, options) {
+        return new fs5.ReadStream(path2, options);
+      }
+      function createWriteStream(path2, options) {
+        return new fs5.WriteStream(path2, options);
+      }
+      var fs$open = fs5.open;
+      fs5.open = open;
+      function open(path2, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path2, flags, mode, cb);
+        function go$open(path3, flags2, mode2, cb2, startTime) {
+          return fs$open(path3, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs5;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs4[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
+        if (fs4[gracefulQueue][i].length > 2) {
+          fs4[gracefulQueue][i][3] = now;
+          fs4[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs4[gracefulQueue].length === 0)
+        return;
+      var elem = fs4[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs4[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "../../node_modules/fs-extra/lib/fs/index.js"(exports) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs4 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs4[key] === "function";
+    });
+    Object.assign(exports, fs4);
+    api.forEach((method) => {
+      exports[method] = u(fs4[method]);
+    });
+    exports.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs4.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs4.exists(filename, resolve);
+      });
+    };
+    exports.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs4.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs4.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs4.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err) return reject(err);
+          resolve({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs4.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve, reject) => {
+        fs4.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err) return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs4.realpath.native === "function") {
+      exports.realpath.native = u(fs4.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
+    "use strict";
+    var path2 = __require("path");
+    module.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path2.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number") return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs4.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs4.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs4 = require_fs();
+    function pathExists(path2) {
+      return fs4.access(path2).then(() => true).catch(() => false);
+    }
+    module.exports = {
+      pathExists: u(pathExists),
+      pathExistsSync: fs4.existsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../../node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path2, atime, mtime) {
+      const fd = await fs4.open(path2, "r+");
+      let closeErr = null;
+      try {
+        await fs4.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs4.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
+    }
+    function utimesMillisSync(path2, atime, mtime) {
+      const fd = fs4.openSync(path2, "r+");
+      fs4.futimesSync(fd, atime, mtime);
+      return fs4.closeSync(fd);
+    }
+    module.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "../../node_modules/fs-extra/lib/util/stat.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var path2 = __require("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs4.stat(file, { bigint: true }) : (file) => fs4.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT") return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs4.statSync(file, { bigint: true }) : (file) => fs4.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT") return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path2.basename(src);
+          const destBaseName = path2.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path2.basename(src);
+          const destBaseName = path2.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src, srcStat, dest, funcName) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = await fs4.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root) return;
+      let destStat;
+      try {
+        destStat = fs4.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path2.resolve(src).split(path2.sep).filter((i) => i);
+      const destArr = path2.resolve(dest).split(path2.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var path2 = __require("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat = require_stat();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include) return;
+      const destParent = path2.dirname(dest);
+      const dirExists = await pathExists(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter) return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs4.stat : fs4.lstat;
+      const srcStat = await statFn(src);
+      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+      if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs4.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs4.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs4.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs4.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs4.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs4.mkdir(dest);
+      }
+      const items = await fs4.readdir(src);
+      await Promise.all(items.map(async (item) => {
+        const srcItem = path2.join(src, item);
+        const destItem = path2.join(dest, item);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (!include) return;
+        const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+        return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+      }));
+      if (!destStat) {
+        await fs4.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs4.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs4.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs4.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs4.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+      }
+      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
+      await fs4.unlink(dest);
+      return fs4.symlink(resolvedSrc, dest);
+    }
+    module.exports = copy;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path2 = __require("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
+      }
+      const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "copy");
+      if (opts.filter && !opts.filter(src, dest)) return;
+      const destParent = path2.dirname(dest);
+      if (!fs4.existsSync(destParent)) mkdirsSync(destParent);
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync = opts.dereference ? fs4.statSync : fs4.lstatSync;
+      const srcStat = statSync(src);
+      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs4.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs4.copyFileSync(src, dest);
+      if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs4.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs4.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs4.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs4.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path2.join(src, item);
+      const destItem = path2.join(dest, item);
+      if (opts.filter && !opts.filter(srcItem, destItem)) return;
+      const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+      return getStats(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs4.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs4.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs4.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs4.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs4.unlinkSync(dest);
+      return fs4.symlinkSync(resolvedSrc, dest);
+    }
+    module.exports = copySync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/fs-extra/lib/copy/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/fs-extra/lib/remove/index.js"(exports, module) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove2(path2, callback) {
+      fs4.rm(path2, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path2) {
+      fs4.rmSync(path2, { recursive: true, force: true });
+    }
+    module.exports = {
+      remove: u(remove2),
+      removeSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "../../node_modules/fs-extra/lib/empty/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs4 = require_fs();
+    var path2 = __require("path");
+    var mkdir = require_mkdirs();
+    var remove2 = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs4.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove2.remove(path2.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs4.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path2.join(dir, item);
+        remove2.removeSync(item);
+      });
+    }
+    module.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require("path");
+    var fs4 = require_fs();
+    var mkdir = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs4.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path2.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs4.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs4.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs4.writeFile(file, "");
+      } else {
+        await fs4.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs4.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile()) return;
+      const dir = path2.dirname(file);
+      try {
+        if (!fs4.statSync(dir).isDirectory()) {
+          fs4.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
+        else throw err;
+      }
+      fs4.writeFileSync(file, "");
+    }
+    module.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require("path");
+    var fs4 = require_fs();
+    var mkdir = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs4.lstat(dstpath);
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs4.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat)) return;
+      const dir = path2.dirname(dstpath);
+      const dirExists = await pathExists(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs4.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs4.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs4.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat)) return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path2.dirname(dstpath);
+      const dirExists = fs4.existsSync(dir);
+      if (dirExists) return fs4.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs4.linkSync(srcpath, dstpath);
+    }
+    module.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
+    "use strict";
+    var path2 = __require("path");
+    var fs4 = require_fs();
+    var { pathExists } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path2.isAbsolute(srcpath)) {
+        try {
+          await fs4.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path2.dirname(dstpath);
+      const relativeToDst = path2.join(dstdir, srcpath);
+      const exists = await pathExists(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs4.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path2.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path2.isAbsolute(srcpath)) {
+        const exists2 = fs4.existsSync(srcpath);
+        if (!exists2) throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path2.dirname(dstpath);
+      const relativeToDst = path2.join(dstdir, srcpath);
+      const exists = fs4.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs4.existsSync(srcpath);
+      if (!srcExists) throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path2.relative(dstdir, srcpath)
+      };
+    }
+    module.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = await fs4.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type) return type;
+      let stats;
+      try {
+        stats = fs4.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require("path");
+    var fs4 = require_fs();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs4.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs4.stat(srcpath),
+          fs4.stat(dstpath)
+        ]);
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative.toDst;
+      const toType = await symlinkType(relative.toCwd, type);
+      const dir = path2.dirname(dstpath);
+      if (!await pathExists(dir)) {
+        await mkdirs(dir);
+      }
+      return fs4.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs4.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs4.statSync(srcpath);
+        const dstStat = fs4.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat)) return;
+      }
+      const relative = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative.toDst;
+      type = symlinkTypeSync(relative.toCwd, type);
+      const dir = path2.dirname(dstpath);
+      const exists = fs4.existsSync(dir);
+      if (exists) return fs4.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs4.symlinkSync(srcpath, dstpath, type);
+    }
+    module.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
+    "use strict";
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/jsonfile/utils.js"(exports, module) {
+    "use strict";
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content)) content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module.exports = { stringify, stripBom };
+  }
+});
+
+// ../../node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../../node_modules/jsonfile/index.js"(exports, module) {
+    "use strict";
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = __require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils2();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs4 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs4.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs4 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs4.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs4 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs4.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs4 = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs4.writeFileSync(file, str, options);
+    }
+    var jsonfile = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync
+    };
+    module.exports = jsonfile;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "../../node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs4 = require_fs();
+    var path2 = __require("path");
+    var mkdir = require_mkdirs();
+    var pathExists = require_path_exists().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path2.dirname(file);
+      if (!await pathExists(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs4.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path2.dirname(file);
+      if (!fs4.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs4.writeFileSync(file, ...args);
+    }
+    module.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module.exports = outputJson;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
+    "use strict";
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module.exports = outputJsonSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../../node_modules/fs-extra/lib/json/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module.exports = jsonFile;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../node_modules/fs-extra/lib/move/move.js"(exports, module) {
+    "use strict";
+    var fs4 = require_fs();
+    var path2 = __require("path");
+    var { copy } = require_copy2();
+    var { remove: remove2 } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists } = require_path_exists();
+    var stat = require_stat();
+    async function move(src, dest, opts = {}) {
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "move");
+      const destParent = path2.dirname(dest);
+      const parsedParentPath = path2.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove2(dest);
+        } else if (await pathExists(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs4.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove2(src);
+    }
+    module.exports = move;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS({
+  "../../node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
+    "use strict";
+    var fs4 = require_graceful_fs();
+    var path2 = __require("path");
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "move");
+      if (!isParentRoot(dest)) mkdirpSync(path2.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path2.dirname(dest);
+      const parsedPath = path2.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase) return rename(src, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs4.existsSync(dest)) throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs4.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module.exports = moveSync;
+  }
+});
+
+// ../../node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/fs-extra/lib/move/index.js"(exports, module) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../../node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/fs-extra/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
+// bin/designsystemet.ts
+import { Argument, program } from "@commander-js/extra-typings";
+import chalk5 from "chalk";
+
+// src/migrations/codemods/css/plugins.ts
+import * as R from "ramda";
+import chalk from "chalk";
+import hash from "object-hash";
+var printDelete = (text) => console.log(`${chalk.red("Deleted:")} ${text}`.replace(/"|'/g, ""));
+var deleteMsg = (decl, from) => `${chalk.yellow(from)} @ ${chalk.gray(`${JSON.stringify(decl.source?.input.file)}:${decl.source?.start?.line}:${decl.source?.start?.column}`)}`;
+var cssClassRename = (dictionary) => ({
+  postcssPlugin: `Renames CSS classes ${hash(dictionary)}`,
+  Rule(rule) {
+    const selector = rule.selector;
+    if (!selector) return;
+    Object.entries(dictionary).forEach(([from, to]) => {
+      if (!selector.includes(from)) return;
+      const newSelector = selector.replace(new RegExp(from, "g"), to);
+      rule.selector = newSelector;
+    });
+  }
+});
+var cssVarRename = (dictionary) => ({
+  postcssPlugin: `Replaces CSS variables ${hash(dictionary)}`,
+  Declaration(decl) {
+    const { value, prop: prop2 } = decl;
+    const deleted = /* @__PURE__ */ new Set();
+    Object.entries(dictionary).forEach(([from, to]) => {
+      if (!R.isEmpty(to)) {
+        switch (true) {
+          case R.includes(from, value):
+            to === "[delete]" && deleted.add(deleteMsg(decl, from));
+            decl.value = value.replace(from, to);
+            break;
+          case R.includes(from, prop2):
+            if (decl.variable) {
+              to === "[delete]" && deleted.add(deleteMsg(decl, from));
+              decl.prop = prop2.replace(from, to);
+              break;
+            }
+        }
+      }
+    });
+    if (deleted.size > 0) {
+      Array.from(deleted).forEach(printDelete);
+    }
+  }
+});
+
+// src/migrations/codemods/css/run.ts
+import fs from "fs";
+import postcss from "postcss";
+import glob from "fast-glob";
+var runCssCodemod = async ({ plugins = [], globPattern = "./**/*.css" }) => {
+  const processor = postcss(plugins);
+  const transform = async () => {
+    const files = await glob(globPattern, { ignore: ["node_modules/**", "dist/**"] });
+    const filePromises = files.map(async (file) => {
+      const contents = fs.readFileSync(file).toString();
+      const result = await processor.process(contents, { from: file });
+      fs.writeFileSync(file, result.css);
+    });
+    await Promise.all(filePromises);
+  };
+  return transform();
+};
+
+// src/migrations/beta-to-v1.ts
+var beta_to_v1_default = (glob4) => runCssCodemod({
+  globPattern: glob4,
+  plugins: [
+    cssClassRename({
+      ".fds-": ".ds-"
+    }),
+    // New component token prefixes
+    cssVarRename({
+      "--fds-accordion": "--dsc-accordion",
+      "--fds-alert": "--dsc-alert",
+      "--fds-btn": "--dsc-btn",
+      "--fds-checkbox": "--dsc-checkbox",
+      "--fdsc-chip": "--dsc-chip",
+      "--fdsc-gap": "--dsc-chip-group-gap",
+      "--fdsc-removable": "--dsc-removable",
+      "--fdsc-bottom": "--dsc-bottom",
+      "--fds-pagination": "--dsc-pagination",
+      "--fds-popover": "--dsc-popover",
+      "--fds-radio": "--dsc-radio",
+      "--f-search": "--dsc-search",
+      "--fds-skeleton": "--dsc-skeleton",
+      "--fds-switch--transition": "--dsc-switch-transition",
+      "--fds-switch": "--dsc-switch",
+      "--table-padding": "--dsc-table-padding",
+      "--border-radius": "--dsc-table-border-radius",
+      "--fds-tabs": "--dsc-tabs",
+      "--fds-tag": "--dsc-tag",
+      "--fds-focus-border-width": "--dsc-focus-border-width"
+    }),
+    // New tokens
+    cssVarRename({
+      "--fds-semantic-surface-first-light": "--ds-color-brand1-surface-default",
+      "--fds-semantic-surface-first-light-hover": "--ds-color-brand1-surface-hover",
+      "--fds-semantic-surface-first-light-active": "--ds-color-brand1-surface-active",
+      "--fds-semantic-surface-first-dark": "[delete]",
+      "--fds-semantic-surface-second-light": "--ds-color-brand2-surface-default",
+      "--fds-semantic-surface-second-light-hover": "--ds-color-brand2-surface-hover",
+      "--fds-semantic-surface-second-light-active": "--ds-color-brand2-surface-active",
+      "--fds-semantic-surface-second-dark": "[delete]",
+      "--fds-semantic-surface-third-light": "--ds-color-brand3-surface-default",
+      "--fds-semantic-surface-third-light-hover": "--ds-color-brand3-surface-hover",
+      "--fds-semantic-surface-third-light-active": "--ds-color-brand3-surface-active",
+      "--fds-semantic-surface-third-dark": "[delete]",
+      "--fds-semantic-surface-action-first-subtle": "--ds-color-accent-surface-default",
+      "--fds-semantic-surface-action-first-subtle-hover": "--ds-color-accent-surface-hover",
+      "--fds-semantic-surface-action-first-default": "--ds-color-accent-base-default",
+      "--fds-semantic-surface-action-first-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-surface-action-first-active": "--ds-color-accent-base-active",
+      "--fds-semantic-surface-action-first-no_fill": "--ds-color-accent-background-default",
+      "--fds-semantic-surface-action-first-no_fill-hover": "--ds-color-accent-surface-default",
+      "--fds-semantic-surface-action-first-no_fill-active": "--ds-color-accent-surface-hover",
+      "--fds-semantic-surface-action-second-subtle": "--ds-color-neutral-surface-default",
+      "--fds-semantic-surface-action-second-subtle-hover": "--ds-color-neutral-surface-hover",
+      "--fds-semantic-surface-action-second-default": "--ds-color-neutral-base-default",
+      "--fds-semantic-surface-action-second-hover": "--ds-color-neutral-base-hover",
+      "--fds-semantic-surface-action-second-active": "--ds-color-neutral-base-active",
+      "--fds-semantic-surface-action-second-no_fill": "--ds-color-neutral-background-default",
+      "--fds-semantic-surface-action-second-no_fill-hover": "--ds-color-neutral-surface-default",
+      "--fds-semantic-surface-action-second-no_fill-active": "--ds-color-neutral-surface-hover",
+      "--fds-semantic-surface-action-subtle": "--ds-color-accent-surface-default",
+      "--fds-semantic-surface-action-subtle-hover": "--ds-color-accent-surface-hover",
+      "--fds-semantic-surface-action-default": "--ds-color-accent-base-default",
+      "--fds-semantic-surface-action-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-surface-action-active": "--ds-color-accent-base-active",
+      "--fds-semantic-surface-action-no_fill": "--ds-color-accent-background-default",
+      "--fds-semantic-surface-action-no_fill-hover": "--ds-color-accent-surface-default",
+      "--fds-semantic-surface-action-no_fill-active": "--ds-color-accent-surface-hover",
+      "--fds-semantic-surface-action-checked": "--ds-color-accent-base-default",
+      "--fds-semantic-surface-neutral-default": "--ds-color-neutral-background-default",
+      "--fds-semantic-surface-neutral-selected": "[delete]",
+      "--fds-semantic-surface-neutral-subtle": "--ds-color-neutral-background-subtle",
+      "--fds-semantic-surface-neutral-subtle-hover": "--ds-color-neutral-surface-default",
+      "--fds-semantic-surface-neutral-dark": "[delete]",
+      "--fds-semantic-surface-neutral-dark-hover": "[delete]",
+      "--fds-semantic-surface-neutral-inverted": "[delete]",
+      "--fds-semantic-surface-success-subtle": "--ds-color-success-surface-default",
+      "--fds-semantic-surface-success-subtle-hover": "--ds-color-success-surface-hover",
+      "--fds-semantic-surface-success-default": "--ds-color-success-base-default",
+      "--fds-semantic-surface-success-hover": "--ds-color-success-base-hover",
+      "--fds-semantic-surface-success-active": "--ds-color-success-base-active",
+      "--fds-semantic-surface-success-no_fill": "--ds-color-success-background-default",
+      "--fds-semantic-surface-success-no_fill-hover": "--ds-color-success-surface-default",
+      "--fds-semantic-surface-success-no_fill-active": "--ds-color-success-surface-hover",
+      "--fds-semantic-surface-warning-subtle": "--ds-color-warning-surface-default",
+      "--fds-semantic-surface-warning-subtle-hover": "--ds-color-warning-surface-default",
+      "--fds-semantic-surface-warning-default": "--ds-color-warning-surface-default",
+      "--fds-semantic-surface-warning-default-hover": "--ds-color-warning-surface-hover",
+      "--fds-semantic-surface-danger-subtle": "--ds-color-danger-surface-default",
+      "--fds-semantic-surface-danger-subtle-hover": "--ds-color-danger-surface-hover",
+      "--fds-semantic-surface-danger-default": "--ds-color-danger-base-default",
+      "--fds-semantic-surface-danger-hover": "--ds-color-danger-base-hover",
+      "--fds-semantic-surface-danger-active": "--ds-color-danger-base-active",
+      "--fds-semantic-surface-danger-no_fill": "--ds-color-danger-background-default",
+      "--fds-semantic-surface-danger-no_fill-hover": "--ds-color-danger-surface-default",
+      "--fds-semantic-surface-danger-no_fill-active": "--ds-color-danger-surface-hover",
+      "--fds-semantic-surface-info-subtle": "--ds-color-info-surface-default",
+      "--fds-semantic-surface-info-subtle-hover": "[delete]",
+      "--fds-semantic-surface-on_inverted-default": "[delete]",
+      "--fds-semantic-surface-on_inverted-hover": "[delete]",
+      "--fds-semantic-surface-on_inverted-active": "[delete]",
+      "--fds-semantic-surface-on_inverted-no_fill": "[delete]",
+      "--fds-semantic-surface-on_inverted-no_fill-hover": "[delete]",
+      "--fds-semantic-surface-on_inverted-no_fill-active": "[delete]",
+      "--fds-semantic-surface-focus-default": "[delete]",
+      "--fds-semantic-border-first-default": "--ds-color-brand1-base-default",
+      "--fds-semantic-border-first-hover": "--ds-color-brand1-base-hover",
+      "--fds-semantic-border-first-active": "--ds-color-brand1-base-active",
+      "--fds-semantic-border-second-default": "--ds-color-brand2-base-default",
+      "--fds-semantic-border-second-hover": "--ds-color-brand2-base-hover",
+      "--fds-semantic-border-second-active": "--ds-color-brand2-base-active",
+      "--fds-semantic-border-third-default": "--ds-color-brand3-base-default",
+      "--fds-semantic-border-third-hover": "--ds-color-brand3-base-hover",
+      "--fds-semantic-border-third-active": "--ds-color-brand3-base-active",
+      "--fds-semantic-border-action-first-subtle": "--ds-color-accent-border-subtle",
+      "--fds-semantic-border-action-first-subtle-hover": "--ds-color-accent-border-default",
+      "--fds-semantic-border-action-first-default": "--ds-color-accent-base-default",
+      "--fds-semantic-border-action-first-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-border-action-first-active": "--ds-color-accent-base-active",
+      "--fds-semantic-border-action-second-subtle": "--ds-color-neutral-border-subtle",
+      "--fds-semantic-border-action-second-subtle-hover": "--ds-color-neutral-border-default",
+      "--fds-semantic-border-action-second-default": "--ds-color-neutral-base-default",
+      "--fds-semantic-border-action-second-hover": "--ds-color-neutral-base-hover",
+      "--fds-semantic-border-action-second-active": "--ds-color-neutral-base-active",
+      "--fds-semantic-border-action-subtle": "--ds-color-accent-border-subtle",
+      "--fds-semantic-border-action-subtle-hover": "--ds-color-accent-border-default",
+      "--fds-semantic-border-action-default": "--ds-color-accent-base-default",
+      "--fds-semantic-border-action-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-border-action-active": "--ds-color-accent-base-active",
+      "--fds-semantic-border-action-dark": "[delete]",
+      "--fds-semantic-border-action-dark-hover": "[delete]",
+      "--fds-semantic-border-info-default": "--ds-color-info-border-strong",
+      "--fds-semantic-border-neutral-default": "--ds-color-neutral-border-strong",
+      "--fds-semantic-border-neutral-subtle": "--ds-color-neutral-border-subtle",
+      "--fds-semantic-border-neutral-strong": "--ds-color-neutral-base-default",
+      "--fds-semantic-border-success-default": "--ds-color-success-border-default",
+      "--fds-semantic-border-success-hover": "[delete]",
+      "--fds-semantic-border-success-active": "[delete]",
+      "--fds-semantic-border-warning-default": "--ds-color-warning-border-default",
+      "--fds-semantic-border-warning-hover": "[delete]",
+      "--fds-semantic-border-warning-active": "[delete]",
+      "--fds-semantic-border-danger-default": "--ds-color-danger-border-default",
+      "--fds-semantic-border-danger-hover": "--ds-color-danger-border-strong",
+      "--fds-semantic-border-danger-active": "--ds-color-danger-border-strong",
+      "--fds-semantic-border-focus-outline": "--ds-color-neutral-text-default",
+      "--fds-semantic-border-focus-boxshadow": "--ds-color-neutral-background-default",
+      "--fds-semantic-border-on_inverted-default": "[delete]",
+      "--fds-semantic-border-input-default": "--ds-color-neutral-border-default",
+      "--fds-semantic-border-input-hover": "--ds-color-accent-border-strong",
+      "--fds-semantic-border-divider-default": "--ds-color-neutral-border-subtle",
+      "--fds-semantic-border-divider-subtle": "--ds-color-neutral-border-subtle",
+      "--fds-semantic-border-divider-strong": "--ds-color-neutral-border-default",
+      "--fds-semantic-text-action-first-default": "--ds-color-accent-base-default",
+      "--fds-semantic-text-action-first-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-text-action-first-active": "--ds-color-accent-base-active",
+      "--fds-semantic-text-action-first-on_action": "--ds-color-accent-contrast-default",
+      "--fds-semantic-text-action-second-default": "--ds-color-neutral-base-default",
+      "--fds-semantic-text-action-second-hover": "--ds-color-neutral-base-hover",
+      "--fds-semantic-text-action-second-active": "--ds-color-neutral-base-active",
+      "--fds-semantic-text-action-second-on_action": "--ds-color-neutral-contrast-default",
+      "--fds-semantic-text-action-default": "--ds-color-accent-base-default",
+      "--fds-semantic-text-action-hover": "--ds-color-accent-base-hover",
+      "--fds-semantic-text-action-active": "--ds-color-accent-base-active",
+      "--fds-semantic-text-action-on_action": "--ds-color-accent-contrast-default",
+      "--fds-semantic-text-success-default": "--ds-color-success-base-default",
+      "--fds-semantic-text-success-hover": "--ds-color-success-base-default",
+      "--fds-semantic-text-success-active": "--ds-color-success-base-default",
+      "--fds-semantic-text-success-on_success": "--ds-color-success-contrast-default",
+      "--fds-semantic-text-success-on_success_subtle": "--ds-color-success-text-default",
+      "--fds-semantic-text-neutral-default": "--ds-color-neutral-text-default",
+      "--fds-semantic-text-neutral-subtle": "--ds-color-neutral-text-subtle",
+      "--fds-semantic-text-neutral-on_inverted": "--ds-color-neutral-contrast-default",
+      "--fds-semantic-text-warning-default": "[delete]",
+      "--fds-semantic-text-warning-icon_warning": "--ds-color-warning-base-default",
+      "--fds-semantic-text-warning-on_warning": "--ds-color-neutral-text-default",
+      "--fds-semantic-text-danger-default": "--ds-color-danger-text-default",
+      "--fds-semantic-text-danger-hover": "--ds-color-danger-text-default",
+      "--fds-semantic-text-danger-active": "--ds-color-danger-text-default",
+      "--fds-semantic-text-danger-on_danger": "--ds-color-danger-contrast-default",
+      "--fds-semantic-text-danger-on_danger_subtle": "--ds-color-danger-text-default",
+      "--fds-semantic-text-visited-default": "--ds-global-purple-13",
+      "--fds-semantic-background-default": "--ds-color-neutral-background-default",
+      "--fds-semantic-background-subtle": "--ds-color-neutral-background-subtle",
+      "--fds-typography-heading-3xlarge": "[delete]",
+      "--fds-typography-heading-2xlarge": "--ds-typography-heading-2xl",
+      "--fds-typography-heading-xlarge": "--ds-typography-heading-xl",
+      "--fds-typography-heading-large": "--ds-typography-heading-lg",
+      "--fds-typography-heading-medium": "--ds-typography-heading-md",
+      "--fds-typography-heading-small": "--ds-typography-heading-sm",
+      "--fds-typography-heading-xsmall": "--ds-typography-heading-xs",
+      "--fds-typography-heading-xxsmall": "--ds-typography-heading-2xs",
+      "--fds-typography-ingress-large": "--ds-typography-ingress-lg",
+      "--fds-typography-ingress-medium": "--ds-typography-ingress-md",
+      "--fds-typography-ingress-small": "--ds-typography-ingress-sm",
+      "--fds-typography-ingress-xsmall": "--ds-typography-ingress-xs",
+      "--fds-typography-paragraph-large": "--ds-typography-paragraph-lg",
+      "--fds-typography-paragraph-medium": "--ds-typography-paragraph-md",
+      "--fds-typography-paragraph-small": "--ds-typography-paragraph-sm",
+      "--fds-typography-paragraph-xsmall": "--ds-typography-paragraph-xs",
+      "--fds-typography-paragraph-short-large": "--ds-typography-paragraph-short-lg",
+      "--fds-typography-paragraph-short-medium": "--ds-typography-paragraph-short-md",
+      "--fds-typography-paragraph-short-small": "--ds-typography-paragraph-short-sm",
+      "--fds-typography-paragraph-short-xsmall": "--ds-typography-paragraph-short-xs",
+      "--fds-typography-paragraph-long-large": "--ds-typography-paragraph-long-lg",
+      "--fds-typography-paragraph-long-medium": "--ds-typography-paragraph-long-md",
+      "--fds-typography-paragraph-long-small": "--ds-typography-paragraph-long-sm",
+      "--fds-typography-paragraph-long-xsmall": "--ds-typography-paragraph-long-xs",
+      "--fds-typography-label-large": "--ds-typography-label-lg",
+      "--fds-typography-label-medium": "--ds-typography-label-md",
+      "--fds-typography-label-small": "--ds-typography-label-sm",
+      "--fds-typography-label-xsmall": "--ds-typography-label-xs",
+      "--fds-typography-error_message-large": "--ds-typography-error_message-lg",
+      "--fds-typography-error_message-medium": "--ds-typography-error_message-md",
+      "--fds-typography-error_message-small": "--ds-typography-error_message-sm",
+      "--fds-typography-error_message-xsmall": "--ds-typography-error_message-xs",
+      "--fds-typography-interactive-large": "--ds-typography-paragraph-short-lg",
+      "--fds-typography-interactive-medium": "--ds-typography-paragraph-short-md",
+      "--fds-typography-interactive-small": "--ds-typography-paragraph-short-sm",
+      "--fds-border_radius-interactive": "--ds-border-radius-md",
+      "--fds-border_radius-small": "--ds-border-radius-sm",
+      "--fds-border_radius-medium": "--ds-border-radius-md",
+      "--fds-border_radius-large": "--ds-border-radius-lg",
+      "--fds-border_radius-xlarge": "--ds-border-radius-xl",
+      "--fds-border_radius-xxlarge": "--ds-border-radius-2xl",
+      "--fds-border_radius-xxxlarge": "--ds-border-radius-3xl",
+      "--fds-border_radius-xxxxlarge": "--ds-border-radius-4xl",
+      "--fds-border_radius-full": "--ds-border-radius-full",
+      "--fds-base_spacing": "[delete]",
+      "--fds-base_sizing": "[delete]",
+      "--fds-border_width-default": "--ds-border-width-default",
+      "--fds-border_width-active": "--ds-border-width-highlight",
+      "--fds-border_width-tab_focus": "--ds-border-width-highlight",
+      "--fds-shadow-xsmall": "--ds-shadow-xs",
+      "--fds-shadow-small": "--ds-shadow-sm",
+      "--fds-shadow-medium": "--ds-shadow-md",
+      "--fds-shadow-large": "--ds-shadow-lg",
+      "--fds-shadow-xlarge": "--ds-shadow-xl",
+      "--fds-spacing-0": "--ds-spacing-0",
+      "--fds-spacing-1": "--ds-spacing-1",
+      "--fds-spacing-2": "--ds-spacing-2",
+      "--fds-spacing-3": "--ds-spacing-3",
+      "--fds-spacing-4": "--ds-spacing-4",
+      "--fds-spacing-5": "--ds-spacing-5",
+      "--fds-spacing-6": "--ds-spacing-6",
+      "--fds-spacing-7": "--ds-spacing-7",
+      "--fds-spacing-8": "--ds-spacing-8",
+      "--fds-spacing-9": "--ds-spacing-9",
+      "--fds-spacing-10": "--ds-spacing-10",
+      "--fds-spacing-11": "--ds-spacing-11",
+      "--fds-spacing-12": "--ds-spacing-12",
+      "--fds-spacing-13": "--ds-spacing-13",
+      "--fds-spacing-14": "--ds-spacing-14",
+      "--fds-spacing-15": "--ds-spacing-15",
+      "--fds-spacing-18": "--ds-spacing-18",
+      "--fds-spacing-22": "--ds-spacing-22",
+      "--fds-spacing-26": "--ds-spacing-26",
+      "--fds-spacing-30": "--ds-spacing-30",
+      "--fds-sizing-0": "--ds-sizing-0",
+      "--fds-sizing-1": "--ds-sizing-1",
+      "--fds-sizing-2": "--ds-sizing-2",
+      "--fds-sizing-3": "--ds-sizing-3",
+      "--fds-sizing-4": "--ds-sizing-4",
+      "--fds-sizing-5": "--ds-sizing-5",
+      "--fds-sizing-6": "--ds-sizing-6",
+      "--fds-sizing-7": "--ds-sizing-7",
+      "--fds-sizing-8": "--ds-sizing-8",
+      "--fds-sizing-9": "--ds-sizing-9",
+      "--fds-sizing-10": "--ds-sizing-10",
+      "--fds-sizing-11": "--ds-sizing-11",
+      "--fds-sizing-12": "--ds-sizing-12",
+      "--fds-sizing-13": "--ds-sizing-13",
+      "--fds-sizing-14": "--ds-sizing-14",
+      "--fds-sizing-15": "--ds-sizing-15",
+      "--fds-sizing-18": "--ds-sizing-18",
+      "--fds-sizing-22": "--ds-sizing-22",
+      "--fds-sizing-26": "--ds-sizing-26",
+      "--fds-sizing-30": "--ds-sizing-30",
+      "--fds-opacity-disabled": "--ds-disabled-opacity",
+      "--fds-colors-blue-100": "--ds-global-blue-1",
+      "--fds-colors-blue-200": "--ds-global-blue-2",
+      "--fds-colors-blue-700": "--ds-global-blue-7",
+      "--fds-colors-blue-800": "--ds-global-blue-8",
+      "--fds-colors-blue-900": "--ds-global-blue-9",
+      "--fds-colors-grey-100": "--ds-color-neutral-1",
+      "--fds-colors-grey-200": "--ds-color-neutral-2",
+      "--fds-colors-grey-400": "--ds-color-neutral-4",
+      "--fds-colors-grey-600": "--ds-color-neutral-6",
+      "--fds-colors-grey-700": "--ds-color-neutral-7",
+      "--fds-colors-grey-800": "--ds-color-neutral-8",
+      "--fds-colors-green-200": "--ds-global-green-2",
+      "--fds-colors-green-300": "--ds-global-green-3",
+      "--fds-colors-green-700": "--ds-global-green-7",
+      "--fds-colors-green-800": "--ds-global-green-8",
+      "--fds-colors-green-900": "--ds-global-green-9",
+      "--fds-colors-yellow-100": "--ds-global-yellow-1",
+      "--fds-colors-yellow-200": "--ds-global-yellow-2",
+      "--fds-colors-yellow-300": "--ds-global-yellow-3",
+      "--fds-colors-yellow-500": "--ds-global-yellow-5",
+      "--fds-colors-blue-400": "--ds-global-blue-4",
+      "--fds-colors-grey-300": "--ds-global-grey-3",
+      "--fds-colors-orange-600": "--ds-global-orange-6",
+      "--fds-colors-orange-700": "--ds-global-orange-7",
+      "--fds-colors-orange-800": "--ds-global-orange-8",
+      "--fds-colors-red-800": "--ds-global-red-8",
+      "--fds-colors-purple-700": "--ds-global-purple-7",
+      "--fds-colors-red-100": "--ds-global-red-1",
+      "--fds-colors-red-200": "--ds-global-red-2",
+      "--fds-colors-red-500": "--ds-global-red-5",
+      "--fds-colors-red-600": "--ds-global-red-6",
+      "--fds-colors-red-700": "--ds-global-red-7",
+      "--fds-brand-alt1-100": "--ds-color-brand1-1",
+      "--fds-brand-alt1-200": "--ds-color-brand1-2",
+      "--fds-brand-alt1-300": "--ds-color-brand1-3",
+      "--fds-brand-alt1-400": "--ds-color-brand1-4",
+      "--fds-brand-alt1-500": "--ds-color-brand1-5",
+      "--fds-brand-alt1-600": "--ds-color-brand1-6",
+      "--fds-brand-alt1-700": "--ds-color-brand1-7",
+      "--fds-brand-alt1-800": "--ds-color-brand1-8",
+      "--fds-brand-alt1-900": "--ds-color-brand1-9",
+      "--fds-brand-alt2-100": "--ds-color-brand2-1",
+      "--fds-brand-alt2-200": "--ds-color-brand2-2",
+      "--fds-brand-alt2-300": "--ds-color-brand2-3",
+      "--fds-brand-alt2-400": "--ds-color-brand2-4",
+      "--fds-brand-alt2-500": "--ds-color-brand2-5",
+      "--fds-brand-alt2-600": "--ds-color-brand2-6",
+      "--fds-brand-alt2-700": "--ds-color-brand2-7",
+      "--fds-brand-alt2-800": "--ds-color-brand2-8",
+      "--fds-brand-alt2-900": "--ds-color-brand2-9",
+      "--fds-brand-alt3-100": "--ds-color-brand3-1",
+      "--fds-brand-alt3-200": "--ds-color-brand3-2",
+      "--fds-brand-alt3-300": "--ds-color-brand3-3",
+      "--fds-brand-alt3-400": "--ds-color-brand3-4",
+      "--fds-brand-alt3-500": "--ds-color-brand3-5",
+      "--fds-brand-alt3-600": "--ds-color-brand3-6",
+      "--fds-brand-alt3-700": "--ds-color-brand3-7",
+      "--fds-brand-alt3-800": "--ds-color-brand3-8",
+      "--fds-brand-alt3-900": "--ds-color-brand3-9"
+    })
+  ]
+});
+
+// src/migrations/codemods/jsx/run.ts
+import glob2 from "fast-glob";
+import { run as jscodeshift } from "jscodeshift/src/Runner.js";
+import chalk2 from "chalk";
+var transformer = `${import.meta.dirname}/classname-prefix.ts`;
+var runJSXCodemod = async ({ globPattern = "./**/*.tsx", dry }) => {
+  const options = {
+    dry,
+    extensions: "tsx",
+    parser: "tsx"
+  };
+  const transform = async () => {
+    const files = await glob2(globPattern, { ignore: ["node_modules/**", "dist/**"] });
+    const result = await jscodeshift(transformer, files, options);
+    if (result.ok) {
+      console.log(chalk2.green("Finished parsing"));
+    }
+  };
+  return transform();
+};
+
+// src/migrations/react-beta-to-v1.ts
+var react_beta_to_v1_default = (glob4) => runJSXCodemod({ globPattern: glob4 });
+
+// src/migrations/index.ts
+var migrations_default = {
+  "css-beta-to-v1": beta_to_v1_default,
+  "react-beta-to-v1": react_beta_to_v1_default
+};
+
+// src/tokens/build.ts
+import path from "path";
+import fs3 from "fs";
+import StyleDictionary2 from "style-dictionary";
+import * as R9 from "ramda";
+import chalk4 from "chalk";
+
+// src/tokens/configs.ts
+var configs_exports = {};
+__export(configs_exports, {
+  basePxFontSize: () => basePxFontSize,
+  colorModeVariables: () => colorModeVariables,
+  getConfigs: () => getConfigs,
+  permutateThemes: () => permutateThemes2,
+  prefix: () => prefix,
+  semanticVariables: () => semanticVariables,
+  separator: () => separator,
+  typescriptTokens: () => typescriptTokens,
+  typographyCSS: () => typographyCSS
+});
+import * as tokenStudio from "@tokens-studio/sd-transforms";
+import StyleDictionary from "style-dictionary";
+import { outputReferencesFilter } from "style-dictionary/utils";
+import * as R8 from "ramda";
+
+// src/tokens/utils/permutateThemes.ts
+import * as R2 from "ramda";
+
+// ../../node_modules/@tokens-studio/types/dist/constants/BoxShadowTypes.js
+var BoxShadowTypes;
+(function(BoxShadowTypes2) {
+  BoxShadowTypes2["DROP_SHADOW"] = "dropShadow";
+  BoxShadowTypes2["INNER_SHADOW"] = "innerShadow";
+})(BoxShadowTypes || (BoxShadowTypes = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/ColorModifierTypes.js
+var ColorModifierTypes;
+(function(ColorModifierTypes2) {
+  ColorModifierTypes2["LIGHTEN"] = "lighten";
+  ColorModifierTypes2["DARKEN"] = "darken";
+  ColorModifierTypes2["MIX"] = "mix";
+  ColorModifierTypes2["ALPHA"] = "alpha";
+})(ColorModifierTypes || (ColorModifierTypes = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/ColorSpaceTypes.js
+var ColorSpaceTypes;
+(function(ColorSpaceTypes2) {
+  ColorSpaceTypes2["LCH"] = "lch";
+  ColorSpaceTypes2["SRGB"] = "srgb";
+  ColorSpaceTypes2["P3"] = "p3";
+  ColorSpaceTypes2["HSL"] = "hsl";
+})(ColorSpaceTypes || (ColorSpaceTypes = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/Properties.js
+var Properties;
+(function(Properties2) {
+  Properties2["sizing"] = "sizing";
+  Properties2["height"] = "height";
+  Properties2["width"] = "width";
+  Properties2["spacing"] = "spacing";
+  Properties2["verticalPadding"] = "verticalPadding";
+  Properties2["horizontalPadding"] = "horizontalPadding";
+  Properties2["paddingTop"] = "paddingTop";
+  Properties2["paddingRight"] = "paddingRight";
+  Properties2["paddingBottom"] = "paddingBottom";
+  Properties2["paddingLeft"] = "paddingLeft";
+  Properties2["itemSpacing"] = "itemSpacing";
+  Properties2["fill"] = "fill";
+  Properties2["backgroundBlur"] = "backgroundBlur";
+  Properties2["border"] = "border";
+  Properties2["borderTop"] = "borderTop";
+  Properties2["borderRight"] = "borderRight";
+  Properties2["borderBottom"] = "borderBottom";
+  Properties2["borderLeft"] = "borderLeft";
+  Properties2["borderColor"] = "borderColor";
+  Properties2["borderRadius"] = "borderRadius";
+  Properties2["borderRadiusTopLeft"] = "borderRadiusTopLeft";
+  Properties2["borderRadiusTopRight"] = "borderRadiusTopRight";
+  Properties2["borderRadiusBottomRight"] = "borderRadiusBottomRight";
+  Properties2["borderRadiusBottomLeft"] = "borderRadiusBottomLeft";
+  Properties2["borderWidth"] = "borderWidth";
+  Properties2["borderWidthTop"] = "borderWidthTop";
+  Properties2["borderWidthRight"] = "borderWidthRight";
+  Properties2["borderWidthBottom"] = "borderWidthBottom";
+  Properties2["borderWidthLeft"] = "borderWidthLeft";
+  Properties2["boxShadow"] = "boxShadow";
+  Properties2["opacity"] = "opacity";
+  Properties2["fontFamilies"] = "fontFamilies";
+  Properties2["fontWeights"] = "fontWeights";
+  Properties2["fontSizes"] = "fontSizes";
+  Properties2["lineHeights"] = "lineHeights";
+  Properties2["typography"] = "typography";
+  Properties2["composition"] = "composition";
+  Properties2["letterSpacing"] = "letterSpacing";
+  Properties2["paragraphSpacing"] = "paragraphSpacing";
+  Properties2["textCase"] = "textCase";
+  Properties2["dimension"] = "dimension";
+  Properties2["textDecoration"] = "textDecoration";
+  Properties2["asset"] = "asset";
+  Properties2["tokenValue"] = "tokenValue";
+  Properties2["value"] = "value";
+  Properties2["tokenName"] = "tokenName";
+  Properties2["description"] = "description";
+})(Properties || (Properties = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/TokenSetStatus.js
+var TokenSetStatus;
+(function(TokenSetStatus2) {
+  TokenSetStatus2["DISABLED"] = "disabled";
+  TokenSetStatus2["SOURCE"] = "source";
+  TokenSetStatus2["ENABLED"] = "enabled";
+})(TokenSetStatus || (TokenSetStatus = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/TokenTypes.js
+var TokenTypes;
+(function(TokenTypes2) {
+  TokenTypes2["OTHER"] = "other";
+  TokenTypes2["COLOR"] = "color";
+  TokenTypes2["BORDER_RADIUS"] = "borderRadius";
+  TokenTypes2["SIZING"] = "sizing";
+  TokenTypes2["SPACING"] = "spacing";
+  TokenTypes2["TEXT"] = "text";
+  TokenTypes2["TYPOGRAPHY"] = "typography";
+  TokenTypes2["OPACITY"] = "opacity";
+  TokenTypes2["BORDER_WIDTH"] = "borderWidth";
+  TokenTypes2["STROKE_STYLE"] = "strokeStyle";
+  TokenTypes2["BOX_SHADOW"] = "boxShadow";
+  TokenTypes2["FONT_FAMILIES"] = "fontFamilies";
+  TokenTypes2["FONT_WEIGHTS"] = "fontWeights";
+  TokenTypes2["LINE_HEIGHTS"] = "lineHeights";
+  TokenTypes2["FONT_SIZES"] = "fontSizes";
+  TokenTypes2["LETTER_SPACING"] = "letterSpacing";
+  TokenTypes2["PARAGRAPH_SPACING"] = "paragraphSpacing";
+  TokenTypes2["PARAGRAPH_INDENT"] = "paragraphIndent";
+  TokenTypes2["TEXT_DECORATION"] = "textDecoration";
+  TokenTypes2["TEXT_CASE"] = "textCase";
+  TokenTypes2["COMPOSITION"] = "composition";
+  TokenTypes2["DIMENSION"] = "dimension";
+  TokenTypes2["BORDER"] = "border";
+  TokenTypes2["ASSET"] = "asset";
+  TokenTypes2["BOOLEAN"] = "boolean";
+  TokenTypes2["NUMBER"] = "number";
+})(TokenTypes || (TokenTypes = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/BorderValues.js
+var BorderValues;
+(function(BorderValues2) {
+  BorderValues2["BORDER_COLOR"] = "color";
+  BorderValues2["BORDER_WIDTH"] = "width";
+  BorderValues2["BORDER_STYLE"] = "style";
+})(BorderValues || (BorderValues = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/StrokeStyleValues.js
+var StrokeStyleValues;
+(function(StrokeStyleValues2) {
+  StrokeStyleValues2["SOLID"] = "solid";
+  StrokeStyleValues2["DASHED"] = "dashed";
+  StrokeStyleValues2["DOTTED"] = "dotted";
+  StrokeStyleValues2["DOUBLE"] = "double";
+  StrokeStyleValues2["GROOVE"] = "groove";
+  StrokeStyleValues2["RIDGE"] = "ridge";
+  StrokeStyleValues2["OUTSET"] = "outset";
+  StrokeStyleValues2["INSET"] = "inset";
+})(StrokeStyleValues || (StrokeStyleValues = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/BoxShadowValues.js
+var BoxShadowValues;
+(function(BoxShadowValues2) {
+  BoxShadowValues2["TYPE"] = "type";
+  BoxShadowValues2["COLOR"] = "color";
+  BoxShadowValues2["X"] = "x";
+  BoxShadowValues2["Y"] = "y";
+  BoxShadowValues2["BLUR"] = "blur";
+  BoxShadowValues2["SPREAD"] = "spread";
+  BoxShadowValues2["BLEND_MODE"] = "blendMode";
+})(BoxShadowValues || (BoxShadowValues = {}));
+
+// ../../node_modules/@tokens-studio/types/dist/constants/TypographyValues.js
+var TypographyValues;
+(function(TypographyValues2) {
+  TypographyValues2["FONT_FAMILY"] = "fontFamily";
+  TypographyValues2["FONT_WEIGHT"] = "fontWeight";
+  TypographyValues2["LINE_HEIGHT"] = "lineHeight";
+  TypographyValues2["FONT_SIZE"] = "fontSize";
+  TypographyValues2["LETTER_SPACING"] = "letterSpacing";
+  TypographyValues2["PARAGRAPH_SPACING"] = "paragraphSpacing";
+  TypographyValues2["PARAGRAPH_INDENT"] = "paragraphIndent";
+  TypographyValues2["TEXT_DECORATION"] = "textDecoration";
+  TypographyValues2["TEXT_CASE"] = "textCase";
+})(TypographyValues || (TypographyValues = {}));
+
+// src/tokens/utils/permutateThemes.ts
+function mapThemesToSetsObject(themes) {
+  return themes.map((theme) => ({ name: theme.name, selectedTokenSets: filterTokenSets(theme.selectedTokenSets) }));
+}
+function permutateThemes(themes, { separator: separator2 = "-" } = {}) {
+  if (!themes.some((theme) => theme.group)) {
+    return mapThemesToSetsObject(themes);
+  }
+  const groups = {};
+  themes.forEach((theme) => {
+    if (theme.group) {
+      groups[theme.group] = [...groups[theme.group] ?? [], theme];
+    } else {
+      throw new Error(
+        `Theme ${theme.name} does not have a group property, which is required for multi-dimensional theming.`
+      );
+    }
+  });
+  if (Object.keys(groups).length <= 1) {
+    return mapThemesToSetsObject(themes);
+  }
+  const permutations = cartesian(Object.values(groups));
+  const permutatedThemes = permutations.map((perm) => {
+    const permutatedTheme = perm.reduce(
+      (acc, theme) => {
+        const { group, name, selectedTokenSets } = theme;
+        let updatedPermutatedTheme = acc;
+        if (group) {
+          const groupProp = R2.lensProp(group.toLowerCase());
+          updatedPermutatedTheme = R2.set(groupProp, name.toLowerCase(), updatedPermutatedTheme);
+        }
+        const updatedName = `${String(acc.name)}${acc ? separator2 : ""}${name}`;
+        const sets = [...updatedPermutatedTheme.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];
+        return {
+          ...updatedPermutatedTheme,
+          name: updatedName,
+          selectedTokenSets: sets
+        };
+      },
+      { name: "", selectedTokenSets: [] }
+    );
+    const uniqueTokenSets = new Set(permutatedTheme.selectedTokenSets);
+    return { ...permutatedTheme, selectedTokenSets: Array.from(uniqueTokenSets) };
+  });
+  return permutatedThemes;
+}
+function filterTokenSets(tokensets) {
+  return Object.entries(tokensets).filter(([, val]) => val !== TokenSetStatus.DISABLED).sort((a, b) => {
+    if (a[1] === TokenSetStatus.SOURCE && b[1] === TokenSetStatus.ENABLED) {
+      return -1;
+    } else if (a[1] === TokenSetStatus.ENABLED && b[1] === TokenSetStatus.SOURCE) {
+      return 1;
+    }
+    return 0;
+  }).map((entry) => entry[0]);
+}
+function cartesian(a) {
+  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e].flat())));
+}
+
+// src/tokens/transformers.ts
+import * as R4 from "ramda";
+
+// src/tokens/utils/noCase.ts
+var lowerCase = (text = "") => text.toLowerCase();
+var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+function noCase(input, options = {}) {
+  const {
+    splitRegexp = DEFAULT_SPLIT_REGEXP,
+    stripRegexp = DEFAULT_STRIP_REGEXP,
+    transform = lowerCase,
+    delimiter = " "
+  } = options;
+  const result = replace(
+    replace(input, splitRegexp, "$1\0$2"),
+    stripRegexp,
+    "\0"
+  );
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0") start++;
+  while (result.charAt(end - 1) === "\0") end--;
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace(input, re, value) {
+  if (re instanceof RegExp) return input.replace(re, value);
+  return re.reduce((input2, re2) => input2.replace(re2, value), input);
+}
+
+// src/tokens/utils/utils.ts
+import * as R3 from "ramda";
+var getType = (token) => (token.$type ?? token.type) || "";
+var getValue = (token) => token.$value ?? token.value;
+var typeEquals = R3.curry((types, token) => {
+  if (R3.isNil(token)) {
+    return false;
+  }
+  return R3.includes(R3.toLower(getType(token)), R3.map(R3.toLower, Array.isArray(types) ? types : [types]));
+});
+
+// src/tokens/transformers.ts
+var isPx = R4.test(/\b\d+px\b/g);
+var sizeRem = {
+  name: "ds/size/toRem",
+  type: "value",
+  transitive: true,
+  filter: (token) => typeEquals(["sizing", "spacing", "borderRadius", "fontsizes"], token),
+  transform: (token, config) => {
+    const value = getValue(token);
+    if (isPx(value)) {
+      const baseFont = config.basePxFontSize || 16;
+      const size = parseInt(value);
+      if (size === 0) {
+        return "0";
+      }
+      return `${size / baseFont}rem`;
+    }
+    return value;
+  }
+};
+var nameKebab = {
+  name: "name/cti/hierarchical-kebab",
+  type: "name",
+  transform: (token, options) => {
+    return noCase([options?.prefix].concat(token.path).join("-"), {
+      delimiter: "-",
+      stripRegexp: /[^A-Z0-9_]+/gi
+    });
+  }
+};
+var typographyShorthand = {
+  name: "typography/shorthand",
+  type: "value",
+  transitive: true,
+  filter: (token) => token.type === "typography",
+  transform: (token) => {
+    const typography2 = getValue(token);
+    return `${typography2.fontWeight} ${typography2.fontSize}/${typography2.lineHeight} '${typography2.fontFamily}'`;
+  }
+};
+
+// src/tokens/formats/js-tokens.ts
+import * as R5 from "ramda";
+import { fileHeader, createPropertyFormatter } from "style-dictionary/utils";
+var groupByType = R5.groupBy((token) => getType(token));
+var removeUnwatedTokens = R5.filter(
+  (token) => !["fds-base_spacing", "fds-base_sizing"].includes(token.name)
+);
+var toCssVarName = R5.pipe(R5.split(":"), R5.head, R5.trim);
+var jsTokens = {
+  name: "ds/js-tokens",
+  format: async function({ dictionary, file }) {
+    const format = createPropertyFormatter({
+      dictionary,
+      format: "css"
+    });
+    const formatTokens = R5.map((token) => ({
+      ...token,
+      name: toCssVarName(format(token))
+    }));
+    const processTokens = R5.pipe(removeUnwatedTokens, formatTokens, groupByType);
+    const tokens = processTokens(dictionary.allTokens);
+    const content = Object.entries(tokens).map(
+      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
+`
+    ).join("\n");
+    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
+  }
+};
+
+// src/tokens/formats/css.ts
+import * as R6 from "ramda";
+import { fileHeader as fileHeader2, createPropertyFormatter as createPropertyFormatter2, usesReferences, getReferences } from "style-dictionary/utils";
+var prefersColorScheme = (mode, content) => `
+@media (prefers-color-scheme: ${mode}) {
+  [data-ds-color-mode="auto"] ${content}
+}
+`;
+var colormode = {
+  name: "ds/css-colormode",
+  format: async function({ dictionary, file, options, platform }) {
+    const { allTokens } = dictionary;
+    const { outputReferences } = options;
+    const { selector, mode, layer } = platform;
+    const mode_ = mode;
+    const header = await fileHeader2({ file });
+    const format = createPropertyFormatter2({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const content = `{
+${allTokens.map(format).join("\n")}
+}
+`;
+    const autoSelectorContent = ["light", "dark"].includes(mode_) ? prefersColorScheme(mode_, content) : "";
+    return header + `@layer ${layer} {
+${selector} ${content} ${autoSelectorContent}
+}
+`;
+  }
+};
+var calculatedVariable = R6.pipe(R6.split(/:(.*?);/g), (split3) => `${split3[0]}: calc(${R6.trim(split3[1])});`);
+var semantic = {
+  name: "ds/css-semantic",
+  format: async function({ dictionary, file, options, platform }) {
+    const { allTokens } = dictionary;
+    const { outputReferences } = options;
+    const { selector, isCalculatedToken, layer } = platform;
+    const header = await fileHeader2({ file });
+    const format = createPropertyFormatter2({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const formatTokens = R6.map((token) => {
+      const originalValue = getValue(token.original);
+      if (usesReferences(originalValue) && typeof outputReferences === "function" && outputReferences?.(token, { dictionary })) {
+        if (isCalculatedToken?.(token, options)) {
+          return calculatedVariable(format(token));
+        }
+      }
+      return format(token);
+    });
+    const formattedVariables = formatTokens(allTokens);
+    const content = `{
+${formattedVariables.join("\n")}
+}
+`;
+    return header + `@layer ${layer} {
+${selector} ${content}
+}
+`;
+  }
+};
+var sortByType = R6.sortBy((token) => token?.type === "typography");
+var getVariableName = R6.pipe(
+  R6.split(":"),
+  R6.head,
+  R6.defaultTo(""),
+  R6.trim,
+  (name) => `var(${name})`
+);
+var bemify = R6.pipe(
+  (path2) => {
+    const filteredPath = path2.filter((p) => p !== "typography");
+    const withPrefix = R6.concat([prefix], R6.remove(0, 0, filteredPath));
+    const [rest, last] = R6.splitAt(-1, withPrefix);
+    const className = `${rest.join("-")}--${R6.head(last)}`;
+    return className;
+  },
+  R6.trim,
+  R6.toLower
+);
+var classSelector = R6.pipe(R6.prop("path"), bemify);
+var sortTypographyLast = R6.sortWith([
+  R6.ascend((token) => typeEquals("typography")(token) ? 1 : 0)
+]);
+var typography = {
+  name: "ds/css-typography",
+  format: async function({ dictionary, file, options, platform }) {
+    const { outputReferences } = options;
+    const { selector, layer } = platform;
+    const header = await fileHeader2({ file });
+    const format = createPropertyFormatter2({
+      outputReferences,
+      dictionary,
+      format: "css"
+    });
+    const sortedTokens = sortTypographyLast(dictionary.allTokens);
+    const formattedTokens = R6.pipe(
+      sortByType,
+      R6.reduce(
+        (acc, token) => {
+          if (typeEquals("fontweights", token)) {
+            const className = `
+  .${classSelector(token)} {
+    font-weight: ${getValue(token)};
+  }`;
+            return {
+              ...acc,
+              variables: [...acc.variables, format(token)],
+              classes: [...acc.classes, className]
+            };
+          }
+          if (typeEquals("lineheights", token)) {
+            const className = `
+  .${classSelector(token)} {
+    line-height: ${getValue(token)};
+  }`;
+            return {
+              ...acc,
+              variables: [...acc.variables, format(token)],
+              classes: [...acc.classes, className]
+            };
+          }
+          if (typeEquals("typography", token)) {
+            const references = getReferences(getValue(token.original), dictionary.tokens);
+            const fontweight = R6.find(typeEquals(["fontweights"]))(references);
+            const lineheight = R6.find(typeEquals(["lineheights"]))(references);
+            const fontsize = R6.find(typeEquals(["fontsizes"]))(references);
+            const letterSpacing = R6.find(typeEquals(["letterSpacing"]))(references);
+            const fontSizeVar = fontsize ? getVariableName(format(fontsize)) : null;
+            const fontWeightVar = fontweight ? getVariableName(format(fontweight)) : null;
+            const lineheightVar = lineheight ? getVariableName(format(lineheight)) : null;
+            const letterSpacingVar = letterSpacing ? getVariableName(format(letterSpacing)) : null;
+            const className = `
+  .${classSelector(token)} {
+    ${fontSizeVar && `font-size: ${fontSizeVar};`}
+    ${lineheightVar && `line-height: ${lineheightVar};`}
+    ${fontWeightVar && `font-weight: ${fontWeightVar};`}
+    ${letterSpacingVar && `letter-spacing: ${letterSpacingVar};`}
+  }`;
+            return { ...acc, classes: [className, ...acc.classes] };
+          }
+          return { ...acc, variables: [...acc.variables, format(token)] };
+        },
+        { variables: [], classes: [] }
+      )
+    )(sortedTokens);
+    const classes = formattedTokens.classes.join("\n");
+    const variables = formattedTokens.variables.join("\n");
+    const content = selector ? `${selector} {
+${variables}
+${classes}
+}` : classes;
+    return header + `@layer ${layer} {
+${content}
+}
+`;
+  }
+};
+
+// src/tokens/actions.ts
+var import_fs_extra = __toESM(require_lib(), 1);
+import glob3 from "fast-glob";
+import chalk3 from "chalk";
+import * as R7 from "ramda";
+var sortLightmodeFirst = R7.sortWith([R7.descend(R7.includes("light")), R7.descend(R7.includes("secondary"))]);
+var makeEntryFile = {
+  name: "make_entryfile",
+  do: async function(dictionary, platform) {
+    const { outPath, theme, log } = platform;
+    const writePath = `${outPath}/${theme}.css`;
+    if (log?.verbosity !== "silent") {
+      console.log(chalk3.green(`Creating entry file: ${writePath}`));
+    }
+    const generateImportUrls = R7.pipe(
+      sortLightmodeFirst,
+      R7.map((file) => `@import url('./${theme}/${file.toString()}');`),
+      R7.join("\n")
+    );
+    const files = await glob3(`**/*`, { cwd: platform.buildPath });
+    const content = generateImportUrls(files);
+    await import_fs_extra.default.writeFile(writePath, content);
+  },
+  undo: async function noOp() {
+  }
+};
+
+// src/tokens/configs.ts
+void tokenStudio.registerTransforms(StyleDictionary);
+var prefix = "ds";
+var basePxFontSize = 16;
+var separator = "_";
+var fileHeader3 = () => [`These files are generated from design tokens defind using Token Studio`];
+StyleDictionary.registerTransform(sizeRem);
+StyleDictionary.registerTransform(nameKebab);
+StyleDictionary.registerTransform(typographyShorthand);
+StyleDictionary.registerFormat(jsTokens);
+StyleDictionary.registerFormat(colormode);
+StyleDictionary.registerFormat(semantic);
+StyleDictionary.registerFormat(typography);
+StyleDictionary.registerAction(makeEntryFile);
+var dsTransformers = [
+  nameKebab.name,
+  `ts/resolveMath`,
+  "ts/size/px",
+  sizeRem.name,
+  "ts/typography/fontWeight",
+  typographyShorthand.name,
+  "ts/color/modifiers",
+  "ts/color/css/hexrgba",
+  "ts/size/lineheight",
+  "ts/shadow/css/shorthand"
+];
+var paritionPrimitives = R8.partition(R8.test(/(?!.*global\.json).*primitives.*/));
+var hasUnknownProps = R8.pipe(R8.values, R8.none(R8.equals("unknown")), R8.not);
+var outputColorReferences = (token) => {
+  if (R8.test(/accent|neutral|brand1|brand2|brand3|success|danger|warning/, token.name) && R8.includes("semantic/color", token.filePath)) {
+    return true;
+  }
+  return false;
+};
+var permutateThemes2 = ($themes) => permutateThemes($themes, {
+  separator
+});
+var colorModeVariables = ({ mode = "light", outPath, theme }) => {
+  const selector = `${mode === "light" ? ":root, " : ""}[data-ds-color-mode="${mode}"]`;
+  const layer = `ds.theme.color.${mode}`;
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        outPath,
+        mode,
+        theme,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${outPath}/${theme}/`,
+        transforms: dsTransformers,
+        actions: [makeEntryFile.name],
+        files: [
+          {
+            destination: `color-mode/${mode}.css`,
+            format: colormode.name,
+            filter: (token) => !token.isSource && typeEquals("color", token)
+          }
+        ],
+        options: {
+          fileHeader: fileHeader3,
+          outputReferences: (token, options) => outputColorReferences(token) && outputReferencesFilter(token, options)
+        }
+      }
+    }
+  };
+};
+var semanticVariables = ({ outPath, theme }) => {
+  const selector = `:root`;
+  const layer = `ds.theme.semantic`;
+  const isCalculatedToken = (token) => typeEquals(["spacing", "sizing", "borderRadius"], token);
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        outPath,
+        theme,
+        basePxFontSize,
+        isCalculatedToken,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${outPath}/${theme}/`,
+        transforms: dsTransformers,
+        actions: [makeEntryFile.name],
+        files: [
+          {
+            destination: `semantic.css`,
+            format: semantic.name,
+            filter: (token) => (!token.isSource || isCalculatedToken(token)) && !typeEquals(["color", "fontWeights", "fontFamilies"], token)
+          }
+        ],
+        options: {
+          fileHeader: fileHeader3,
+          outputReferences: (token, options) => isCalculatedToken(token) && outputReferencesFilter(token, options)
+        }
+      }
+    }
+  };
+};
+var typescriptTokens = ({ mode = "unknown", outPath, theme }) => {
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      ts: {
+        prefix,
+        basePxFontSize,
+        transforms: dsTransformers,
+        buildPath: `${outPath}/${theme}/`,
+        files: [
+          {
+            destination: `${mode}.ts`,
+            format: jsTokens.name,
+            outputReferences: outputColorReferences,
+            filter: (token) => {
+              if (R8.test(/primitives\/modes|\/themes/, token.filePath)) {
+                return false;
+              }
+              if (R8.test(/accent|neutral|brand1|brand2|brand3|success|danger|warning/, token.name) || R8.includes("semantic", token.filePath)) {
+                return true;
+              }
+              return false;
+            }
+          }
+        ],
+        options: {
+          fileHeader: fileHeader3
+        }
+      }
+    }
+  };
+};
+var typographyCSS = ({ outPath, theme, typography: typography2 }) => {
+  const selector = `${typography2 === "primary" ? ":root, " : ""}[data-ds-typography="${typography2}"]`;
+  const layer = `ds.theme.typography.${typography2}`;
+  return {
+    log: { verbosity: "silent" },
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        prefix,
+        typography: typography2,
+        selector,
+        layer,
+        buildPath: `${outPath}/${theme}/`,
+        basePxFontSize,
+        transforms: [nameKebab.name, "ts/size/px", sizeRem.name, "ts/size/lineheight", "ts/typography/fontWeight"],
+        files: [
+          {
+            destination: `typography/${typography2}.css`,
+            format: typography.name,
+            filter: (token) => {
+              return typeEquals(
+                ["typography", "fontweights", "fontfamilies", "lineheights", "fontsizes", "letterSpacing"],
+                token
+              ) && !(token.path[0] || "").startsWith("theme");
+            }
+          }
+        ],
+        options: {
+          fileHeader: fileHeader3
+        }
+      }
+    }
+  };
+};
+var getConfigs = (getConfig, outPath, tokensDir, permutatedThemes) => permutatedThemes.map((permutatedTheme) => {
+  const {
+    selectedTokenSets = [],
+    mode = "unknown",
+    theme = "unknown",
+    semantic: semantic2 = "unknown",
+    size = "unknown",
+    typography: typography2 = "unknown"
+  } = permutatedTheme;
+  if (hasUnknownProps(permutatedTheme)) {
+    throw Error(`Theme ${permutatedTheme.name} has unknown props: ${JSON.stringify(permutatedTheme)}`);
+  }
+  const setsWithPaths = selectedTokenSets.map((x) => `${tokensDir}/${x}.json`);
+  const [source, include] = paritionPrimitives(setsWithPaths);
+  const config_ = getConfig({
+    outPath,
+    theme,
+    mode,
+    semantic: semantic2,
+    size,
+    typography: typography2
+  });
+  const config = {
+    ...config_,
+    source,
+    include
+  };
+  return { mode, theme, semantic: semantic2, size, typography: typography2, config };
+}).sort();
+
+// src/tokens/build.ts
+var { permutateThemes: permutateThemes3, getConfigs: getConfigs2 } = configs_exports;
+var sd = new StyleDictionary2();
+async function run(options) {
+  const tokensDir = options.tokens;
+  const storefrontOutDir = path.resolve("../../apps/storefront/tokens");
+  const tokensOutDir = path.resolve(options.out);
+  const $themes = JSON.parse(fs3.readFileSync(path.resolve(`${tokensDir}/$themes.json`), "utf-8"));
+  const relevant$themes = $themes.filter((theme) => {
+    const group = R9.toLower(R9.defaultTo("")(theme.group));
+    if (group === "size" && theme.name !== "default") return false;
+    return true;
+  });
+  const themes = permutateThemes3(relevant$themes);
+  const typographyThemes = R9.filter((val) => val.mode === "light", themes);
+  const colormodeThemes = R9.filter((val) => val.typography === "primary", themes);
+  const semanticThemes = R9.filter((val) => val.mode === "light" && val.typography === "primary", themes);
+  const colorModeConfigs = getConfigs2(colorModeVariables, tokensOutDir, tokensDir, colormodeThemes);
+  const semanticConfigs = getConfigs2(semanticVariables, tokensOutDir, tokensDir, semanticThemes);
+  const typographyConfigs = getConfigs2(typographyCSS, tokensOutDir, tokensDir, typographyThemes);
+  const storefrontConfigs = getConfigs2(typescriptTokens, storefrontOutDir, tokensDir, colormodeThemes);
+  if (typographyConfigs.length > 0) {
+    console.log(`
+\u{1F371} Building ${chalk4.green("typography")}`);
+    await Promise.all(
+      typographyConfigs.map(async ({ theme, typography: typography2, config }) => {
+        console.log(`\u{1F477} ${theme} - ${typography2}`);
+        const typographyClasses = await sd.extend(config);
+        return typographyClasses.buildAllPlatforms();
+      })
+    );
+  }
+  if (semanticConfigs.length > 0) {
+    console.log(`
+\u{1F371} Building ${chalk4.green("semantic")}`);
+    await Promise.all(
+      semanticConfigs.map(async ({ theme, config, semantic: semantic2 }) => {
+        console.log(`\u{1F477} ${theme} - ${semantic2}`);
+        const typographyClasses = await sd.extend(config);
+        return typographyClasses.buildAllPlatforms();
+      })
+    );
+  }
+  if (colorModeConfigs.length > 0) {
+    console.log(`
+\u{1F371} Building ${chalk4.green("color-mode")}`);
+    await Promise.all(
+      colorModeConfigs.map(async ({ theme, mode, config }) => {
+        console.log(`\u{1F477} ${theme} - ${mode}`);
+        const themeVariablesSD = await sd.extend(config);
+        return themeVariablesSD.buildAllPlatforms();
+      })
+    );
+  }
+  if (storefrontConfigs.length > 0 && options.preview) {
+    console.log(`
+\u{1F371} Building ${chalk4.green("Storefront preview tokens")}`);
+    await Promise.all(
+      storefrontConfigs.map(async ({ theme, mode, config }) => {
+        console.log(`\u{1F477} ${theme} - ${mode}`);
+        const storefrontSD = await sd.extend(config);
+        return storefrontSD.buildAllPlatforms();
+      })
+    );
+  }
+}
+
+// bin/designsystemet.ts
+program.name("Designsystemet").description("CLI for working with Designsystemet");
+program.command("tokens").showHelpAfterError().description("run Designsystemet token builder").option("-t, --tokens [string]", `Path to ${chalk5.blue("design-tokens")}`, "./design-tokens").option("-o, --out [string]", `Output directory for built ${chalk5.blue("design-tokens")}`, "./dist/tokens").option("-p, --preview", "Generate preview token.ts files", false).action((opts) => {
+  const tokens = typeof opts.tokens === "string" ? opts.tokens : "./design-tokens";
+  const out = typeof opts.out === "string" ? opts.out : "./dist/tokens";
+  const preview = opts.preview;
+  console.log(`Bulding tokens in ${chalk5.green(tokens)}`);
+  return run({ tokens, out, preview });
+});
+program.command("migrate").showHelpAfterError().description("run a Designsystemet migration").addArgument(new Argument("[migration]", "Available migrations").choices(Object.keys(migrations_default))).option("-l --list", "List available migrations").option("-g --glob <glob>", "Glob for files upon which to apply the migration", "./**/*.(tsx|css)").action((migrationKey, opts) => {
+  const { glob: glob4, list } = opts;
+  if (list) {
+    Object.keys(migrations_default).forEach((key) => {
+      console.log(key);
+    });
+  } else if (migrationKey) {
+    const migration = migrations_default[migrationKey];
+    if (!migration) {
+      console.error("Migration not found!");
+      throw "Aborting";
+    }
+    console.log(`Applying migration ${chalk5.blue(migrationKey)} with glob: ${chalk5.green(glob4)}`);
+    migration?.(glob4).then(() => console.log(`Migration ${chalk5.blue(migrationKey)} finished`)).catch((error) => console.log(error));
+  } else {
+    console.log("Migrate: please specify a migration name or --list");
+  }
+});
+await program.parseAsync(process.argv);
+//# sourceMappingURL=designsystemet.js.map