@dannote/figma-use 0.6.2 → 0.7.0

package/dist/cli/index.js

@@ -23858,12 +23858,14 @@ function serializeNode(node) {
     lines.push(`pos: ${node.x} ${node.y}`);
   }
   const fills = node.fills;
-  if (fills?.length && fills[0]?.type === "SOLID" && fills[0].color) {
-    lines.push(`fill: ${fills[0].color}`);
+  const firstFill = fills?.[0];
+  if (firstFill?.type === "SOLID" && firstFill.color) {
+    lines.push(`fill: ${firstFill.color}`);
   }
   const strokes = node.strokes;
-  if (strokes?.length && strokes[0]?.type === "SOLID" && strokes[0].color) {
-    lines.push(`stroke: ${strokes[0].color}`);
+  const firstStroke = strokes?.[0];
+  if (firstStroke?.type === "SOLID" && firstStroke.color) {
+    lines.push(`stroke: ${firstStroke.color}`);
   }
   if (node.strokeWeight !== undefined && node.strokeWeight !== 0) {
     lines.push(`strokeWeight: ${node.strokeWeight}`);
@@ -24370,6 +24372,2112 @@ ${oldContent.split(`
   });
 });
 
+// node_modules/pngjs/lib/chunkstream.js
+var require_chunkstream = __commonJS((exports, module) => {
+  var util = __require("util");
+  var Stream = __require("stream");
+  var ChunkStream = module.exports = function() {
+    Stream.call(this);
+    this._buffers = [];
+    this._buffered = 0;
+    this._reads = [];
+    this._paused = false;
+    this._encoding = "utf8";
+    this.writable = true;
+  };
+  util.inherits(ChunkStream, Stream);
+  ChunkStream.prototype.read = function(length, callback) {
+    this._reads.push({
+      length: Math.abs(length),
+      allowLess: length < 0,
+      func: callback
+    });
+    process.nextTick(function() {
+      this._process();
+      if (this._paused && this._reads && this._reads.length > 0) {
+        this._paused = false;
+        this.emit("drain");
+      }
+    }.bind(this));
+  };
+  ChunkStream.prototype.write = function(data, encoding) {
+    if (!this.writable) {
+      this.emit("error", new Error("Stream not writable"));
+      return false;
+    }
+    let dataBuffer;
+    if (Buffer.isBuffer(data)) {
+      dataBuffer = data;
+    } else {
+      dataBuffer = Buffer.from(data, encoding || this._encoding);
+    }
+    this._buffers.push(dataBuffer);
+    this._buffered += dataBuffer.length;
+    this._process();
+    if (this._reads && this._reads.length === 0) {
+      this._paused = true;
+    }
+    return this.writable && !this._paused;
+  };
+  ChunkStream.prototype.end = function(data, encoding) {
+    if (data) {
+      this.write(data, encoding);
+    }
+    this.writable = false;
+    if (!this._buffers) {
+      return;
+    }
+    if (this._buffers.length === 0) {
+      this._end();
+    } else {
+      this._buffers.push(null);
+      this._process();
+    }
+  };
+  ChunkStream.prototype.destroySoon = ChunkStream.prototype.end;
+  ChunkStream.prototype._end = function() {
+    if (this._reads.length > 0) {
+      this.emit("error", new Error("Unexpected end of input"));
+    }
+    this.destroy();
+  };
+  ChunkStream.prototype.destroy = function() {
+    if (!this._buffers) {
+      return;
+    }
+    this.writable = false;
+    this._reads = null;
+    this._buffers = null;
+    this.emit("close");
+  };
+  ChunkStream.prototype._processReadAllowingLess = function(read) {
+    this._reads.shift();
+    let smallerBuf = this._buffers[0];
+    if (smallerBuf.length > read.length) {
+      this._buffered -= read.length;
+      this._buffers[0] = smallerBuf.slice(read.length);
+      read.func.call(this, smallerBuf.slice(0, read.length));
+    } else {
+      this._buffered -= smallerBuf.length;
+      this._buffers.shift();
+      read.func.call(this, smallerBuf);
+    }
+  };
+  ChunkStream.prototype._processRead = function(read) {
+    this._reads.shift();
+    let pos = 0;
+    let count = 0;
+    let data = Buffer.alloc(read.length);
+    while (pos < read.length) {
+      let buf = this._buffers[count++];
+      let len = Math.min(buf.length, read.length - pos);
+      buf.copy(data, pos, 0, len);
+      pos += len;
+      if (len !== buf.length) {
+        this._buffers[--count] = buf.slice(len);
+      }
+    }
+    if (count > 0) {
+      this._buffers.splice(0, count);
+    }
+    this._buffered -= read.length;
+    read.func.call(this, data);
+  };
+  ChunkStream.prototype._process = function() {
+    try {
+      while (this._buffered > 0 && this._reads && this._reads.length > 0) {
+        let read = this._reads[0];
+        if (read.allowLess) {
+          this._processReadAllowingLess(read);
+        } else if (this._buffered >= read.length) {
+          this._processRead(read);
+        } else {
+          break;
+        }
+      }
+      if (this._buffers && !this.writable) {
+        this._end();
+      }
+    } catch (ex) {
+      this.emit("error", ex);
+    }
+  };
+});
+
+// node_modules/pngjs/lib/interlace.js
+var require_interlace = __commonJS((exports) => {
+  var imagePasses = [
+    {
+      x: [0],
+      y: [0]
+    },
+    {
+      x: [4],
+      y: [0]
+    },
+    {
+      x: [0, 4],
+      y: [4]
+    },
+    {
+      x: [2, 6],
+      y: [0, 4]
+    },
+    {
+      x: [0, 2, 4, 6],
+      y: [2, 6]
+    },
+    {
+      x: [1, 3, 5, 7],
+      y: [0, 2, 4, 6]
+    },
+    {
+      x: [0, 1, 2, 3, 4, 5, 6, 7],
+      y: [1, 3, 5, 7]
+    }
+  ];
+  exports.getImagePasses = function(width, height) {
+    let images = [];
+    let xLeftOver = width % 8;
+    let yLeftOver = height % 8;
+    let xRepeats = (width - xLeftOver) / 8;
+    let yRepeats = (height - yLeftOver) / 8;
+    for (let i3 = 0;i3 < imagePasses.length; i3++) {
+      let pass = imagePasses[i3];
+      let passWidth = xRepeats * pass.x.length;
+      let passHeight = yRepeats * pass.y.length;
+      for (let j = 0;j < pass.x.length; j++) {
+        if (pass.x[j] < xLeftOver) {
+          passWidth++;
+        } else {
+          break;
+        }
+      }
+      for (let j = 0;j < pass.y.length; j++) {
+        if (pass.y[j] < yLeftOver) {
+          passHeight++;
+        } else {
+          break;
+        }
+      }
+      if (passWidth > 0 && passHeight > 0) {
+        images.push({ width: passWidth, height: passHeight, index: i3 });
+      }
+    }
+    return images;
+  };
+  exports.getInterlaceIterator = function(width) {
+    return function(x3, y5, pass) {
+      let outerXLeftOver = x3 % imagePasses[pass].x.length;
+      let outerX = (x3 - outerXLeftOver) / imagePasses[pass].x.length * 8 + imagePasses[pass].x[outerXLeftOver];
+      let outerYLeftOver = y5 % imagePasses[pass].y.length;
+      let outerY = (y5 - outerYLeftOver) / imagePasses[pass].y.length * 8 + imagePasses[pass].y[outerYLeftOver];
+      return outerX * 4 + outerY * width * 4;
+    };
+  };
+});
+
+// node_modules/pngjs/lib/paeth-predictor.js
+var require_paeth_predictor = __commonJS((exports, module) => {
+  module.exports = function paethPredictor(left, above, upLeft) {
+    let paeth = left + above - upLeft;
+    let pLeft = Math.abs(paeth - left);
+    let pAbove = Math.abs(paeth - above);
+    let pUpLeft = Math.abs(paeth - upLeft);
+    if (pLeft <= pAbove && pLeft <= pUpLeft) {
+      return left;
+    }
+    if (pAbove <= pUpLeft) {
+      return above;
+    }
+    return upLeft;
+  };
+});
+
+// node_modules/pngjs/lib/filter-parse.js
+var require_filter_parse = __commonJS((exports, module) => {
+  var interlaceUtils = require_interlace();
+  var paethPredictor = require_paeth_predictor();
+  function getByteWidth(width, bpp, depth) {
+    let byteWidth = width * bpp;
+    if (depth !== 8) {
+      byteWidth = Math.ceil(byteWidth / (8 / depth));
+    }
+    return byteWidth;
+  }
+  var Filter = module.exports = function(bitmapInfo, dependencies) {
+    let width = bitmapInfo.width;
+    let height = bitmapInfo.height;
+    let interlace = bitmapInfo.interlace;
+    let bpp = bitmapInfo.bpp;
+    let depth = bitmapInfo.depth;
+    this.read = dependencies.read;
+    this.write = dependencies.write;
+    this.complete = dependencies.complete;
+    this._imageIndex = 0;
+    this._images = [];
+    if (interlace) {
+      let passes = interlaceUtils.getImagePasses(width, height);
+      for (let i3 = 0;i3 < passes.length; i3++) {
+        this._images.push({
+          byteWidth: getByteWidth(passes[i3].width, bpp, depth),
+          height: passes[i3].height,
+          lineIndex: 0
+        });
+      }
+    } else {
+      this._images.push({
+        byteWidth: getByteWidth(width, bpp, depth),
+        height,
+        lineIndex: 0
+      });
+    }
+    if (depth === 8) {
+      this._xComparison = bpp;
+    } else if (depth === 16) {
+      this._xComparison = bpp * 2;
+    } else {
+      this._xComparison = 1;
+    }
+  };
+  Filter.prototype.start = function() {
+    this.read(this._images[this._imageIndex].byteWidth + 1, this._reverseFilterLine.bind(this));
+  };
+  Filter.prototype._unFilterType1 = function(rawData, unfilteredLine, byteWidth) {
+    let xComparison = this._xComparison;
+    let xBiggerThan = xComparison - 1;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let rawByte = rawData[1 + x3];
+      let f1Left = x3 > xBiggerThan ? unfilteredLine[x3 - xComparison] : 0;
+      unfilteredLine[x3] = rawByte + f1Left;
+    }
+  };
+  Filter.prototype._unFilterType2 = function(rawData, unfilteredLine, byteWidth) {
+    let lastLine = this._lastLine;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let rawByte = rawData[1 + x3];
+      let f2Up = lastLine ? lastLine[x3] : 0;
+      unfilteredLine[x3] = rawByte + f2Up;
+    }
+  };
+  Filter.prototype._unFilterType3 = function(rawData, unfilteredLine, byteWidth) {
+    let xComparison = this._xComparison;
+    let xBiggerThan = xComparison - 1;
+    let lastLine = this._lastLine;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let rawByte = rawData[1 + x3];
+      let f3Up = lastLine ? lastLine[x3] : 0;
+      let f3Left = x3 > xBiggerThan ? unfilteredLine[x3 - xComparison] : 0;
+      let f3Add = Math.floor((f3Left + f3Up) / 2);
+      unfilteredLine[x3] = rawByte + f3Add;
+    }
+  };
+  Filter.prototype._unFilterType4 = function(rawData, unfilteredLine, byteWidth) {
+    let xComparison = this._xComparison;
+    let xBiggerThan = xComparison - 1;
+    let lastLine = this._lastLine;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let rawByte = rawData[1 + x3];
+      let f4Up = lastLine ? lastLine[x3] : 0;
+      let f4Left = x3 > xBiggerThan ? unfilteredLine[x3 - xComparison] : 0;
+      let f4UpLeft = x3 > xBiggerThan && lastLine ? lastLine[x3 - xComparison] : 0;
+      let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
+      unfilteredLine[x3] = rawByte + f4Add;
+    }
+  };
+  Filter.prototype._reverseFilterLine = function(rawData) {
+    let filter = rawData[0];
+    let unfilteredLine;
+    let currentImage = this._images[this._imageIndex];
+    let byteWidth = currentImage.byteWidth;
+    if (filter === 0) {
+      unfilteredLine = rawData.slice(1, byteWidth + 1);
+    } else {
+      unfilteredLine = Buffer.alloc(byteWidth);
+      switch (filter) {
+        case 1:
+          this._unFilterType1(rawData, unfilteredLine, byteWidth);
+          break;
+        case 2:
+          this._unFilterType2(rawData, unfilteredLine, byteWidth);
+          break;
+        case 3:
+          this._unFilterType3(rawData, unfilteredLine, byteWidth);
+          break;
+        case 4:
+          this._unFilterType4(rawData, unfilteredLine, byteWidth);
+          break;
+        default:
+          throw new Error("Unrecognised filter type - " + filter);
+      }
+    }
+    this.write(unfilteredLine);
+    currentImage.lineIndex++;
+    if (currentImage.lineIndex >= currentImage.height) {
+      this._lastLine = null;
+      this._imageIndex++;
+      currentImage = this._images[this._imageIndex];
+    } else {
+      this._lastLine = unfilteredLine;
+    }
+    if (currentImage) {
+      this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
+    } else {
+      this._lastLine = null;
+      this.complete();
+    }
+  };
+});
+
+// node_modules/pngjs/lib/filter-parse-async.js
+var require_filter_parse_async = __commonJS((exports, module) => {
+  var util = __require("util");
+  var ChunkStream = require_chunkstream();
+  var Filter = require_filter_parse();
+  var FilterAsync = module.exports = function(bitmapInfo) {
+    ChunkStream.call(this);
+    let buffers = [];
+    let that = this;
+    this._filter = new Filter(bitmapInfo, {
+      read: this.read.bind(this),
+      write: function(buffer) {
+        buffers.push(buffer);
+      },
+      complete: function() {
+        that.emit("complete", Buffer.concat(buffers));
+      }
+    });
+    this._filter.start();
+  };
+  util.inherits(FilterAsync, ChunkStream);
+});
+
+// node_modules/pngjs/lib/constants.js
+var require_constants = __commonJS((exports, module) => {
+  module.exports = {
+    PNG_SIGNATURE: [137, 80, 78, 71, 13, 10, 26, 10],
+    TYPE_IHDR: 1229472850,
+    TYPE_IEND: 1229278788,
+    TYPE_IDAT: 1229209940,
+    TYPE_PLTE: 1347179589,
+    TYPE_tRNS: 1951551059,
+    TYPE_gAMA: 1732332865,
+    COLORTYPE_GRAYSCALE: 0,
+    COLORTYPE_PALETTE: 1,
+    COLORTYPE_COLOR: 2,
+    COLORTYPE_ALPHA: 4,
+    COLORTYPE_PALETTE_COLOR: 3,
+    COLORTYPE_COLOR_ALPHA: 6,
+    COLORTYPE_TO_BPP_MAP: {
+      0: 1,
+      2: 3,
+      3: 1,
+      4: 2,
+      6: 4
+    },
+    GAMMA_DIVISION: 1e5
+  };
+});
+
+// node_modules/pngjs/lib/crc.js
+var require_crc = __commonJS((exports, module) => {
+  var crcTable = [];
+  (function() {
+    for (let i3 = 0;i3 < 256; i3++) {
+      let currentCrc = i3;
+      for (let j = 0;j < 8; j++) {
+        if (currentCrc & 1) {
+          currentCrc = 3988292384 ^ currentCrc >>> 1;
+        } else {
+          currentCrc = currentCrc >>> 1;
+        }
+      }
+      crcTable[i3] = currentCrc;
+    }
+  })();
+  var CrcCalculator = module.exports = function() {
+    this._crc = -1;
+  };
+  CrcCalculator.prototype.write = function(data) {
+    for (let i3 = 0;i3 < data.length; i3++) {
+      this._crc = crcTable[(this._crc ^ data[i3]) & 255] ^ this._crc >>> 8;
+    }
+    return true;
+  };
+  CrcCalculator.prototype.crc32 = function() {
+    return this._crc ^ -1;
+  };
+  CrcCalculator.crc32 = function(buf) {
+    let crc = -1;
+    for (let i3 = 0;i3 < buf.length; i3++) {
+      crc = crcTable[(crc ^ buf[i3]) & 255] ^ crc >>> 8;
+    }
+    return crc ^ -1;
+  };
+});
+
+// node_modules/pngjs/lib/parser.js
+var require_parser = __commonJS((exports, module) => {
+  var constants = require_constants();
+  var CrcCalculator = require_crc();
+  var Parser = module.exports = function(options, dependencies) {
+    this._options = options;
+    options.checkCRC = options.checkCRC !== false;
+    this._hasIHDR = false;
+    this._hasIEND = false;
+    this._emittedHeadersFinished = false;
+    this._palette = [];
+    this._colorType = 0;
+    this._chunks = {};
+    this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this);
+    this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this);
+    this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this);
+    this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this);
+    this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this);
+    this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this);
+    this.read = dependencies.read;
+    this.error = dependencies.error;
+    this.metadata = dependencies.metadata;
+    this.gamma = dependencies.gamma;
+    this.transColor = dependencies.transColor;
+    this.palette = dependencies.palette;
+    this.parsed = dependencies.parsed;
+    this.inflateData = dependencies.inflateData;
+    this.finished = dependencies.finished;
+    this.simpleTransparency = dependencies.simpleTransparency;
+    this.headersFinished = dependencies.headersFinished || function() {};
+  };
+  Parser.prototype.start = function() {
+    this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));
+  };
+  Parser.prototype._parseSignature = function(data) {
+    let signature = constants.PNG_SIGNATURE;
+    for (let i3 = 0;i3 < signature.length; i3++) {
+      if (data[i3] !== signature[i3]) {
+        this.error(new Error("Invalid file signature"));
+        return;
+      }
+    }
+    this.read(8, this._parseChunkBegin.bind(this));
+  };
+  Parser.prototype._parseChunkBegin = function(data) {
+    let length = data.readUInt32BE(0);
+    let type = data.readUInt32BE(4);
+    let name = "";
+    for (let i3 = 4;i3 < 8; i3++) {
+      name += String.fromCharCode(data[i3]);
+    }
+    let ancillary = Boolean(data[4] & 32);
+    if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
+      this.error(new Error("Expected IHDR on beggining"));
+      return;
+    }
+    this._crc = new CrcCalculator;
+    this._crc.write(Buffer.from(name));
+    if (this._chunks[type]) {
+      return this._chunks[type](length);
+    }
+    if (!ancillary) {
+      this.error(new Error("Unsupported critical chunk type " + name));
+      return;
+    }
+    this.read(length + 4, this._skipChunk.bind(this));
+  };
+  Parser.prototype._skipChunk = function() {
+    this.read(8, this._parseChunkBegin.bind(this));
+  };
+  Parser.prototype._handleChunkEnd = function() {
+    this.read(4, this._parseChunkEnd.bind(this));
+  };
+  Parser.prototype._parseChunkEnd = function(data) {
+    let fileCrc = data.readInt32BE(0);
+    let calcCrc = this._crc.crc32();
+    if (this._options.checkCRC && calcCrc !== fileCrc) {
+      this.error(new Error("Crc error - " + fileCrc + " - " + calcCrc));
+      return;
+    }
+    if (!this._hasIEND) {
+      this.read(8, this._parseChunkBegin.bind(this));
+    }
+  };
+  Parser.prototype._handleIHDR = function(length) {
+    this.read(length, this._parseIHDR.bind(this));
+  };
+  Parser.prototype._parseIHDR = function(data) {
+    this._crc.write(data);
+    let width = data.readUInt32BE(0);
+    let height = data.readUInt32BE(4);
+    let depth = data[8];
+    let colorType = data[9];
+    let compr = data[10];
+    let filter = data[11];
+    let interlace = data[12];
+    if (depth !== 8 && depth !== 4 && depth !== 2 && depth !== 1 && depth !== 16) {
+      this.error(new Error("Unsupported bit depth " + depth));
+      return;
+    }
+    if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {
+      this.error(new Error("Unsupported color type"));
+      return;
+    }
+    if (compr !== 0) {
+      this.error(new Error("Unsupported compression method"));
+      return;
+    }
+    if (filter !== 0) {
+      this.error(new Error("Unsupported filter method"));
+      return;
+    }
+    if (interlace !== 0 && interlace !== 1) {
+      this.error(new Error("Unsupported interlace method"));
+      return;
+    }
+    this._colorType = colorType;
+    let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
+    this._hasIHDR = true;
+    this.metadata({
+      width,
+      height,
+      depth,
+      interlace: Boolean(interlace),
+      palette: Boolean(colorType & constants.COLORTYPE_PALETTE),
+      color: Boolean(colorType & constants.COLORTYPE_COLOR),
+      alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),
+      bpp,
+      colorType
+    });
+    this._handleChunkEnd();
+  };
+  Parser.prototype._handlePLTE = function(length) {
+    this.read(length, this._parsePLTE.bind(this));
+  };
+  Parser.prototype._parsePLTE = function(data) {
+    this._crc.write(data);
+    let entries = Math.floor(data.length / 3);
+    for (let i3 = 0;i3 < entries; i3++) {
+      this._palette.push([data[i3 * 3], data[i3 * 3 + 1], data[i3 * 3 + 2], 255]);
+    }
+    this.palette(this._palette);
+    this._handleChunkEnd();
+  };
+  Parser.prototype._handleTRNS = function(length) {
+    this.simpleTransparency();
+    this.read(length, this._parseTRNS.bind(this));
+  };
+  Parser.prototype._parseTRNS = function(data) {
+    this._crc.write(data);
+    if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {
+      if (this._palette.length === 0) {
+        this.error(new Error("Transparency chunk must be after palette"));
+        return;
+      }
+      if (data.length > this._palette.length) {
+        this.error(new Error("More transparent colors than palette size"));
+        return;
+      }
+      for (let i3 = 0;i3 < data.length; i3++) {
+        this._palette[i3][3] = data[i3];
+      }
+      this.palette(this._palette);
+    }
+    if (this._colorType === constants.COLORTYPE_GRAYSCALE) {
+      this.transColor([data.readUInt16BE(0)]);
+    }
+    if (this._colorType === constants.COLORTYPE_COLOR) {
+      this.transColor([
+        data.readUInt16BE(0),
+        data.readUInt16BE(2),
+        data.readUInt16BE(4)
+      ]);
+    }
+    this._handleChunkEnd();
+  };
+  Parser.prototype._handleGAMA = function(length) {
+    this.read(length, this._parseGAMA.bind(this));
+  };
+  Parser.prototype._parseGAMA = function(data) {
+    this._crc.write(data);
+    this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);
+    this._handleChunkEnd();
+  };
+  Parser.prototype._handleIDAT = function(length) {
+    if (!this._emittedHeadersFinished) {
+      this._emittedHeadersFinished = true;
+      this.headersFinished();
+    }
+    this.read(-length, this._parseIDAT.bind(this, length));
+  };
+  Parser.prototype._parseIDAT = function(length, data) {
+    this._crc.write(data);
+    if (this._colorType === constants.COLORTYPE_PALETTE_COLOR && this._palette.length === 0) {
+      throw new Error("Expected palette not found");
+    }
+    this.inflateData(data);
+    let leftOverLength = length - data.length;
+    if (leftOverLength > 0) {
+      this._handleIDAT(leftOverLength);
+    } else {
+      this._handleChunkEnd();
+    }
+  };
+  Parser.prototype._handleIEND = function(length) {
+    this.read(length, this._parseIEND.bind(this));
+  };
+  Parser.prototype._parseIEND = function(data) {
+    this._crc.write(data);
+    this._hasIEND = true;
+    this._handleChunkEnd();
+    if (this.finished) {
+      this.finished();
+    }
+  };
+});
+
+// node_modules/pngjs/lib/bitmapper.js
+var require_bitmapper = __commonJS((exports) => {
+  var interlaceUtils = require_interlace();
+  var pixelBppMapper = [
+    function() {},
+    function(pxData, data, pxPos, rawPos) {
+      if (rawPos === data.length) {
+        throw new Error("Ran out of data");
+      }
+      let pixel = data[rawPos];
+      pxData[pxPos] = pixel;
+      pxData[pxPos + 1] = pixel;
+      pxData[pxPos + 2] = pixel;
+      pxData[pxPos + 3] = 255;
+    },
+    function(pxData, data, pxPos, rawPos) {
+      if (rawPos + 1 >= data.length) {
+        throw new Error("Ran out of data");
+      }
+      let pixel = data[rawPos];
+      pxData[pxPos] = pixel;
+      pxData[pxPos + 1] = pixel;
+      pxData[pxPos + 2] = pixel;
+      pxData[pxPos + 3] = data[rawPos + 1];
+    },
+    function(pxData, data, pxPos, rawPos) {
+      if (rawPos + 2 >= data.length) {
+        throw new Error("Ran out of data");
+      }
+      pxData[pxPos] = data[rawPos];
+      pxData[pxPos + 1] = data[rawPos + 1];
+      pxData[pxPos + 2] = data[rawPos + 2];
+      pxData[pxPos + 3] = 255;
+    },
+    function(pxData, data, pxPos, rawPos) {
+      if (rawPos + 3 >= data.length) {
+        throw new Error("Ran out of data");
+      }
+      pxData[pxPos] = data[rawPos];
+      pxData[pxPos + 1] = data[rawPos + 1];
+      pxData[pxPos + 2] = data[rawPos + 2];
+      pxData[pxPos + 3] = data[rawPos + 3];
+    }
+  ];
+  var pixelBppCustomMapper = [
+    function() {},
+    function(pxData, pixelData, pxPos, maxBit) {
+      let pixel = pixelData[0];
+      pxData[pxPos] = pixel;
+      pxData[pxPos + 1] = pixel;
+      pxData[pxPos + 2] = pixel;
+      pxData[pxPos + 3] = maxBit;
+    },
+    function(pxData, pixelData, pxPos) {
+      let pixel = pixelData[0];
+      pxData[pxPos] = pixel;
+      pxData[pxPos + 1] = pixel;
+      pxData[pxPos + 2] = pixel;
+      pxData[pxPos + 3] = pixelData[1];
+    },
+    function(pxData, pixelData, pxPos, maxBit) {
+      pxData[pxPos] = pixelData[0];
+      pxData[pxPos + 1] = pixelData[1];
+      pxData[pxPos + 2] = pixelData[2];
+      pxData[pxPos + 3] = maxBit;
+    },
+    function(pxData, pixelData, pxPos) {
+      pxData[pxPos] = pixelData[0];
+      pxData[pxPos + 1] = pixelData[1];
+      pxData[pxPos + 2] = pixelData[2];
+      pxData[pxPos + 3] = pixelData[3];
+    }
+  ];
+  function bitRetriever(data, depth) {
+    let leftOver = [];
+    let i3 = 0;
+    function split() {
+      if (i3 === data.length) {
+        throw new Error("Ran out of data");
+      }
+      let byte = data[i3];
+      i3++;
+      let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
+      switch (depth) {
+        default:
+          throw new Error("unrecognised depth");
+        case 16:
+          byte2 = data[i3];
+          i3++;
+          leftOver.push((byte << 8) + byte2);
+          break;
+        case 4:
+          byte2 = byte & 15;
+          byte1 = byte >> 4;
+          leftOver.push(byte1, byte2);
+          break;
+        case 2:
+          byte4 = byte & 3;
+          byte3 = byte >> 2 & 3;
+          byte2 = byte >> 4 & 3;
+          byte1 = byte >> 6 & 3;
+          leftOver.push(byte1, byte2, byte3, byte4);
+          break;
+        case 1:
+          byte8 = byte & 1;
+          byte7 = byte >> 1 & 1;
+          byte6 = byte >> 2 & 1;
+          byte5 = byte >> 3 & 1;
+          byte4 = byte >> 4 & 1;
+          byte3 = byte >> 5 & 1;
+          byte2 = byte >> 6 & 1;
+          byte1 = byte >> 7 & 1;
+          leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);
+          break;
+      }
+    }
+    return {
+      get: function(count) {
+        while (leftOver.length < count) {
+          split();
+        }
+        let returner = leftOver.slice(0, count);
+        leftOver = leftOver.slice(count);
+        return returner;
+      },
+      resetAfterLine: function() {
+        leftOver.length = 0;
+      },
+      end: function() {
+        if (i3 !== data.length) {
+          throw new Error("extra data found");
+        }
+      }
+    };
+  }
+  function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) {
+    let imageWidth = image.width;
+    let imageHeight = image.height;
+    let imagePass = image.index;
+    for (let y5 = 0;y5 < imageHeight; y5++) {
+      for (let x3 = 0;x3 < imageWidth; x3++) {
+        let pxPos = getPxPos(x3, y5, imagePass);
+        pixelBppMapper[bpp](pxData, data, pxPos, rawPos);
+        rawPos += bpp;
+      }
+    }
+    return rawPos;
+  }
+  function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) {
+    let imageWidth = image.width;
+    let imageHeight = image.height;
+    let imagePass = image.index;
+    for (let y5 = 0;y5 < imageHeight; y5++) {
+      for (let x3 = 0;x3 < imageWidth; x3++) {
+        let pixelData = bits.get(bpp);
+        let pxPos = getPxPos(x3, y5, imagePass);
+        pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
+      }
+      bits.resetAfterLine();
+    }
+  }
+  exports.dataToBitMap = function(data, bitmapInfo) {
+    let width = bitmapInfo.width;
+    let height = bitmapInfo.height;
+    let depth = bitmapInfo.depth;
+    let bpp = bitmapInfo.bpp;
+    let interlace = bitmapInfo.interlace;
+    let bits;
+    if (depth !== 8) {
+      bits = bitRetriever(data, depth);
+    }
+    let pxData;
+    if (depth <= 8) {
+      pxData = Buffer.alloc(width * height * 4);
+    } else {
+      pxData = new Uint16Array(width * height * 4);
+    }
+    let maxBit = Math.pow(2, depth) - 1;
+    let rawPos = 0;
+    let images;
+    let getPxPos;
+    if (interlace) {
+      images = interlaceUtils.getImagePasses(width, height);
+      getPxPos = interlaceUtils.getInterlaceIterator(width, height);
+    } else {
+      let nonInterlacedPxPos = 0;
+      getPxPos = function() {
+        let returner = nonInterlacedPxPos;
+        nonInterlacedPxPos += 4;
+        return returner;
+      };
+      images = [{ width, height }];
+    }
+    for (let imageIndex = 0;imageIndex < images.length; imageIndex++) {
+      if (depth === 8) {
+        rawPos = mapImage8Bit(images[imageIndex], pxData, getPxPos, bpp, data, rawPos);
+      } else {
+        mapImageCustomBit(images[imageIndex], pxData, getPxPos, bpp, bits, maxBit);
+      }
+    }
+    if (depth === 8) {
+      if (rawPos !== data.length) {
+        throw new Error("extra data found");
+      }
+    } else {
+      bits.end();
+    }
+    return pxData;
+  };
+});
+
+// node_modules/pngjs/lib/format-normaliser.js
+var require_format_normaliser = __commonJS((exports, module) => {
+  function dePalette(indata, outdata, width, height, palette) {
+    let pxPos = 0;
+    for (let y5 = 0;y5 < height; y5++) {
+      for (let x3 = 0;x3 < width; x3++) {
+        let color = palette[indata[pxPos]];
+        if (!color) {
+          throw new Error("index " + indata[pxPos] + " not in palette");
+        }
+        for (let i3 = 0;i3 < 4; i3++) {
+          outdata[pxPos + i3] = color[i3];
+        }
+        pxPos += 4;
+      }
+    }
+  }
+  function replaceTransparentColor(indata, outdata, width, height, transColor) {
+    let pxPos = 0;
+    for (let y5 = 0;y5 < height; y5++) {
+      for (let x3 = 0;x3 < width; x3++) {
+        let makeTrans = false;
+        if (transColor.length === 1) {
+          if (transColor[0] === indata[pxPos]) {
+            makeTrans = true;
+          }
+        } else if (transColor[0] === indata[pxPos] && transColor[1] === indata[pxPos + 1] && transColor[2] === indata[pxPos + 2]) {
+          makeTrans = true;
+        }
+        if (makeTrans) {
+          for (let i3 = 0;i3 < 4; i3++) {
+            outdata[pxPos + i3] = 0;
+          }
+        }
+        pxPos += 4;
+      }
+    }
+  }
+  function scaleDepth(indata, outdata, width, height, depth) {
+    let maxOutSample = 255;
+    let maxInSample = Math.pow(2, depth) - 1;
+    let pxPos = 0;
+    for (let y5 = 0;y5 < height; y5++) {
+      for (let x3 = 0;x3 < width; x3++) {
+        for (let i3 = 0;i3 < 4; i3++) {
+          outdata[pxPos + i3] = Math.floor(indata[pxPos + i3] * maxOutSample / maxInSample + 0.5);
+        }
+        pxPos += 4;
+      }
+    }
+  }
+  module.exports = function(indata, imageData, skipRescale = false) {
+    let depth = imageData.depth;
+    let width = imageData.width;
+    let height = imageData.height;
+    let colorType = imageData.colorType;
+    let transColor = imageData.transColor;
+    let palette = imageData.palette;
+    let outdata = indata;
+    if (colorType === 3) {
+      dePalette(indata, outdata, width, height, palette);
+    } else {
+      if (transColor) {
+        replaceTransparentColor(indata, outdata, width, height, transColor);
+      }
+      if (depth !== 8 && !skipRescale) {
+        if (depth === 16) {
+          outdata = Buffer.alloc(width * height * 4);
+        }
+        scaleDepth(indata, outdata, width, height, depth);
+      }
+    }
+    return outdata;
+  };
+});
+
+// node_modules/pngjs/lib/parser-async.js
+var require_parser_async = __commonJS((exports, module) => {
+  var util = __require("util");
+  var zlib = __require("zlib");
+  var ChunkStream = require_chunkstream();
+  var FilterAsync = require_filter_parse_async();
+  var Parser = require_parser();
+  var bitmapper = require_bitmapper();
+  var formatNormaliser = require_format_normaliser();
+  var ParserAsync = module.exports = function(options) {
+    ChunkStream.call(this);
+    this._parser = new Parser(options, {
+      read: this.read.bind(this),
+      error: this._handleError.bind(this),
+      metadata: this._handleMetaData.bind(this),
+      gamma: this.emit.bind(this, "gamma"),
+      palette: this._handlePalette.bind(this),
+      transColor: this._handleTransColor.bind(this),
+      finished: this._finished.bind(this),
+      inflateData: this._inflateData.bind(this),
+      simpleTransparency: this._simpleTransparency.bind(this),
+      headersFinished: this._headersFinished.bind(this)
+    });
+    this._options = options;
+    this.writable = true;
+    this._parser.start();
+  };
+  util.inherits(ParserAsync, ChunkStream);
+  ParserAsync.prototype._handleError = function(err) {
+    this.emit("error", err);
+    this.writable = false;
+    this.destroy();
+    if (this._inflate && this._inflate.destroy) {
+      this._inflate.destroy();
+    }
+    if (this._filter) {
+      this._filter.destroy();
+      this._filter.on("error", function() {});
+    }
+    this.errord = true;
+  };
+  ParserAsync.prototype._inflateData = function(data) {
+    if (!this._inflate) {
+      if (this._bitmapInfo.interlace) {
+        this._inflate = zlib.createInflate();
+        this._inflate.on("error", this.emit.bind(this, "error"));
+        this._filter.on("complete", this._complete.bind(this));
+        this._inflate.pipe(this._filter);
+      } else {
+        let rowSize = (this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7 >> 3) + 1;
+        let imageSize = rowSize * this._bitmapInfo.height;
+        let chunkSize = Math.max(imageSize, zlib.Z_MIN_CHUNK);
+        this._inflate = zlib.createInflate({ chunkSize });
+        let leftToInflate = imageSize;
+        let emitError = this.emit.bind(this, "error");
+        this._inflate.on("error", function(err) {
+          if (!leftToInflate) {
+            return;
+          }
+          emitError(err);
+        });
+        this._filter.on("complete", this._complete.bind(this));
+        let filterWrite = this._filter.write.bind(this._filter);
+        this._inflate.on("data", function(chunk) {
+          if (!leftToInflate) {
+            return;
+          }
+          if (chunk.length > leftToInflate) {
+            chunk = chunk.slice(0, leftToInflate);
+          }
+          leftToInflate -= chunk.length;
+          filterWrite(chunk);
+        });
+        this._inflate.on("end", this._filter.end.bind(this._filter));
+      }
+    }
+    this._inflate.write(data);
+  };
+  ParserAsync.prototype._handleMetaData = function(metaData) {
+    this._metaData = metaData;
+    this._bitmapInfo = Object.create(metaData);
+    this._filter = new FilterAsync(this._bitmapInfo);
+  };
+  ParserAsync.prototype._handleTransColor = function(transColor) {
+    this._bitmapInfo.transColor = transColor;
+  };
+  ParserAsync.prototype._handlePalette = function(palette) {
+    this._bitmapInfo.palette = palette;
+  };
+  ParserAsync.prototype._simpleTransparency = function() {
+    this._metaData.alpha = true;
+  };
+  ParserAsync.prototype._headersFinished = function() {
+    this.emit("metadata", this._metaData);
+  };
+  ParserAsync.prototype._finished = function() {
+    if (this.errord) {
+      return;
+    }
+    if (!this._inflate) {
+      this.emit("error", "No Inflate block");
+    } else {
+      this._inflate.end();
+    }
+  };
+  ParserAsync.prototype._complete = function(filteredData) {
+    if (this.errord) {
+      return;
+    }
+    let normalisedBitmapData;
+    try {
+      let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
+      normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo, this._options.skipRescale);
+      bitmapData = null;
+    } catch (ex) {
+      this._handleError(ex);
+      return;
+    }
+    this.emit("parsed", normalisedBitmapData);
+  };
+});
+
+// node_modules/pngjs/lib/bitpacker.js
+var require_bitpacker = __commonJS((exports, module) => {
+  var constants = require_constants();
+  module.exports = function(dataIn, width, height, options) {
+    let outHasAlpha = [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(options.colorType) !== -1;
+    if (options.colorType === options.inputColorType) {
+      let bigEndian = function() {
+        let buffer = new ArrayBuffer(2);
+        new DataView(buffer).setInt16(0, 256, true);
+        return new Int16Array(buffer)[0] !== 256;
+      }();
+      if (options.bitDepth === 8 || options.bitDepth === 16 && bigEndian) {
+        return dataIn;
+      }
+    }
+    let data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
+    let maxValue = 255;
+    let inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
+    if (inBpp === 4 && !options.inputHasAlpha) {
+      inBpp = 3;
+    }
+    let outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
+    if (options.bitDepth === 16) {
+      maxValue = 65535;
+      outBpp *= 2;
+    }
+    let outData = Buffer.alloc(width * height * outBpp);
+    let inIndex = 0;
+    let outIndex = 0;
+    let bgColor = options.bgColor || {};
+    if (bgColor.red === undefined) {
+      bgColor.red = maxValue;
+    }
+    if (bgColor.green === undefined) {
+      bgColor.green = maxValue;
+    }
+    if (bgColor.blue === undefined) {
+      bgColor.blue = maxValue;
+    }
+    function getRGBA() {
+      let red;
+      let green;
+      let blue;
+      let alpha = maxValue;
+      switch (options.inputColorType) {
+        case constants.COLORTYPE_COLOR_ALPHA:
+          alpha = data[inIndex + 3];
+          red = data[inIndex];
+          green = data[inIndex + 1];
+          blue = data[inIndex + 2];
+          break;
+        case constants.COLORTYPE_COLOR:
+          red = data[inIndex];
+          green = data[inIndex + 1];
+          blue = data[inIndex + 2];
+          break;
+        case constants.COLORTYPE_ALPHA:
+          alpha = data[inIndex + 1];
+          red = data[inIndex];
+          green = red;
+          blue = red;
+          break;
+        case constants.COLORTYPE_GRAYSCALE:
+          red = data[inIndex];
+          green = red;
+          blue = red;
+          break;
+        default:
+          throw new Error("input color type:" + options.inputColorType + " is not supported at present");
+      }
+      if (options.inputHasAlpha) {
+        if (!outHasAlpha) {
+          alpha /= maxValue;
+          red = Math.min(Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0), maxValue);
+          green = Math.min(Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0), maxValue);
+          blue = Math.min(Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0), maxValue);
+        }
+      }
+      return { red, green, blue, alpha };
+    }
+    for (let y5 = 0;y5 < height; y5++) {
+      for (let x3 = 0;x3 < width; x3++) {
+        let rgba = getRGBA(data, inIndex);
+        switch (options.colorType) {
+          case constants.COLORTYPE_COLOR_ALPHA:
+          case constants.COLORTYPE_COLOR:
+            if (options.bitDepth === 8) {
+              outData[outIndex] = rgba.red;
+              outData[outIndex + 1] = rgba.green;
+              outData[outIndex + 2] = rgba.blue;
+              if (outHasAlpha) {
+                outData[outIndex + 3] = rgba.alpha;
+              }
+            } else {
+              outData.writeUInt16BE(rgba.red, outIndex);
+              outData.writeUInt16BE(rgba.green, outIndex + 2);
+              outData.writeUInt16BE(rgba.blue, outIndex + 4);
+              if (outHasAlpha) {
+                outData.writeUInt16BE(rgba.alpha, outIndex + 6);
+              }
+            }
+            break;
+          case constants.COLORTYPE_ALPHA:
+          case constants.COLORTYPE_GRAYSCALE: {
+            let grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
+            if (options.bitDepth === 8) {
+              outData[outIndex] = grayscale;
+              if (outHasAlpha) {
+                outData[outIndex + 1] = rgba.alpha;
+              }
+            } else {
+              outData.writeUInt16BE(grayscale, outIndex);
+              if (outHasAlpha) {
+                outData.writeUInt16BE(rgba.alpha, outIndex + 2);
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error("unrecognised color Type " + options.colorType);
+        }
+        inIndex += inBpp;
+        outIndex += outBpp;
+      }
+    }
+    return outData;
+  };
+});
+
+// node_modules/pngjs/lib/filter-pack.js
+var require_filter_pack = __commonJS((exports, module) => {
+  var paethPredictor = require_paeth_predictor();
+  function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      rawData[rawPos + x3] = pxData[pxPos + x3];
+    }
+  }
+  function filterSumNone(pxData, pxPos, byteWidth) {
+    let sum = 0;
+    let length = pxPos + byteWidth;
+    for (let i3 = pxPos;i3 < length; i3++) {
+      sum += Math.abs(pxData[i3]);
+    }
+    return sum;
+  }
+  function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let val = pxData[pxPos + x3] - left;
+      rawData[rawPos + x3] = val;
+    }
+  }
+  function filterSumSub(pxData, pxPos, byteWidth, bpp) {
+    let sum = 0;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let val = pxData[pxPos + x3] - left;
+      sum += Math.abs(val);
+    }
+    return sum;
+  }
+  function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let up = pxPos > 0 ? pxData[pxPos + x3 - byteWidth] : 0;
+      let val = pxData[pxPos + x3] - up;
+      rawData[rawPos + x3] = val;
+    }
+  }
+  function filterSumUp(pxData, pxPos, byteWidth) {
+    let sum = 0;
+    let length = pxPos + byteWidth;
+    for (let x3 = pxPos;x3 < length; x3++) {
+      let up = pxPos > 0 ? pxData[x3 - byteWidth] : 0;
+      let val = pxData[x3] - up;
+      sum += Math.abs(val);
+    }
+    return sum;
+  }
+  function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let up = pxPos > 0 ? pxData[pxPos + x3 - byteWidth] : 0;
+      let val = pxData[pxPos + x3] - (left + up >> 1);
+      rawData[rawPos + x3] = val;
+    }
+  }
+  function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
+    let sum = 0;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let up = pxPos > 0 ? pxData[pxPos + x3 - byteWidth] : 0;
+      let val = pxData[pxPos + x3] - (left + up >> 1);
+      sum += Math.abs(val);
+    }
+    return sum;
+  }
+  function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let up = pxPos > 0 ? pxData[pxPos + x3 - byteWidth] : 0;
+      let upleft = pxPos > 0 && x3 >= bpp ? pxData[pxPos + x3 - (byteWidth + bpp)] : 0;
+      let val = pxData[pxPos + x3] - paethPredictor(left, up, upleft);
+      rawData[rawPos + x3] = val;
+    }
+  }
+  function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
+    let sum = 0;
+    for (let x3 = 0;x3 < byteWidth; x3++) {
+      let left = x3 >= bpp ? pxData[pxPos + x3 - bpp] : 0;
+      let up = pxPos > 0 ? pxData[pxPos + x3 - byteWidth] : 0;
+      let upleft = pxPos > 0 && x3 >= bpp ? pxData[pxPos + x3 - (byteWidth + bpp)] : 0;
+      let val = pxData[pxPos + x3] - paethPredictor(left, up, upleft);
+      sum += Math.abs(val);
+    }
+    return sum;
+  }
+  var filters = {
+    0: filterNone,
+    1: filterSub,
+    2: filterUp,
+    3: filterAvg,
+    4: filterPaeth
+  };
+  var filterSums = {
+    0: filterSumNone,
+    1: filterSumSub,
+    2: filterSumUp,
+    3: filterSumAvg,
+    4: filterSumPaeth
+  };
+  module.exports = function(pxData, width, height, options, bpp) {
+    let filterTypes;
+    if (!("filterType" in options) || options.filterType === -1) {
+      filterTypes = [0, 1, 2, 3, 4];
+    } else if (typeof options.filterType === "number") {
+      filterTypes = [options.filterType];
+    } else {
+      throw new Error("unrecognised filter types");
+    }
+    if (options.bitDepth === 16) {
+      bpp *= 2;
+    }
+    let byteWidth = width * bpp;
+    let rawPos = 0;
+    let pxPos = 0;
+    let rawData = Buffer.alloc((byteWidth + 1) * height);
+    let sel = filterTypes[0];
+    for (let y5 = 0;y5 < height; y5++) {
+      if (filterTypes.length > 1) {
+        let min = Infinity;
+        for (let i3 = 0;i3 < filterTypes.length; i3++) {
+          let sum = filterSums[filterTypes[i3]](pxData, pxPos, byteWidth, bpp);
+          if (sum < min) {
+            sel = filterTypes[i3];
+            min = sum;
+          }
+        }
+      }
+      rawData[rawPos] = sel;
+      rawPos++;
+      filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);
+      rawPos += byteWidth;
+      pxPos += byteWidth;
+    }
+    return rawData;
+  };
+});
+
+// node_modules/pngjs/lib/packer.js
+var require_packer = __commonJS((exports, module) => {
+  var constants = require_constants();
+  var CrcStream = require_crc();
+  var bitPacker = require_bitpacker();
+  var filter = require_filter_pack();
+  var zlib = __require("zlib");
+  var Packer = module.exports = function(options) {
+    this._options = options;
+    options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;
+    options.deflateLevel = options.deflateLevel != null ? options.deflateLevel : 9;
+    options.deflateStrategy = options.deflateStrategy != null ? options.deflateStrategy : 3;
+    options.inputHasAlpha = options.inputHasAlpha != null ? options.inputHasAlpha : true;
+    options.deflateFactory = options.deflateFactory || zlib.createDeflate;
+    options.bitDepth = options.bitDepth || 8;
+    options.colorType = typeof options.colorType === "number" ? options.colorType : constants.COLORTYPE_COLOR_ALPHA;
+    options.inputColorType = typeof options.inputColorType === "number" ? options.inputColorType : constants.COLORTYPE_COLOR_ALPHA;
+    if ([
+      constants.COLORTYPE_GRAYSCALE,
+      constants.COLORTYPE_COLOR,
+      constants.COLORTYPE_COLOR_ALPHA,
+      constants.COLORTYPE_ALPHA
+    ].indexOf(options.colorType) === -1) {
+      throw new Error("option color type:" + options.colorType + " is not supported at present");
+    }
+    if ([
+      constants.COLORTYPE_GRAYSCALE,
+      constants.COLORTYPE_COLOR,
+      constants.COLORTYPE_COLOR_ALPHA,
+      constants.COLORTYPE_ALPHA
+    ].indexOf(options.inputColorType) === -1) {
+      throw new Error("option input color type:" + options.inputColorType + " is not supported at present");
+    }
+    if (options.bitDepth !== 8 && options.bitDepth !== 16) {
+      throw new Error("option bit depth:" + options.bitDepth + " is not supported at present");
+    }
+  };
+  Packer.prototype.getDeflateOptions = function() {
+    return {
+      chunkSize: this._options.deflateChunkSize,
+      level: this._options.deflateLevel,
+      strategy: this._options.deflateStrategy
+    };
+  };
+  Packer.prototype.createDeflate = function() {
+    return this._options.deflateFactory(this.getDeflateOptions());
+  };
+  Packer.prototype.filterData = function(data, width, height) {
+    let packedData = bitPacker(data, width, height, this._options);
+    let bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
+    let filteredData = filter(packedData, width, height, this._options, bpp);
+    return filteredData;
+  };
+  Packer.prototype._packChunk = function(type, data) {
+    let len = data ? data.length : 0;
+    let buf = Buffer.alloc(len + 12);
+    buf.writeUInt32BE(len, 0);
+    buf.writeUInt32BE(type, 4);
+    if (data) {
+      data.copy(buf, 8);
+    }
+    buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);
+    return buf;
+  };
+  Packer.prototype.packGAMA = function(gamma4) {
+    let buf = Buffer.alloc(4);
+    buf.writeUInt32BE(Math.floor(gamma4 * constants.GAMMA_DIVISION), 0);
+    return this._packChunk(constants.TYPE_gAMA, buf);
+  };
+  Packer.prototype.packIHDR = function(width, height) {
+    let buf = Buffer.alloc(13);
+    buf.writeUInt32BE(width, 0);
+    buf.writeUInt32BE(height, 4);
+    buf[8] = this._options.bitDepth;
+    buf[9] = this._options.colorType;
+    buf[10] = 0;
+    buf[11] = 0;
+    buf[12] = 0;
+    return this._packChunk(constants.TYPE_IHDR, buf);
+  };
+  Packer.prototype.packIDAT = function(data) {
+    return this._packChunk(constants.TYPE_IDAT, data);
+  };
+  Packer.prototype.packIEND = function() {
+    return this._packChunk(constants.TYPE_IEND, null);
+  };
+});
+
+// node_modules/pngjs/lib/packer-async.js
+var require_packer_async = __commonJS((exports, module) => {
+  var util = __require("util");
+  var Stream = __require("stream");
+  var constants = require_constants();
+  var Packer = require_packer();
+  var PackerAsync = module.exports = function(opt) {
+    Stream.call(this);
+    let options = opt || {};
+    this._packer = new Packer(options);
+    this._deflate = this._packer.createDeflate();
+    this.readable = true;
+  };
+  util.inherits(PackerAsync, Stream);
+  PackerAsync.prototype.pack = function(data, width, height, gamma4) {
+    this.emit("data", Buffer.from(constants.PNG_SIGNATURE));
+    this.emit("data", this._packer.packIHDR(width, height));
+    if (gamma4) {
+      this.emit("data", this._packer.packGAMA(gamma4));
+    }
+    let filteredData = this._packer.filterData(data, width, height);
+    this._deflate.on("error", this.emit.bind(this, "error"));
+    this._deflate.on("data", function(compressedData) {
+      this.emit("data", this._packer.packIDAT(compressedData));
+    }.bind(this));
+    this._deflate.on("end", function() {
+      this.emit("data", this._packer.packIEND());
+      this.emit("end");
+    }.bind(this));
+    this._deflate.end(filteredData);
+  };
+});
+
+// node_modules/pngjs/lib/sync-inflate.js
+var require_sync_inflate = __commonJS((exports, module) => {
+  var assert = __require("assert").ok;
+  var zlib = __require("zlib");
+  var util = __require("util");
+  var kMaxLength = __require("buffer").kMaxLength;
+  function Inflate(opts) {
+    if (!(this instanceof Inflate)) {
+      return new Inflate(opts);
+    }
+    if (opts && opts.chunkSize < zlib.Z_MIN_CHUNK) {
+      opts.chunkSize = zlib.Z_MIN_CHUNK;
+    }
+    zlib.Inflate.call(this, opts);
+    this._offset = this._offset === undefined ? this._outOffset : this._offset;
+    this._buffer = this._buffer || this._outBuffer;
+    if (opts && opts.maxLength != null) {
+      this._maxLength = opts.maxLength;
+    }
+  }
+  function createInflate(opts) {
+    return new Inflate(opts);
+  }
+  function _close(engine, callback) {
+    if (callback) {
+      process.nextTick(callback);
+    }
+    if (!engine._handle) {
+      return;
+    }
+    engine._handle.close();
+    engine._handle = null;
+  }
+  Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
+    if (typeof asyncCb === "function") {
+      return zlib.Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);
+    }
+    let self = this;
+    let availInBefore = chunk && chunk.length;
+    let availOutBefore = this._chunkSize - this._offset;
+    let leftToInflate = this._maxLength;
+    let inOff = 0;
+    let buffers = [];
+    let nread = 0;
+    let error;
+    this.on("error", function(err) {
+      error = err;
+    });
+    function handleChunk(availInAfter, availOutAfter) {
+      if (self._hadError) {
+        return;
+      }
+      let have = availOutBefore - availOutAfter;
+      assert(have >= 0, "have should not go down");
+      if (have > 0) {
+        let out = self._buffer.slice(self._offset, self._offset + have);
+        self._offset += have;
+        if (out.length > leftToInflate) {
+          out = out.slice(0, leftToInflate);
+        }
+        buffers.push(out);
+        nread += out.length;
+        leftToInflate -= out.length;
+        if (leftToInflate === 0) {
+          return false;
+        }
+      }
+      if (availOutAfter === 0 || self._offset >= self._chunkSize) {
+        availOutBefore = self._chunkSize;
+        self._offset = 0;
+        self._buffer = Buffer.allocUnsafe(self._chunkSize);
+      }
+      if (availOutAfter === 0) {
+        inOff += availInBefore - availInAfter;
+        availInBefore = availInAfter;
+        return true;
+      }
+      return false;
+    }
+    assert(this._handle, "zlib binding closed");
+    let res;
+    do {
+      res = this._handle.writeSync(flushFlag, chunk, inOff, availInBefore, this._buffer, this._offset, availOutBefore);
+      res = res || this._writeState;
+    } while (!this._hadError && handleChunk(res[0], res[1]));
+    if (this._hadError) {
+      throw error;
+    }
+    if (nread >= kMaxLength) {
+      _close(this);
+      throw new RangeError("Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + " bytes");
+    }
+    let buf = Buffer.concat(buffers, nread);
+    _close(this);
+    return buf;
+  };
+  util.inherits(Inflate, zlib.Inflate);
+  function zlibBufferSync(engine, buffer) {
+    if (typeof buffer === "string") {
+      buffer = Buffer.from(buffer);
+    }
+    if (!(buffer instanceof Buffer)) {
+      throw new TypeError("Not a string or buffer");
+    }
+    let flushFlag = engine._finishFlushFlag;
+    if (flushFlag == null) {
+      flushFlag = zlib.Z_FINISH;
+    }
+    return engine._processChunk(buffer, flushFlag);
+  }
+  function inflateSync(buffer, opts) {
+    return zlibBufferSync(new Inflate(opts), buffer);
+  }
+  module.exports = exports = inflateSync;
+  exports.Inflate = Inflate;
+  exports.createInflate = createInflate;
+  exports.inflateSync = inflateSync;
+});
+
+// node_modules/pngjs/lib/sync-reader.js
+var require_sync_reader = __commonJS((exports, module) => {
+  var SyncReader = module.exports = function(buffer) {
+    this._buffer = buffer;
+    this._reads = [];
+  };
+  SyncReader.prototype.read = function(length, callback) {
+    this._reads.push({
+      length: Math.abs(length),
+      allowLess: length < 0,
+      func: callback
+    });
+  };
+  SyncReader.prototype.process = function() {
+    while (this._reads.length > 0 && this._buffer.length) {
+      let read = this._reads[0];
+      if (this._buffer.length && (this._buffer.length >= read.length || read.allowLess)) {
+        this._reads.shift();
+        let buf = this._buffer;
+        this._buffer = buf.slice(read.length);
+        read.func.call(this, buf.slice(0, read.length));
+      } else {
+        break;
+      }
+    }
+    if (this._reads.length > 0) {
+      throw new Error("There are some read requests waitng on finished stream");
+    }
+    if (this._buffer.length > 0) {
+      throw new Error("unrecognised content at end of stream");
+    }
+  };
+});
+
+// node_modules/pngjs/lib/filter-parse-sync.js
+var require_filter_parse_sync = __commonJS((exports) => {
+  var SyncReader = require_sync_reader();
+  var Filter = require_filter_parse();
+  exports.process = function(inBuffer, bitmapInfo) {
+    let outBuffers = [];
+    let reader = new SyncReader(inBuffer);
+    let filter = new Filter(bitmapInfo, {
+      read: reader.read.bind(reader),
+      write: function(bufferPart) {
+        outBuffers.push(bufferPart);
+      },
+      complete: function() {}
+    });
+    filter.start();
+    reader.process();
+    return Buffer.concat(outBuffers);
+  };
+});
+
+// node_modules/pngjs/lib/parser-sync.js
+var require_parser_sync = __commonJS((exports, module) => {
+  var hasSyncZlib = true;
+  var zlib = __require("zlib");
+  var inflateSync = require_sync_inflate();
+  if (!zlib.deflateSync) {
+    hasSyncZlib = false;
+  }
+  var SyncReader = require_sync_reader();
+  var FilterSync = require_filter_parse_sync();
+  var Parser = require_parser();
+  var bitmapper = require_bitmapper();
+  var formatNormaliser = require_format_normaliser();
+  module.exports = function(buffer, options) {
+    if (!hasSyncZlib) {
+      throw new Error("To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0");
+    }
+    let err;
+    function handleError2(_err_) {
+      err = _err_;
+    }
+    let metaData;
+    function handleMetaData(_metaData_) {
+      metaData = _metaData_;
+    }
+    function handleTransColor(transColor) {
+      metaData.transColor = transColor;
+    }
+    function handlePalette(palette) {
+      metaData.palette = palette;
+    }
+    function handleSimpleTransparency() {
+      metaData.alpha = true;
+    }
+    let gamma4;
+    function handleGamma(_gamma_) {
+      gamma4 = _gamma_;
+    }
+    let inflateDataList = [];
+    function handleInflateData(inflatedData2) {
+      inflateDataList.push(inflatedData2);
+    }
+    let reader = new SyncReader(buffer);
+    let parser = new Parser(options, {
+      read: reader.read.bind(reader),
+      error: handleError2,
+      metadata: handleMetaData,
+      gamma: handleGamma,
+      palette: handlePalette,
+      transColor: handleTransColor,
+      inflateData: handleInflateData,
+      simpleTransparency: handleSimpleTransparency
+    });
+    parser.start();
+    reader.process();
+    if (err) {
+      throw err;
+    }
+    let inflateData = Buffer.concat(inflateDataList);
+    inflateDataList.length = 0;
+    let inflatedData;
+    if (metaData.interlace) {
+      inflatedData = zlib.inflateSync(inflateData);
+    } else {
+      let rowSize = (metaData.width * metaData.bpp * metaData.depth + 7 >> 3) + 1;
+      let imageSize = rowSize * metaData.height;
+      inflatedData = inflateSync(inflateData, {
+        chunkSize: imageSize,
+        maxLength: imageSize
+      });
+    }
+    inflateData = null;
+    if (!inflatedData || !inflatedData.length) {
+      throw new Error("bad png - invalid inflate data response");
+    }
+    let unfilteredData = FilterSync.process(inflatedData, metaData);
+    inflateData = null;
+    let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
+    unfilteredData = null;
+    let normalisedBitmapData = formatNormaliser(bitmapData, metaData, options.skipRescale);
+    metaData.data = normalisedBitmapData;
+    metaData.gamma = gamma4 || 0;
+    return metaData;
+  };
+});
+
+// node_modules/pngjs/lib/packer-sync.js
+var require_packer_sync = __commonJS((exports, module) => {
+  var hasSyncZlib = true;
+  var zlib = __require("zlib");
+  if (!zlib.deflateSync) {
+    hasSyncZlib = false;
+  }
+  var constants = require_constants();
+  var Packer = require_packer();
+  module.exports = function(metaData, opt) {
+    if (!hasSyncZlib) {
+      throw new Error("To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0");
+    }
+    let options = opt || {};
+    let packer = new Packer(options);
+    let chunks = [];
+    chunks.push(Buffer.from(constants.PNG_SIGNATURE));
+    chunks.push(packer.packIHDR(metaData.width, metaData.height));
+    if (metaData.gamma) {
+      chunks.push(packer.packGAMA(metaData.gamma));
+    }
+    let filteredData = packer.filterData(metaData.data, metaData.width, metaData.height);
+    let compressedData = zlib.deflateSync(filteredData, packer.getDeflateOptions());
+    filteredData = null;
+    if (!compressedData || !compressedData.length) {
+      throw new Error("bad png - invalid compressed data response");
+    }
+    chunks.push(packer.packIDAT(compressedData));
+    chunks.push(packer.packIEND());
+    return Buffer.concat(chunks);
+  };
+});
+
+// node_modules/pngjs/lib/png-sync.js
+var require_png_sync = __commonJS((exports) => {
+  var parse2 = require_parser_sync();
+  var pack = require_packer_sync();
+  exports.read = function(buffer, options) {
+    return parse2(buffer, options || {});
+  };
+  exports.write = function(png, options) {
+    return pack(png, options);
+  };
+});
+
+// node_modules/pngjs/lib/png.js
+var require_png = __commonJS((exports) => {
+  var util = __require("util");
+  var Stream = __require("stream");
+  var Parser = require_parser_async();
+  var Packer = require_packer_async();
+  var PNGSync = require_png_sync();
+  var PNG = exports.PNG = function(options) {
+    Stream.call(this);
+    options = options || {};
+    this.width = options.width | 0;
+    this.height = options.height | 0;
+    this.data = this.width > 0 && this.height > 0 ? Buffer.alloc(4 * this.width * this.height) : null;
+    if (options.fill && this.data) {
+      this.data.fill(0);
+    }
+    this.gamma = 0;
+    this.readable = this.writable = true;
+    this._parser = new Parser(options);
+    this._parser.on("error", this.emit.bind(this, "error"));
+    this._parser.on("close", this._handleClose.bind(this));
+    this._parser.on("metadata", this._metadata.bind(this));
+    this._parser.on("gamma", this._gamma.bind(this));
+    this._parser.on("parsed", function(data) {
+      this.data = data;
+      this.emit("parsed", data);
+    }.bind(this));
+    this._packer = new Packer(options);
+    this._packer.on("data", this.emit.bind(this, "data"));
+    this._packer.on("end", this.emit.bind(this, "end"));
+    this._parser.on("close", this._handleClose.bind(this));
+    this._packer.on("error", this.emit.bind(this, "error"));
+  };
+  util.inherits(PNG, Stream);
+  PNG.sync = PNGSync;
+  PNG.prototype.pack = function() {
+    if (!this.data || !this.data.length) {
+      this.emit("error", "No data provided");
+      return this;
+    }
+    process.nextTick(function() {
+      this._packer.pack(this.data, this.width, this.height, this.gamma);
+    }.bind(this));
+    return this;
+  };
+  PNG.prototype.parse = function(data, callback) {
+    if (callback) {
+      let onParsed, onError;
+      onParsed = function(parsedData) {
+        this.removeListener("error", onError);
+        this.data = parsedData;
+        callback(null, this);
+      }.bind(this);
+      onError = function(err) {
+        this.removeListener("parsed", onParsed);
+        callback(err, null);
+      }.bind(this);
+      this.once("parsed", onParsed);
+      this.once("error", onError);
+    }
+    this.end(data);
+    return this;
+  };
+  PNG.prototype.write = function(data) {
+    this._parser.write(data);
+    return true;
+  };
+  PNG.prototype.end = function(data) {
+    this._parser.end(data);
+  };
+  PNG.prototype._metadata = function(metadata) {
+    this.width = metadata.width;
+    this.height = metadata.height;
+    this.emit("metadata", metadata);
+  };
+  PNG.prototype._gamma = function(gamma4) {
+    this.gamma = gamma4;
+  };
+  PNG.prototype._handleClose = function() {
+    if (!this._parser.writable && !this._packer.readable) {
+      this.emit("close");
+    }
+  };
+  PNG.bitblt = function(src3, dst, srcX, srcY, width, height, deltaX, deltaY) {
+    srcX |= 0;
+    srcY |= 0;
+    width |= 0;
+    height |= 0;
+    deltaX |= 0;
+    deltaY |= 0;
+    if (srcX > src3.width || srcY > src3.height || srcX + width > src3.width || srcY + height > src3.height) {
+      throw new Error("bitblt reading outside image");
+    }
+    if (deltaX > dst.width || deltaY > dst.height || deltaX + width > dst.width || deltaY + height > dst.height) {
+      throw new Error("bitblt writing outside image");
+    }
+    for (let y5 = 0;y5 < height; y5++) {
+      src3.data.copy(dst.data, (deltaY + y5) * dst.width + deltaX << 2, (srcY + y5) * src3.width + srcX << 2, (srcY + y5) * src3.width + srcX + width << 2);
+    }
+  };
+  PNG.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) {
+    PNG.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
+    return this;
+  };
+  PNG.adjustGamma = function(src3) {
+    if (src3.gamma) {
+      for (let y5 = 0;y5 < src3.height; y5++) {
+        for (let x3 = 0;x3 < src3.width; x3++) {
+          let idx = src3.width * y5 + x3 << 2;
+          for (let i3 = 0;i3 < 3; i3++) {
+            let sample = src3.data[idx + i3] / 255;
+            sample = Math.pow(sample, 1 / 2.2 / src3.gamma);
+            src3.data[idx + i3] = Math.round(sample * 255);
+          }
+        }
+      }
+      src3.gamma = 0;
+    }
+  };
+  PNG.prototype.adjustGamma = function() {
+    PNG.adjustGamma(this);
+  };
+});
+
+// node_modules/pixelmatch/index.js
+function pixelmatch(img1, img2, output, width, height, options = {}) {
+  const {
+    threshold = 0.1,
+    alpha = 0.1,
+    aaColor = [255, 255, 0],
+    diffColor = [255, 0, 0],
+    includeAA,
+    diffColorAlt,
+    diffMask
+  } = options;
+  if (!isPixelData(img1) || !isPixelData(img2) || output && !isPixelData(output))
+    throw new Error("Image data: Uint8Array, Uint8ClampedArray or Buffer expected.");
+  if (img1.length !== img2.length || output && output.length !== img1.length)
+    throw new Error("Image sizes do not match.");
+  if (img1.length !== width * height * 4)
+    throw new Error("Image data size does not match width/height.");
+  const len = width * height;
+  const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+  const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+  let identical = true;
+  for (let i3 = 0;i3 < len; i3++) {
+    if (a32[i3] !== b32[i3]) {
+      identical = false;
+      break;
+    }
+  }
+  if (identical) {
+    if (output && !diffMask) {
+      for (let i3 = 0;i3 < len; i3++)
+        drawGrayPixel(img1, 4 * i3, alpha, output);
+    }
+    return 0;
+  }
+  const maxDelta = 35215 * threshold * threshold;
+  const [aaR, aaG, aaB] = aaColor;
+  const [diffR, diffG, diffB] = diffColor;
+  const [altR, altG, altB] = diffColorAlt || diffColor;
+  let diff = 0;
+  for (let y5 = 0;y5 < height; y5++) {
+    for (let x3 = 0;x3 < width; x3++) {
+      const i3 = y5 * width + x3;
+      const pos = i3 * 4;
+      const delta = a32[i3] === b32[i3] ? 0 : colorDelta(img1, img2, pos, pos, false);
+      if (Math.abs(delta) > maxDelta) {
+        const isAA = antialiased(img1, x3, y5, width, height, a32, b32) || antialiased(img2, x3, y5, width, height, b32, a32);
+        if (!includeAA && isAA) {
+          if (output && !diffMask)
+            drawPixel(output, pos, aaR, aaG, aaB);
+        } else {
+          if (output) {
+            if (delta < 0) {
+              drawPixel(output, pos, altR, altG, altB);
+            } else {
+              drawPixel(output, pos, diffR, diffG, diffB);
+            }
+          }
+          diff++;
+        }
+      } else if (output && !diffMask) {
+        drawGrayPixel(img1, pos, alpha, output);
+      }
+    }
+  }
+  return diff;
+}
+function isPixelData(arr) {
+  return ArrayBuffer.isView(arr) && arr.BYTES_PER_ELEMENT === 1;
+}
+function antialiased(img, x1, y1, width, height, a32, b32) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x22 = Math.min(x1 + 1, width - 1);
+  const y22 = Math.min(y1 + 1, height - 1);
+  const pos = y1 * width + x1;
+  let zeroes = x1 === x0 || x1 === x22 || y1 === y0 || y1 === y22 ? 1 : 0;
+  let min = 0;
+  let max = 0;
+  let minX = 0;
+  let minY = 0;
+  let maxX = 0;
+  let maxY = 0;
+  for (let x3 = x0;x3 <= x22; x3++) {
+    for (let y5 = y0;y5 <= y22; y5++) {
+      if (x3 === x1 && y5 === y1)
+        continue;
+      const delta = colorDelta(img, img, pos * 4, (y5 * width + x3) * 4, true);
+      if (delta === 0) {
+        zeroes++;
+        if (zeroes > 2)
+          return false;
+      } else if (delta < min) {
+        min = delta;
+        minX = x3;
+        minY = y5;
+      } else if (delta > max) {
+        max = delta;
+        maxX = x3;
+        maxY = y5;
+      }
+    }
+  }
+  if (min === 0 || max === 0)
+    return false;
+  return hasManySiblings(a32, minX, minY, width, height) && hasManySiblings(b32, minX, minY, width, height) || hasManySiblings(a32, maxX, maxY, width, height) && hasManySiblings(b32, maxX, maxY, width, height);
+}
+function hasManySiblings(img, x1, y1, width, height) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x22 = Math.min(x1 + 1, width - 1);
+  const y22 = Math.min(y1 + 1, height - 1);
+  const val = img[y1 * width + x1];
+  let zeroes = x1 === x0 || x1 === x22 || y1 === y0 || y1 === y22 ? 1 : 0;
+  for (let x3 = x0;x3 <= x22; x3++) {
+    for (let y5 = y0;y5 <= y22; y5++) {
+      if (x3 === x1 && y5 === y1)
+        continue;
+      zeroes += +(val === img[y5 * width + x3]);
+      if (zeroes > 2)
+        return true;
+    }
+  }
+  return false;
+}
+function colorDelta(img1, img2, k6, m3, yOnly) {
+  const r1 = img1[k6];
+  const g1 = img1[k6 + 1];
+  const b1 = img1[k6 + 2];
+  const a1 = img1[k6 + 3];
+  const r22 = img2[m3];
+  const g22 = img2[m3 + 1];
+  const b22 = img2[m3 + 2];
+  const a22 = img2[m3 + 3];
+  let dr = r1 - r22;
+  let dg = g1 - g22;
+  let db = b1 - b22;
+  const da = a1 - a22;
+  if (!dr && !dg && !db && !da)
+    return 0;
+  if (a1 < 255 || a22 < 255) {
+    const rb = 48 + 159 * (k6 % 2);
+    const gb = 48 + 159 * ((k6 / 1.618033988749895 | 0) % 2);
+    const bb = 48 + 159 * ((k6 / 2.618033988749895 | 0) % 2);
+    dr = (r1 * a1 - r22 * a22 - rb * da) / 255;
+    dg = (g1 * a1 - g22 * a22 - gb * da) / 255;
+    db = (b1 * a1 - b22 * a22 - bb * da) / 255;
+  }
+  const y5 = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+  if (yOnly)
+    return y5;
+  const i3 = dr * 0.59597799 - dg * 0.2741761 - db * 0.32180189;
+  const q3 = dr * 0.21147017 - dg * 0.52261711 + db * 0.31114694;
+  const delta = 0.5053 * y5 * y5 + 0.299 * i3 * i3 + 0.1957 * q3 * q3;
+  return y5 > 0 ? -delta : delta;
+}
+function drawPixel(output, pos, r5, g5, b3) {
+  output[pos + 0] = r5;
+  output[pos + 1] = g5;
+  output[pos + 2] = b3;
+  output[pos + 3] = 255;
+}
+function drawGrayPixel(img, i3, alpha, output) {
+  const val = 255 + (img[i3] * 0.29889531 + img[i3 + 1] * 0.58662247 + img[i3 + 2] * 0.11448223 - 255) * alpha * img[i3 + 3] / 255;
+  drawPixel(output, i3, val, val, val);
+}
+
+// packages/cli/src/commands/diff/visual.ts
+var exports_visual = {};
+__export(exports_visual, {
+  default: () => visual_default
+});
+var import_pngjs, visual_default;
+var init_visual = __esm(() => {
+  init_dist2();
+  init_client();
+  init_format();
+  import_pngjs = __toESM(require_png(), 1);
+  visual_default = defineCommand({
+    meta: { description: "Create visual diff between two nodes as PNG" },
+    args: {
+      from: { type: "string", description: "Source node ID", required: true },
+      to: { type: "string", description: "Target node ID", required: true },
+      output: { type: "string", description: "Output file path", required: true },
+      scale: { type: "string", description: "Export scale (default: 1)" },
+      threshold: { type: "string", description: "Color threshold 0-1 (default: 0.1)" }
+    },
+    async run({ args }) {
+      try {
+        const scale = args.scale ? Number(args.scale) : 1;
+        const threshold = args.threshold ? Number(args.threshold) : 0.1;
+        const [fromResult, toResult] = await Promise.all([
+          sendCommand("export-node", { id: args.from, format: "PNG", scale }),
+          sendCommand("export-node", { id: args.to, format: "PNG", scale })
+        ]);
+        if (!fromResult?.data || !toResult?.data) {
+          console.error(fail("Could not export nodes"));
+          process.exit(1);
+        }
+        const fromPng = import_pngjs.PNG.sync.read(Buffer.from(fromResult.data, "base64"));
+        const toPng = import_pngjs.PNG.sync.read(Buffer.from(toResult.data, "base64"));
+        if (fromPng.width !== toPng.width || fromPng.height !== toPng.height) {
+          console.error(fail(`Size mismatch: ${fromPng.width}\xD7${fromPng.height} vs ${toPng.width}\xD7${toPng.height}`));
+          process.exit(1);
+        }
+        const { width, height } = fromPng;
+        const diff = new import_pngjs.PNG({ width, height });
+        const diffPixels = pixelmatch(fromPng.data, toPng.data, diff.data, width, height, { threshold });
+        const totalPixels = width * height;
+        const diffPercent = (diffPixels / totalPixels * 100).toFixed(2);
+        await Bun.write(args.output, import_pngjs.PNG.sync.write(diff));
+        console.log(`${diffPixels} pixels differ (${diffPercent}%)`);
+        console.log(`Saved to ${args.output}`);
+      } catch (e6) {
+        handleError(e6);
+      }
+    }
+  });
+});
+
 // packages/cli/src/index.ts
 init_dist2();
 
@@ -29078,317 +31186,1596 @@ var convertXybToRgb = ({ x: x3, y: y5, b: b3, alpha }) => {
     res.alpha = alpha;
   return res;
 };
-var convertXybToRgb_default = convertXybToRgb;
+var convertXybToRgb_default = convertXybToRgb;
+
+// packages/cli/node_modules/culori/src/xyb/definition.js
+var definition25 = {
+  mode: "xyb",
+  channels: ["x", "y", "b", "alpha"],
+  parse: ["--xyb"],
+  serialize: "--xyb",
+  toMode: {
+    rgb: convertXybToRgb_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyb_default
+  },
+  ranges: {
+    x: [-0.0154, 0.0281],
+    y: [0, 0.8453],
+    b: [-0.2778, 0.388]
+  },
+  interpolate: {
+    x: interpolatorLinear,
+    y: interpolatorLinear,
+    b: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  }
+};
+var definition_default25 = definition25;
+
+// packages/cli/node_modules/culori/src/xyz50/definition.js
+var definition26 = {
+  mode: "xyz50",
+  parse: ["xyz-d50"],
+  serialize: "xyz-d50",
+  toMode: {
+    rgb: convertXyz50ToRgb_default,
+    lab: convertXyz50ToLab_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyz50_default,
+    lab: convertLabToXyz50_default
+  },
+  channels: ["x", "y", "z", "alpha"],
+  ranges: {
+    x: [0, 0.964],
+    y: [0, 0.999],
+    z: [0, 0.825]
+  },
+  interpolate: {
+    x: interpolatorLinear,
+    y: interpolatorLinear,
+    z: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  }
+};
+var definition_default26 = definition26;
+
+// packages/cli/node_modules/culori/src/xyz65/convertXyz65ToXyz50.js
+var convertXyz65ToXyz50 = (xyz65) => {
+  let { x: x3, y: y5, z: z3, alpha } = xyz65;
+  if (x3 === undefined)
+    x3 = 0;
+  if (y5 === undefined)
+    y5 = 0;
+  if (z3 === undefined)
+    z3 = 0;
+  let res = {
+    mode: "xyz50",
+    x: 1.0479298208405488 * x3 + 0.0229467933410191 * y5 - 0.0501922295431356 * z3,
+    y: 0.0296278156881593 * x3 + 0.990434484573249 * y5 - 0.0170738250293851 * z3,
+    z: -0.0092430581525912 * x3 + 0.0150551448965779 * y5 + 0.7518742899580008 * z3
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToXyz50_default = convertXyz65ToXyz50;
+
+// packages/cli/node_modules/culori/src/xyz65/convertXyz50ToXyz65.js
+var convertXyz50ToXyz65 = (xyz50) => {
+  let { x: x3, y: y5, z: z3, alpha } = xyz50;
+  if (x3 === undefined)
+    x3 = 0;
+  if (y5 === undefined)
+    y5 = 0;
+  if (z3 === undefined)
+    z3 = 0;
+  let res = {
+    mode: "xyz65",
+    x: 0.9554734527042182 * x3 - 0.0230985368742614 * y5 + 0.0632593086610217 * z3,
+    y: -0.0283697069632081 * x3 + 1.0099954580058226 * y5 + 0.021041398966943 * z3,
+    z: 0.0123140016883199 * x3 - 0.0205076964334779 * y5 + 1.3303659366080753 * z3
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToXyz65_default = convertXyz50ToXyz65;
+
+// packages/cli/node_modules/culori/src/xyz65/definition.js
+var definition27 = {
+  mode: "xyz65",
+  toMode: {
+    rgb: convertXyz65ToRgb_default,
+    xyz50: convertXyz65ToXyz50_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyz65_default,
+    xyz50: convertXyz50ToXyz65_default
+  },
+  ranges: {
+    x: [0, 0.95],
+    y: [0, 1],
+    z: [0, 1.088]
+  },
+  channels: ["x", "y", "z", "alpha"],
+  parse: ["xyz", "xyz-d65"],
+  serialize: "xyz-d65",
+  interpolate: {
+    x: interpolatorLinear,
+    y: interpolatorLinear,
+    z: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  }
+};
+var definition_default27 = definition27;
+
+// packages/cli/node_modules/culori/src/yiq/convertRgbToYiq.js
+var convertRgbToYiq = ({ r: r5, g: g5, b: b3, alpha }) => {
+  if (r5 === undefined)
+    r5 = 0;
+  if (g5 === undefined)
+    g5 = 0;
+  if (b3 === undefined)
+    b3 = 0;
+  const res = {
+    mode: "yiq",
+    y: 0.29889531 * r5 + 0.58662247 * g5 + 0.11448223 * b3,
+    i: 0.59597799 * r5 - 0.2741761 * g5 - 0.32180189 * b3,
+    q: 0.21147017 * r5 - 0.52261711 * g5 + 0.31114694 * b3
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertRgbToYiq_default = convertRgbToYiq;
+
+// packages/cli/node_modules/culori/src/yiq/convertYiqToRgb.js
+var convertYiqToRgb = ({ y: y5, i: i3, q: q3, alpha }) => {
+  if (y5 === undefined)
+    y5 = 0;
+  if (i3 === undefined)
+    i3 = 0;
+  if (q3 === undefined)
+    q3 = 0;
+  const res = {
+    mode: "rgb",
+    r: y5 + 0.95608445 * i3 + 0.6208885 * q3,
+    g: y5 - 0.27137664 * i3 - 0.6486059 * q3,
+    b: y5 - 1.10561724 * i3 + 1.70250126 * q3
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertYiqToRgb_default = convertYiqToRgb;
 
-// packages/cli/node_modules/culori/src/xyb/definition.js
-var definition25 = {
-  mode: "xyb",
-  channels: ["x", "y", "b", "alpha"],
-  parse: ["--xyb"],
-  serialize: "--xyb",
+// packages/cli/node_modules/culori/src/yiq/definition.js
+var definition28 = {
+  mode: "yiq",
   toMode: {
-    rgb: convertXybToRgb_default
+    rgb: convertYiqToRgb_default
   },
   fromMode: {
-    rgb: convertRgbToXyb_default
+    rgb: convertRgbToYiq_default
   },
+  channels: ["y", "i", "q", "alpha"],
+  parse: ["--yiq"],
+  serialize: "--yiq",
   ranges: {
-    x: [-0.0154, 0.0281],
-    y: [0, 0.8453],
-    b: [-0.2778, 0.388]
+    i: [-0.595, 0.595],
+    q: [-0.522, 0.522]
   },
   interpolate: {
-    x: interpolatorLinear,
     y: interpolatorLinear,
-    b: interpolatorLinear,
+    i: interpolatorLinear,
+    q: interpolatorLinear,
     alpha: { use: interpolatorLinear, fixup: fixupAlpha }
   }
 };
-var definition_default25 = definition25;
+var definition_default28 = definition28;
+// packages/cli/node_modules/culori/src/index.js
+var a98 = useMode(definition_default2);
+var cubehelix = useMode(definition_default3);
+var dlab = useMode(definition_default4);
+var dlch = useMode(definition_default5);
+var hsi = useMode(definition_default6);
+var hsl = useMode(definition_default7);
+var hsv = useMode(definition_default8);
+var hwb = useMode(definition_default9);
+var itp = useMode(definition_default10);
+var jab = useMode(definition_default11);
+var jch = useMode(definition_default12);
+var lab = useMode(definition_default13);
+var lab65 = useMode(definition_default14);
+var lch = useMode(definition_default15);
+var lch65 = useMode(definition_default16);
+var lchuv = useMode(definition_default17);
+var lrgb = useMode(definition_default18);
+var luv = useMode(definition_default19);
+var okhsl = useMode(modeOkhsl_default);
+var okhsv = useMode(modeOkhsv_default);
+var oklab = useMode(definition_default20);
+var oklch = useMode(definition_default21);
+var p3 = useMode(definition_default22);
+var prophoto = useMode(definition_default23);
+var rec2020 = useMode(definition_default24);
+var rgb = useMode(definition_default);
+var xyb = useMode(definition_default25);
+var xyz50 = useMode(definition_default26);
+var xyz65 = useMode(definition_default27);
+var yiq = useMode(definition_default28);
 
-// packages/cli/node_modules/culori/src/xyz50/definition.js
-var definition26 = {
-  mode: "xyz50",
-  parse: ["xyz-d50"],
-  serialize: "xyz-d50",
-  toMode: {
-    rgb: convertXyz50ToRgb_default,
-    lab: convertXyz50ToLab_default
-  },
-  fromMode: {
-    rgb: convertRgbToXyz50_default,
-    lab: convertLabToXyz50_default
-  },
-  channels: ["x", "y", "z", "alpha"],
-  ranges: {
-    x: [0, 0.964],
-    y: [0, 0.999],
-    z: [0, 0.825]
-  },
-  interpolate: {
-    x: interpolatorLinear,
-    y: interpolatorLinear,
-    z: interpolatorLinear,
-    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+// packages/cli/src/color.ts
+var toRgb = converter_default("rgb");
+function parseColor(color) {
+  const parsed = parse_default(color);
+  if (!parsed) {
+    return { r: 0, g: 0, b: 0, a: 1 };
   }
+  const rgb2 = toRgb(parsed);
+  return {
+    r: rgb2?.r ?? 0,
+    g: rgb2?.g ?? 0,
+    b: rgb2?.b ?? 0,
+    a: parsed.alpha ?? 1
+  };
+}
+
+// packages/cli/src/render/reconciler.ts
+init_vars();
+
+// packages/cli/src/render/components.tsx
+init_vars();
+var React = __toESM(require_react(), 1);
+var componentRegistry = new Map;
+function getComponentRegistry() {
+  return componentRegistry;
+}
+var c6 = (type) => (props) => React.createElement(type, props);
+var Frame = c6("frame");
+var Rectangle = c6("rectangle");
+var Ellipse = c6("ellipse");
+var Text = c6("text");
+var Line = c6("line");
+var Star = c6("star");
+var Polygon = c6("polygon");
+var Vector = c6("vector");
+var Component = c6("component");
+var Instance = c6("instance");
+var Group = c6("group");
+var Page = c6("page");
+var Icon = c6("icon");
+var INTRINSIC_ELEMENTS = [
+  "Frame",
+  "Rectangle",
+  "Ellipse",
+  "Text",
+  "Line",
+  "Star",
+  "Polygon",
+  "Vector",
+  "Component",
+  "Instance",
+  "Group",
+  "Page",
+  "View",
+  "Icon"
+];
+
+// packages/cli/src/render/shorthands.ts
+var shorthands = {
+  w: "width",
+  h: "height",
+  bg: "backgroundColor",
+  rounded: "borderRadius",
+  p: "padding",
+  pt: "paddingTop",
+  pr: "paddingRight",
+  pb: "paddingBottom",
+  pl: "paddingLeft",
+  size: "fontSize",
+  font: "fontFamily",
+  weight: "fontWeight"
 };
-var definition_default26 = definition26;
+var valueTransforms = {
+  flexDirection: { col: "column" },
+  justifyContent: {
+    start: "flex-start",
+    end: "flex-end",
+    between: "space-between",
+    evenly: "space-evenly"
+  },
+  alignItems: { start: "flex-start", end: "flex-end" }
+};
+function normalizeStyle(style) {
+  const result = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (key === "px" || key === "py" || key === "flex" || key === "justify" || key === "items") {
+      continue;
+    }
+    const fullKey = shorthands[key] || key;
+    if (shorthands[key] && style[fullKey] !== undefined) {
+      continue;
+    }
+    if (result[fullKey] === undefined) {
+      const transform = valueTransforms[fullKey];
+      result[fullKey] = transform?.[value] ?? value;
+    }
+  }
+  if (style.px !== undefined) {
+    if (result.paddingLeft === undefined)
+      result.paddingLeft = style.px;
+    if (result.paddingRight === undefined)
+      result.paddingRight = style.px;
+  }
+  if (style.py !== undefined) {
+    if (result.paddingTop === undefined)
+      result.paddingTop = style.py;
+    if (result.paddingBottom === undefined)
+      result.paddingBottom = style.py;
+  }
+  if (style.flex !== undefined && result.flexDirection === undefined) {
+    const transform = valueTransforms.flexDirection;
+    const value = transform?.[style.flex] ?? style.flex;
+    result.flexDirection = value === "col" ? "column" : value;
+  }
+  if (style.justify !== undefined && result.justifyContent === undefined) {
+    const transform = valueTransforms.justifyContent;
+    result.justifyContent = transform?.[style.justify] ?? style.justify;
+  }
+  if (style.items !== undefined && result.alignItems === undefined) {
+    const transform = valueTransforms.alignItems;
+    result.alignItems = transform?.[style.items] ?? style.items;
+  }
+  return result;
+}
 
-// packages/cli/node_modules/culori/src/xyz65/convertXyz65ToXyz50.js
-var convertXyz65ToXyz50 = (xyz65) => {
-  let { x: x3, y: y5, z: z3, alpha } = xyz65;
-  if (x3 === undefined)
-    x3 = 0;
-  if (y5 === undefined)
-    y5 = 0;
-  if (z3 === undefined)
-    z3 = 0;
-  let res = {
-    mode: "xyz50",
-    x: 1.0479298208405488 * x3 + 0.0229467933410191 * y5 - 0.0501922295431356 * z3,
-    y: 0.0296278156881593 * x3 + 0.990434484573249 * y5 - 0.0170738250293851 * z3,
-    z: -0.0092430581525912 * x3 + 0.0150551448965779 * y5 + 0.7518742899580008 * z3
+// packages/cli/src/render/component-set.tsx
+var React2 = __toESM(require_react(), 1);
+var REGISTRY_KEY = "__figma_use_component_set_registry__";
+var componentSetRegistry = globalThis[REGISTRY_KEY] || (globalThis[REGISTRY_KEY] = new Map);
+function getComponentSetRegistry() {
+  return componentSetRegistry;
+}
+function generateVariantCombinations(variants) {
+  const keys = Object.keys(variants);
+  if (keys.length === 0)
+    return [{}];
+  const result = [];
+  function combine(index, current) {
+    if (index === keys.length) {
+      result.push(current);
+      return;
+    }
+    const key = keys[index];
+    for (const value of variants[key]) {
+      combine(index + 1, { ...current, [key]: value });
+    }
+  }
+  combine(0, {});
+  return result;
+}
+function buildVariantName(props) {
+  return Object.entries(props).map(([k6, v3]) => `${k6}=${v3}`).join(", ");
+}
+function buildStateGroupPropertyValueOrders(variants) {
+  return Object.entries(variants).map(([property, values]) => ({
+    property,
+    values: [...values]
+  }));
+}
+
+// node_modules/@iconify/core/lib/api/callbacks.js
+function removeCallback(storages, id) {
+  storages.forEach((storage) => {
+    const items = storage.loaderCallbacks;
+    if (items)
+      storage.loaderCallbacks = items.filter((row) => row.id !== id);
+  });
+}
+function updateCallbacks(storage) {
+  if (!storage.pendingCallbacksFlag) {
+    storage.pendingCallbacksFlag = true;
+    setTimeout(() => {
+      storage.pendingCallbacksFlag = false;
+      const items = storage.loaderCallbacks ? storage.loaderCallbacks.slice(0) : [];
+      if (!items.length)
+        return;
+      let hasPending = false;
+      const provider = storage.provider;
+      const prefix = storage.prefix;
+      items.forEach((item) => {
+        const icons = item.icons;
+        const oldLength = icons.pending.length;
+        icons.pending = icons.pending.filter((icon) => {
+          if (icon.prefix !== prefix)
+            return true;
+          const name = icon.name;
+          if (storage.icons[name])
+            icons.loaded.push({
+              provider,
+              prefix,
+              name
+            });
+          else if (storage.missing.has(name))
+            icons.missing.push({
+              provider,
+              prefix,
+              name
+            });
+          else {
+            hasPending = true;
+            return true;
+          }
+          return false;
+        });
+        if (icons.pending.length !== oldLength) {
+          if (!hasPending)
+            removeCallback([storage], item.id);
+          item.callback(icons.loaded.slice(0), icons.missing.slice(0), icons.pending.slice(0), item.abort);
+        }
+      });
+    });
+  }
+}
+var idCounter = 0;
+function storeCallback(callback, icons, pendingSources) {
+  const id = idCounter++;
+  const abort = removeCallback.bind(null, pendingSources, id);
+  if (!icons.pending.length)
+    return abort;
+  const item = {
+    id,
+    icons,
+    callback,
+    abort
   };
-  if (alpha !== undefined) {
-    res.alpha = alpha;
+  pendingSources.forEach((storage) => {
+    (storage.loaderCallbacks || (storage.loaderCallbacks = [])).push(item);
+  });
+  return abort;
+}
+
+// node_modules/@iconify/utils/lib/icon-set/tree.js
+function getIconsTree(data, names) {
+  const icons = data.icons;
+  const aliases = data.aliases || Object.create(null);
+  const resolved = Object.create(null);
+  function resolve3(name) {
+    if (icons[name])
+      return resolved[name] = [];
+    if (!(name in resolved)) {
+      resolved[name] = null;
+      const parent = aliases[name] && aliases[name].parent;
+      const value = parent && resolve3(parent);
+      if (value)
+        resolved[name] = [parent].concat(value);
+    }
+    return resolved[name];
+  }
+  (names || Object.keys(icons).concat(Object.keys(aliases))).forEach(resolve3);
+  return resolved;
+}
+
+// node_modules/@iconify/utils/lib/icon/defaults.js
+var defaultIconDimensions = Object.freeze({
+  left: 0,
+  top: 0,
+  width: 16,
+  height: 16
+});
+var defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+var defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+var defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+
+// node_modules/@iconify/utils/lib/icon/transformations.js
+function mergeIconTransformations(obj1, obj2) {
+  const result = {};
+  if (!obj1.hFlip !== !obj2.hFlip)
+    result.hFlip = true;
+  if (!obj1.vFlip !== !obj2.vFlip)
+    result.vFlip = true;
+  const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+  if (rotate)
+    result.rotate = rotate;
+  return result;
+}
+
+// node_modules/@iconify/utils/lib/icon/merge.js
+function mergeIconData(parent, child) {
+  const result = mergeIconTransformations(parent, child);
+  for (const key in defaultExtendedIconProps)
+    if (key in defaultIconTransformations) {
+      if (key in parent && !(key in result))
+        result[key] = defaultIconTransformations[key];
+    } else if (key in child)
+      result[key] = child[key];
+    else if (key in parent)
+      result[key] = parent[key];
+  return result;
+}
+
+// node_modules/@iconify/utils/lib/icon-set/get-icon.js
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || Object.create(null);
+  let currentProps = {};
+  function parse2(name$1) {
+    currentProps = mergeIconData(icons[name$1] || aliases[name$1], currentProps);
+  }
+  parse2(name);
+  tree.forEach(parse2);
+  return mergeIconData(data, currentProps);
+}
+
+// node_modules/@iconify/utils/lib/icon-set/parse.js
+function parseIconSet(data, callback) {
+  const names = [];
+  if (typeof data !== "object" || typeof data.icons !== "object")
+    return names;
+  if (data.not_found instanceof Array)
+    data.not_found.forEach((name) => {
+      callback(name, null);
+      names.push(name);
+    });
+  const tree = getIconsTree(data);
+  for (const name in tree) {
+    const item = tree[name];
+    if (item) {
+      callback(name, internalGetIconData(data, name, item));
+      names.push(name);
+    }
+  }
+  return names;
+}
+
+// node_modules/@iconify/utils/lib/icon-set/validate-basic.js
+var optionalPropertyDefaults = {
+  provider: "",
+  aliases: {},
+  not_found: {},
+  ...defaultIconDimensions
+};
+function checkOptionalProps(item, defaults) {
+  for (const prop in defaults)
+    if (prop in item && typeof item[prop] !== typeof defaults[prop])
+      return false;
+  return true;
+}
+function quicklyValidateIconSet(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return null;
+  const data = obj;
+  if (typeof data.prefix !== "string" || !obj.icons || typeof obj.icons !== "object")
+    return null;
+  if (!checkOptionalProps(obj, optionalPropertyDefaults))
+    return null;
+  const icons = data.icons;
+  for (const name in icons) {
+    const icon = icons[name];
+    if (!name || typeof icon.body !== "string" || !checkOptionalProps(icon, defaultExtendedIconProps))
+      return null;
   }
-  return res;
-};
-var convertXyz65ToXyz50_default = convertXyz65ToXyz50;
+  const aliases = data.aliases || Object.create(null);
+  for (const name in aliases) {
+    const icon = aliases[name];
+    const parent = icon.parent;
+    if (!name || typeof parent !== "string" || !icons[parent] && !aliases[parent] || !checkOptionalProps(icon, defaultExtendedIconProps))
+      return null;
+  }
+  return data;
+}
 
-// packages/cli/node_modules/culori/src/xyz65/convertXyz50ToXyz65.js
-var convertXyz50ToXyz65 = (xyz50) => {
-  let { x: x3, y: y5, z: z3, alpha } = xyz50;
-  if (x3 === undefined)
-    x3 = 0;
-  if (y5 === undefined)
-    y5 = 0;
-  if (z3 === undefined)
-    z3 = 0;
-  let res = {
-    mode: "xyz65",
-    x: 0.9554734527042182 * x3 - 0.0230985368742614 * y5 + 0.0632593086610217 * z3,
-    y: -0.0283697069632081 * x3 + 1.0099954580058226 * y5 + 0.021041398966943 * z3,
-    z: 0.0123140016883199 * x3 - 0.0205076964334779 * y5 + 1.3303659366080753 * z3
+// node_modules/@iconify/core/lib/storage/storage.js
+var dataStorage = Object.create(null);
+function newStorage(provider, prefix) {
+  return {
+    provider,
+    prefix,
+    icons: Object.create(null),
+    missing: /* @__PURE__ */ new Set
   };
-  if (alpha !== undefined) {
-    res.alpha = alpha;
+}
+function getStorage(provider, prefix) {
+  const providerStorage = dataStorage[provider] || (dataStorage[provider] = Object.create(null));
+  return providerStorage[prefix] || (providerStorage[prefix] = newStorage(provider, prefix));
+}
+function addIconSet(storage, data) {
+  if (!quicklyValidateIconSet(data))
+    return [];
+  return parseIconSet(data, (name, icon) => {
+    if (icon)
+      storage.icons[name] = icon;
+    else
+      storage.missing.add(name);
+  });
+}
+
+// node_modules/@iconify/core/lib/icon/sort.js
+function sortIcons(icons) {
+  const result = {
+    loaded: [],
+    missing: [],
+    pending: []
+  };
+  const storage = Object.create(null);
+  icons.sort((a3, b3) => {
+    if (a3.provider !== b3.provider)
+      return a3.provider.localeCompare(b3.provider);
+    if (a3.prefix !== b3.prefix)
+      return a3.prefix.localeCompare(b3.prefix);
+    return a3.name.localeCompare(b3.name);
+  });
+  let lastIcon = {
+    provider: "",
+    prefix: "",
+    name: ""
+  };
+  icons.forEach((icon) => {
+    if (lastIcon.name === icon.name && lastIcon.prefix === icon.prefix && lastIcon.provider === icon.provider)
+      return;
+    lastIcon = icon;
+    const provider = icon.provider;
+    const prefix = icon.prefix;
+    const name = icon.name;
+    const providerStorage = storage[provider] || (storage[provider] = Object.create(null));
+    const localStorage = providerStorage[prefix] || (providerStorage[prefix] = getStorage(provider, prefix));
+    let list;
+    if (name in localStorage.icons)
+      list = result.loaded;
+    else if (prefix === "" || localStorage.missing.has(name))
+      list = result.missing;
+    else
+      list = result.pending;
+    const item = {
+      provider,
+      prefix,
+      name
+    };
+    list.push(item);
+  });
+  return result;
+}
+
+// node_modules/@iconify/core/lib/api/modules.js
+var storage = Object.create(null);
+function setAPIModule(provider, item) {
+  storage[provider] = item;
+}
+function getAPIModule(provider) {
+  return storage[provider] || storage[""];
+}
+
+// node_modules/@iconify/utils/lib/icon/name.js
+var matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var stringToIcon = (value, validate3, allowSimpleName, provider = "") => {
+  const colonSeparated = value.split(":");
+  if (value.slice(0, 1) === "@") {
+    if (colonSeparated.length < 2 || colonSeparated.length > 3)
+      return null;
+    provider = colonSeparated.shift().slice(1);
   }
-  return res;
+  if (colonSeparated.length > 3 || !colonSeparated.length)
+    return null;
+  if (colonSeparated.length > 1) {
+    const name$1 = colonSeparated.pop();
+    const prefix = colonSeparated.pop();
+    const result = {
+      provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+      prefix,
+      name: name$1
+    };
+    return validate3 && !validateIconName(result) ? null : result;
+  }
+  const name = colonSeparated[0];
+  const dashSeparated = name.split("-");
+  if (dashSeparated.length > 1) {
+    const result = {
+      provider,
+      prefix: dashSeparated.shift(),
+      name: dashSeparated.join("-")
+    };
+    return validate3 && !validateIconName(result) ? null : result;
+  }
+  if (allowSimpleName && provider === "") {
+    const result = {
+      provider,
+      prefix: "",
+      name
+    };
+    return validate3 && !validateIconName(result, allowSimpleName) ? null : result;
+  }
+  return null;
+};
+var validateIconName = (icon, allowSimpleName) => {
+  if (!icon)
+    return false;
+  return !!((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
 };
-var convertXyz50ToXyz65_default = convertXyz50ToXyz65;
 
-// packages/cli/node_modules/culori/src/xyz65/definition.js
-var definition27 = {
-  mode: "xyz65",
-  toMode: {
-    rgb: convertXyz65ToRgb_default,
-    xyz50: convertXyz65ToXyz50_default
-  },
-  fromMode: {
-    rgb: convertRgbToXyz65_default,
-    xyz50: convertXyz50ToXyz65_default
-  },
-  ranges: {
-    x: [0, 0.95],
-    y: [0, 1],
-    z: [0, 1.088]
-  },
-  channels: ["x", "y", "z", "alpha"],
-  parse: ["xyz", "xyz-d65"],
-  serialize: "xyz-d65",
-  interpolate: {
-    x: interpolatorLinear,
-    y: interpolatorLinear,
-    z: interpolatorLinear,
-    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+// node_modules/@iconify/core/lib/icon/list.js
+function listToIcons(list, validate3 = true, simpleNames = false) {
+  const result = [];
+  list.forEach((item) => {
+    const icon = typeof item === "string" ? stringToIcon(item, validate3, simpleNames) : item;
+    if (icon)
+      result.push(icon);
+  });
+  return result;
+}
+
+// node_modules/@iconify/core/lib/storage/functions.js
+var simpleNames = false;
+function allowSimpleNames(allow) {
+  if (typeof allow === "boolean")
+    simpleNames = allow;
+  return simpleNames;
+}
+function getIconData(name) {
+  const icon = typeof name === "string" ? stringToIcon(name, true, simpleNames) : name;
+  if (icon) {
+    const storage2 = getStorage(icon.provider, icon.prefix);
+    const iconName = icon.name;
+    return storage2.icons[iconName] || (storage2.missing.has(iconName) ? null : undefined);
   }
-};
-var definition_default27 = definition27;
+}
 
-// packages/cli/node_modules/culori/src/yiq/convertRgbToYiq.js
-var convertRgbToYiq = ({ r: r5, g: g5, b: b3, alpha }) => {
-  if (r5 === undefined)
-    r5 = 0;
-  if (g5 === undefined)
-    g5 = 0;
-  if (b3 === undefined)
-    b3 = 0;
-  const res = {
-    mode: "yiq",
-    y: 0.29889531 * r5 + 0.58662247 * g5 + 0.11448223 * b3,
-    i: 0.59597799 * r5 - 0.2741761 * g5 - 0.32180189 * b3,
-    q: 0.21147017 * r5 - 0.52261711 * g5 + 0.31114694 * b3
+// node_modules/@iconify/core/lib/api/config.js
+function createAPIConfig(source) {
+  let resources;
+  if (typeof source.resources === "string")
+    resources = [source.resources];
+  else {
+    resources = source.resources;
+    if (!(resources instanceof Array) || !resources.length)
+      return null;
+  }
+  const result = {
+    resources,
+    path: source.path || "/",
+    maxURL: source.maxURL || 500,
+    rotate: source.rotate || 750,
+    timeout: source.timeout || 5000,
+    random: source.random === true,
+    index: source.index || 0,
+    dataAfterTimeout: source.dataAfterTimeout !== false
   };
-  if (alpha !== undefined)
-    res.alpha = alpha;
-  return res;
+  return result;
+}
+var configStorage = Object.create(null);
+var fallBackAPISources = ["https://api.simplesvg.com", "https://api.unisvg.com"];
+var fallBackAPI = [];
+while (fallBackAPISources.length > 0)
+  if (fallBackAPISources.length === 1)
+    fallBackAPI.push(fallBackAPISources.shift());
+  else if (Math.random() > 0.5)
+    fallBackAPI.push(fallBackAPISources.shift());
+  else
+    fallBackAPI.push(fallBackAPISources.pop());
+configStorage[""] = createAPIConfig({ resources: ["https://api.iconify.design"].concat(fallBackAPI) });
+function getAPIConfig(provider) {
+  return configStorage[provider];
+}
+
+// node_modules/@iconify/api-redundancy/dist/index.mjs
+var defaultConfig = {
+  resources: [],
+  index: 0,
+  timeout: 2000,
+  rotate: 750,
+  random: false,
+  dataAfterTimeout: false
 };
-var convertRgbToYiq_default = convertRgbToYiq;
+function sendQuery(config, payload, query, done) {
+  const resourcesCount = config.resources.length;
+  const startIndex = config.random ? Math.floor(Math.random() * resourcesCount) : config.index;
+  let resources;
+  if (config.random) {
+    let list = config.resources.slice(0);
+    resources = [];
+    while (list.length > 1) {
+      const nextIndex = Math.floor(Math.random() * list.length);
+      resources.push(list[nextIndex]);
+      list = list.slice(0, nextIndex).concat(list.slice(nextIndex + 1));
+    }
+    resources = resources.concat(list);
+  } else {
+    resources = config.resources.slice(startIndex).concat(config.resources.slice(0, startIndex));
+  }
+  const startTime = Date.now();
+  let status = "pending";
+  let queriesSent = 0;
+  let lastError;
+  let timer = null;
+  let queue3 = [];
+  let doneCallbacks = [];
+  if (typeof done === "function") {
+    doneCallbacks.push(done);
+  }
+  function resetTimer() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function abort() {
+    if (status === "pending") {
+      status = "aborted";
+    }
+    resetTimer();
+    queue3.forEach((item) => {
+      if (item.status === "pending") {
+        item.status = "aborted";
+      }
+    });
+    queue3 = [];
+  }
+  function subscribe(callback, overwrite) {
+    if (overwrite) {
+      doneCallbacks = [];
+    }
+    if (typeof callback === "function") {
+      doneCallbacks.push(callback);
+    }
+  }
+  function getQueryStatus() {
+    return {
+      startTime,
+      payload,
+      status,
+      queriesSent,
+      queriesPending: queue3.length,
+      subscribe,
+      abort
+    };
+  }
+  function failQuery() {
+    status = "failed";
+    doneCallbacks.forEach((callback) => {
+      callback(undefined, lastError);
+    });
+  }
+  function clearQueue() {
+    queue3.forEach((item) => {
+      if (item.status === "pending") {
+        item.status = "aborted";
+      }
+    });
+    queue3 = [];
+  }
+  function moduleResponse(item, response, data) {
+    const isError = response !== "success";
+    queue3 = queue3.filter((queued) => queued !== item);
+    switch (status) {
+      case "pending":
+        break;
+      case "failed":
+        if (isError || !config.dataAfterTimeout) {
+          return;
+        }
+        break;
+      default:
+        return;
+    }
+    if (response === "abort") {
+      lastError = data;
+      failQuery();
+      return;
+    }
+    if (isError) {
+      lastError = data;
+      if (!queue3.length) {
+        if (!resources.length) {
+          failQuery();
+        } else {
+          execNext();
+        }
+      }
+      return;
+    }
+    resetTimer();
+    clearQueue();
+    if (!config.random) {
+      const index = config.resources.indexOf(item.resource);
+      if (index !== -1 && index !== config.index) {
+        config.index = index;
+      }
+    }
+    status = "completed";
+    doneCallbacks.forEach((callback) => {
+      callback(data);
+    });
+  }
+  function execNext() {
+    if (status !== "pending") {
+      return;
+    }
+    resetTimer();
+    const resource = resources.shift();
+    if (resource === undefined) {
+      if (queue3.length) {
+        timer = setTimeout(() => {
+          resetTimer();
+          if (status === "pending") {
+            clearQueue();
+            failQuery();
+          }
+        }, config.timeout);
+        return;
+      }
+      failQuery();
+      return;
+    }
+    const item = {
+      status: "pending",
+      resource,
+      callback: (status2, data) => {
+        moduleResponse(item, status2, data);
+      }
+    };
+    queue3.push(item);
+    queriesSent++;
+    timer = setTimeout(execNext, config.rotate);
+    query(resource, payload, item.callback);
+  }
+  setTimeout(execNext);
+  return getQueryStatus;
+}
+function initRedundancy(cfg) {
+  const config = {
+    ...defaultConfig,
+    ...cfg
+  };
+  let queries = [];
+  function cleanup() {
+    queries = queries.filter((item) => item().status === "pending");
+  }
+  function query(payload, queryCallback, doneCallback) {
+    const query2 = sendQuery(config, payload, queryCallback, (data, error) => {
+      cleanup();
+      if (doneCallback) {
+        doneCallback(data, error);
+      }
+    });
+    queries.push(query2);
+    return query2;
+  }
+  function find(callback) {
+    return queries.find((value) => {
+      return callback(value);
+    }) || null;
+  }
+  const instance = {
+    query,
+    find,
+    setIndex: (index) => {
+      config.index = index;
+    },
+    getIndex: () => config.index,
+    cleanup
+  };
+  return instance;
+}
 
-// packages/cli/node_modules/culori/src/yiq/convertYiqToRgb.js
-var convertYiqToRgb = ({ y: y5, i: i3, q: q3, alpha }) => {
-  if (y5 === undefined)
-    y5 = 0;
-  if (i3 === undefined)
-    i3 = 0;
-  if (q3 === undefined)
-    q3 = 0;
-  const res = {
-    mode: "rgb",
-    r: y5 + 0.95608445 * i3 + 0.6208885 * q3,
-    g: y5 - 0.27137664 * i3 - 0.6486059 * q3,
-    b: y5 - 1.10561724 * i3 + 1.70250126 * q3
+// node_modules/@iconify/core/lib/api/query.js
+function emptyCallback() {}
+var redundancyCache = Object.create(null);
+function getRedundancyCache(provider) {
+  if (!redundancyCache[provider]) {
+    const config = getAPIConfig(provider);
+    if (!config)
+      return;
+    const redundancy = initRedundancy(config);
+    const cachedReundancy = {
+      config,
+      redundancy
+    };
+    redundancyCache[provider] = cachedReundancy;
+  }
+  return redundancyCache[provider];
+}
+function sendAPIQuery(target, query, callback) {
+  let redundancy;
+  let send;
+  if (typeof target === "string") {
+    const api = getAPIModule(target);
+    if (!api) {
+      callback(undefined, 424);
+      return emptyCallback;
+    }
+    send = api.send;
+    const cached = getRedundancyCache(target);
+    if (cached)
+      redundancy = cached.redundancy;
+  } else {
+    const config = createAPIConfig(target);
+    if (config) {
+      redundancy = initRedundancy(config);
+      const moduleKey = target.resources ? target.resources[0] : "";
+      const api = getAPIModule(moduleKey);
+      if (api)
+        send = api.send;
+    }
+  }
+  if (!redundancy || !send) {
+    callback(undefined, 424);
+    return emptyCallback;
+  }
+  return redundancy.query(query, send, callback)().abort;
+}
+
+// node_modules/@iconify/core/lib/api/icons.js
+function emptyCallback2() {}
+function loadedNewIcons(storage2) {
+  if (!storage2.iconsLoaderFlag) {
+    storage2.iconsLoaderFlag = true;
+    setTimeout(() => {
+      storage2.iconsLoaderFlag = false;
+      updateCallbacks(storage2);
+    });
+  }
+}
+function checkIconNamesForAPI(icons) {
+  const valid = [];
+  const invalid = [];
+  icons.forEach((name) => {
+    (name.match(matchIconName) ? valid : invalid).push(name);
+  });
+  return {
+    valid,
+    invalid
   };
-  if (alpha !== undefined)
-    res.alpha = alpha;
-  return res;
+}
+function parseLoaderResponse(storage2, icons, data) {
+  function checkMissing() {
+    const pending = storage2.pendingIcons;
+    icons.forEach((name) => {
+      if (pending)
+        pending.delete(name);
+      if (!storage2.icons[name])
+        storage2.missing.add(name);
+    });
+  }
+  if (data && typeof data === "object")
+    try {
+      const parsed = addIconSet(storage2, data);
+      if (!parsed.length) {
+        checkMissing();
+        return;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+  checkMissing();
+  loadedNewIcons(storage2);
+}
+function parsePossiblyAsyncResponse(response, callback) {
+  if (response instanceof Promise)
+    response.then((data) => {
+      callback(data);
+    }).catch(() => {
+      callback(null);
+    });
+  else
+    callback(response);
+}
+function loadNewIcons(storage2, icons) {
+  if (!storage2.iconsToLoad)
+    storage2.iconsToLoad = icons;
+  else
+    storage2.iconsToLoad = storage2.iconsToLoad.concat(icons).sort();
+  if (!storage2.iconsQueueFlag) {
+    storage2.iconsQueueFlag = true;
+    setTimeout(() => {
+      storage2.iconsQueueFlag = false;
+      const { provider, prefix } = storage2;
+      const icons$1 = storage2.iconsToLoad;
+      delete storage2.iconsToLoad;
+      if (!icons$1 || !icons$1.length)
+        return;
+      const customIconLoader = storage2.loadIcon;
+      if (storage2.loadIcons && (icons$1.length > 1 || !customIconLoader)) {
+        parsePossiblyAsyncResponse(storage2.loadIcons(icons$1, prefix, provider), (data) => {
+          parseLoaderResponse(storage2, icons$1, data);
+        });
+        return;
+      }
+      if (customIconLoader) {
+        icons$1.forEach((name) => {
+          const response = customIconLoader(name, prefix, provider);
+          parsePossiblyAsyncResponse(response, (data) => {
+            const iconSet = data ? {
+              prefix,
+              icons: { [name]: data }
+            } : null;
+            parseLoaderResponse(storage2, [name], iconSet);
+          });
+        });
+        return;
+      }
+      const { valid, invalid } = checkIconNamesForAPI(icons$1);
+      if (invalid.length)
+        parseLoaderResponse(storage2, invalid, null);
+      if (!valid.length)
+        return;
+      const api = prefix.match(matchIconName) ? getAPIModule(provider) : null;
+      if (!api) {
+        parseLoaderResponse(storage2, valid, null);
+        return;
+      }
+      const params = api.prepare(provider, prefix, valid);
+      params.forEach((item) => {
+        sendAPIQuery(provider, item, (data) => {
+          parseLoaderResponse(storage2, item.icons, data);
+        });
+      });
+    });
+  }
+}
+var loadIcons = (icons, callback) => {
+  const cleanedIcons = listToIcons(icons, true, allowSimpleNames());
+  const sortedIcons = sortIcons(cleanedIcons);
+  if (!sortedIcons.pending.length) {
+    let callCallback = true;
+    if (callback)
+      setTimeout(() => {
+        if (callCallback)
+          callback(sortedIcons.loaded, sortedIcons.missing, sortedIcons.pending, emptyCallback2);
+      });
+    return () => {
+      callCallback = false;
+    };
+  }
+  const newIcons = Object.create(null);
+  const sources = [];
+  let lastProvider, lastPrefix;
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix } = icon;
+    if (prefix === lastPrefix && provider === lastProvider)
+      return;
+    lastProvider = provider;
+    lastPrefix = prefix;
+    sources.push(getStorage(provider, prefix));
+    const providerNewIcons = newIcons[provider] || (newIcons[provider] = Object.create(null));
+    if (!providerNewIcons[prefix])
+      providerNewIcons[prefix] = [];
+  });
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix, name } = icon;
+    const storage2 = getStorage(provider, prefix);
+    const pendingQueue = storage2.pendingIcons || (storage2.pendingIcons = /* @__PURE__ */ new Set);
+    if (!pendingQueue.has(name)) {
+      pendingQueue.add(name);
+      newIcons[provider][prefix].push(name);
+    }
+  });
+  sources.forEach((storage2) => {
+    const list = newIcons[storage2.provider][storage2.prefix];
+    if (list.length)
+      loadNewIcons(storage2, list);
+  });
+  return callback ? storeCallback(callback, sortedIcons, sources) : emptyCallback2;
+};
+var loadIcon = (icon) => {
+  return new Promise((fulfill, reject) => {
+    const iconObj = typeof icon === "string" ? stringToIcon(icon, true) : icon;
+    if (!iconObj) {
+      reject(icon);
+      return;
+    }
+    loadIcons([iconObj || icon], (loaded) => {
+      if (loaded.length && iconObj) {
+        const data = getIconData(iconObj);
+        if (data) {
+          fulfill({
+            ...defaultIconProps,
+            ...data
+          });
+          return;
+        }
+      }
+      reject(icon);
+    });
+  });
 };
-var convertYiqToRgb_default = convertYiqToRgb;
 
-// packages/cli/node_modules/culori/src/yiq/definition.js
-var definition28 = {
-  mode: "yiq",
-  toMode: {
-    rgb: convertYiqToRgb_default
-  },
-  fromMode: {
-    rgb: convertRgbToYiq_default
-  },
-  channels: ["y", "i", "q", "alpha"],
-  parse: ["--yiq"],
-  serialize: "--yiq",
-  ranges: {
-    i: [-0.595, 0.595],
-    q: [-0.522, 0.522]
-  },
-  interpolate: {
-    y: interpolatorLinear,
-    i: interpolatorLinear,
-    q: interpolatorLinear,
-    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+// node_modules/@iconify/core/lib/api/modules/fetch.js
+var detectFetch = () => {
+  let callback;
+  try {
+    callback = fetch;
+    if (typeof callback === "function")
+      return callback;
+  } catch (err) {}
+};
+var fetchModule = detectFetch();
+function calculateMaxLength(provider, prefix) {
+  const config = getAPIConfig(provider);
+  if (!config)
+    return 0;
+  let result;
+  if (!config.maxURL)
+    result = 0;
+  else {
+    let maxHostLength = 0;
+    config.resources.forEach((item) => {
+      const host = item;
+      maxHostLength = Math.max(maxHostLength, host.length);
+    });
+    const url = prefix + ".json?icons=";
+    result = config.maxURL - maxHostLength - config.path.length - url.length;
   }
+  return result;
+}
+function shouldAbort(status) {
+  return status === 404;
+}
+var prepare2 = (provider, prefix, icons) => {
+  const results = [];
+  const maxLength = calculateMaxLength(provider, prefix);
+  const type = "icons";
+  let item = {
+    type,
+    provider,
+    prefix,
+    icons: []
+  };
+  let length = 0;
+  icons.forEach((name, index) => {
+    length += name.length + 1;
+    if (length >= maxLength && index > 0) {
+      results.push(item);
+      item = {
+        type,
+        provider,
+        prefix,
+        icons: []
+      };
+      length = name.length;
+    }
+    item.icons.push(name);
+  });
+  results.push(item);
+  return results;
+};
+function getPath(provider) {
+  if (typeof provider === "string") {
+    const config = getAPIConfig(provider);
+    if (config)
+      return config.path;
+  }
+  return "/";
+}
+var send = (host, params, callback) => {
+  if (!fetchModule) {
+    callback("abort", 424);
+    return;
+  }
+  let path = getPath(params.provider);
+  switch (params.type) {
+    case "icons": {
+      const prefix = params.prefix;
+      const icons = params.icons;
+      const iconsList = icons.join(",");
+      const urlParams = new URLSearchParams({ icons: iconsList });
+      path += prefix + ".json?" + urlParams.toString();
+      break;
+    }
+    case "custom": {
+      const uri = params.uri;
+      path += uri.slice(0, 1) === "/" ? uri.slice(1) : uri;
+      break;
+    }
+    default:
+      callback("abort", 400);
+      return;
+  }
+  let defaultError = 503;
+  fetchModule(host + path).then((response) => {
+    const status = response.status;
+    if (status !== 200) {
+      setTimeout(() => {
+        callback(shouldAbort(status) ? "abort" : "next", status);
+      });
+      return;
+    }
+    defaultError = 501;
+    return response.json();
+  }).then((data) => {
+    if (typeof data !== "object" || data === null) {
+      setTimeout(() => {
+        if (data === 404)
+          callback("abort", data);
+        else
+          callback("next", defaultError);
+      });
+      return;
+    }
+    setTimeout(() => {
+      callback("success", data);
+    });
+  }).catch(() => {
+    callback("next", defaultError);
+  });
+};
+var fetchAPIModule = {
+  prepare: prepare2,
+  send
 };
-var definition_default28 = definition28;
-// packages/cli/node_modules/culori/src/index.js
-var a98 = useMode(definition_default2);
-var cubehelix = useMode(definition_default3);
-var dlab = useMode(definition_default4);
-var dlch = useMode(definition_default5);
-var hsi = useMode(definition_default6);
-var hsl = useMode(definition_default7);
-var hsv = useMode(definition_default8);
-var hwb = useMode(definition_default9);
-var itp = useMode(definition_default10);
-var jab = useMode(definition_default11);
-var jch = useMode(definition_default12);
-var lab = useMode(definition_default13);
-var lab65 = useMode(definition_default14);
-var lch = useMode(definition_default15);
-var lch65 = useMode(definition_default16);
-var lchuv = useMode(definition_default17);
-var lrgb = useMode(definition_default18);
-var luv = useMode(definition_default19);
-var okhsl = useMode(modeOkhsl_default);
-var okhsv = useMode(modeOkhsv_default);
-var oklab = useMode(definition_default20);
-var oklch = useMode(definition_default21);
-var p3 = useMode(definition_default22);
-var prophoto = useMode(definition_default23);
-var rec2020 = useMode(definition_default24);
-var rgb = useMode(definition_default);
-var xyb = useMode(definition_default25);
-var xyz50 = useMode(definition_default26);
-var xyz65 = useMode(definition_default27);
-var yiq = useMode(definition_default28);
 
-// packages/cli/src/color.ts
-var toRgb = converter_default("rgb");
-function parseColor(color) {
-  const parsed = parse_default(color);
-  if (!parsed) {
-    return { r: 0, g: 0, b: 0, a: 1 };
+// node_modules/@iconify/utils/lib/customisations/defaults.js
+var defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+var defaultIconCustomisations = Object.freeze({
+  ...defaultIconSizeCustomisations,
+  ...defaultIconTransformations
+});
+
+// node_modules/@iconify/utils/lib/svg/size.js
+var unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+var unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+  if (ratio === 1)
+    return size;
+  precision = precision || 100;
+  if (typeof size === "number")
+    return Math.ceil(size * ratio * precision) / precision;
+  if (typeof size !== "string")
+    return size;
+  const oldParts = size.split(unitsSplit);
+  if (oldParts === null || !oldParts.length)
+    return size;
+  const newParts = [];
+  let code = oldParts.shift();
+  let isNumber = unitsTest.test(code);
+  while (true) {
+    if (isNumber) {
+      const num3 = parseFloat(code);
+      if (isNaN(num3))
+        newParts.push(code);
+      else
+        newParts.push(Math.ceil(num3 * ratio * precision) / precision);
+    } else
+      newParts.push(code);
+    code = oldParts.shift();
+    if (code === undefined)
+      return newParts.join("");
+    isNumber = !isNumber;
+  }
+}
+
+// node_modules/@iconify/utils/lib/svg/defs.js
+function splitSVGDefs(content, tag = "defs") {
+  let defs = "";
+  const index = content.indexOf("<" + tag);
+  while (index >= 0) {
+    const start = content.indexOf(">", index);
+    const end = content.indexOf("</" + tag);
+    if (start === -1 || end === -1)
+      break;
+    const endEnd = content.indexOf(">", end);
+    if (endEnd === -1)
+      break;
+    defs += content.slice(start + 1, end).trim();
+    content = content.slice(0, index).trim() + content.slice(endEnd + 1);
   }
-  const rgb2 = toRgb(parsed);
   return {
-    r: rgb2?.r ?? 0,
-    g: rgb2?.g ?? 0,
-    b: rgb2?.b ?? 0,
-    a: parsed.alpha ?? 1
+    defs,
+    content
   };
 }
+function mergeDefsAndContent(defs, content) {
+  return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+function wrapSVGContent(body, start, end) {
+  const split = splitSVGDefs(body);
+  return mergeDefsAndContent(split.defs, start + split.content + end);
+}
 
-// packages/cli/src/render/reconciler.ts
-init_vars();
-
-// packages/cli/src/render/components.tsx
-init_vars();
-var React = __toESM(require_react(), 1);
-var componentRegistry = new Map;
-function getComponentRegistry() {
-  return componentRegistry;
+// node_modules/@iconify/utils/lib/svg/build.js
+var isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+function iconToSVG(icon, customisations) {
+  const fullIcon = {
+    ...defaultIconProps,
+    ...icon
+  };
+  const fullCustomisations = {
+    ...defaultIconCustomisations,
+    ...customisations
+  };
+  const box3 = {
+    left: fullIcon.left,
+    top: fullIcon.top,
+    width: fullIcon.width,
+    height: fullIcon.height
+  };
+  let body = fullIcon.body;
+  [fullIcon, fullCustomisations].forEach((props) => {
+    const transformations = [];
+    const hFlip = props.hFlip;
+    const vFlip = props.vFlip;
+    let rotation = props.rotate;
+    if (hFlip)
+      if (vFlip)
+        rotation += 2;
+      else {
+        transformations.push("translate(" + (box3.width + box3.left).toString() + " " + (0 - box3.top).toString() + ")");
+        transformations.push("scale(-1 1)");
+        box3.top = box3.left = 0;
+      }
+    else if (vFlip) {
+      transformations.push("translate(" + (0 - box3.left).toString() + " " + (box3.height + box3.top).toString() + ")");
+      transformations.push("scale(1 -1)");
+      box3.top = box3.left = 0;
+    }
+    let tempValue;
+    if (rotation < 0)
+      rotation -= Math.floor(rotation / 4) * 4;
+    rotation = rotation % 4;
+    switch (rotation) {
+      case 1:
+        tempValue = box3.height / 2 + box3.top;
+        transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+      case 2:
+        transformations.unshift("rotate(180 " + (box3.width / 2 + box3.left).toString() + " " + (box3.height / 2 + box3.top).toString() + ")");
+        break;
+      case 3:
+        tempValue = box3.width / 2 + box3.left;
+        transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+    }
+    if (rotation % 2 === 1) {
+      if (box3.left !== box3.top) {
+        tempValue = box3.left;
+        box3.left = box3.top;
+        box3.top = tempValue;
+      }
+      if (box3.width !== box3.height) {
+        tempValue = box3.width;
+        box3.width = box3.height;
+        box3.height = tempValue;
+      }
+    }
+    if (transformations.length)
+      body = wrapSVGContent(body, '<g transform="' + transformations.join(" ") + '">', "</g>");
+  });
+  const customisationsWidth = fullCustomisations.width;
+  const customisationsHeight = fullCustomisations.height;
+  const boxWidth = box3.width;
+  const boxHeight = box3.height;
+  let width;
+  let height;
+  if (customisationsWidth === null) {
+    height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    width = calculateSize(height, boxWidth / boxHeight);
+  } else {
+    width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+    height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+  }
+  const attributes = {};
+  const setAttr = (prop, value) => {
+    if (!isUnsetKeyword(value))
+      attributes[prop] = value.toString();
+  };
+  setAttr("width", width);
+  setAttr("height", height);
+  const viewBox = [
+    box3.left,
+    box3.top,
+    boxWidth,
+    boxHeight
+  ];
+  attributes.viewBox = viewBox.join(" ");
+  return {
+    attributes,
+    viewBox,
+    body
+  };
 }
-var c6 = (type) => (props) => React.createElement(type, props);
-var Frame = c6("frame");
-var Rectangle = c6("rectangle");
-var Ellipse = c6("ellipse");
-var Text = c6("text");
-var Line = c6("line");
-var Star = c6("star");
-var Polygon = c6("polygon");
-var Vector = c6("vector");
-var Component = c6("component");
-var Instance = c6("instance");
-var Group = c6("group");
-var Page = c6("page");
-var INTRINSIC_ELEMENTS = [
-  "Frame",
-  "Rectangle",
-  "Ellipse",
-  "Text",
-  "Line",
-  "Star",
-  "Polygon",
-  "Vector",
-  "Component",
-  "Instance",
-  "Group",
-  "Page",
-  "View"
-];
 
-// packages/cli/src/render/component-set.tsx
-var React2 = __toESM(require_react(), 1);
-var componentSetRegistry = new Map;
-function getComponentSetRegistry() {
-  return componentSetRegistry;
+// packages/cli/src/render/icon.ts
+setAPIModule("", fetchAPIModule);
+var iconCache = new Map;
+var rawIconCache = new Map;
+async function loadRawIcon(name) {
+  if (rawIconCache.has(name)) {
+    return rawIconCache.get(name);
+  }
+  const icon = await loadIcon(name);
+  if (!icon) {
+    return null;
+  }
+  rawIconCache.set(name, icon);
+  return icon;
 }
-function generateVariantCombinations(variants) {
-  const keys = Object.keys(variants);
-  if (keys.length === 0)
-    return [{}];
-  const result = [];
-  function combine(index, current) {
-    if (index === keys.length) {
-      result.push(current);
+async function loadIconSvg(name, size = 24) {
+  const cacheKey = `${name}@${size}`;
+  if (iconCache.has(cacheKey)) {
+    return iconCache.get(cacheKey);
+  }
+  const icon = await loadRawIcon(name);
+  if (!icon) {
+    return null;
+  }
+  const result = iconToSVG(icon, { height: size, width: size });
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" ${Object.entries(result.attributes).map(([k6, v3]) => `${k6}="${v3}"`).join(" ")}>${result.body}</svg>`;
+  const data = {
+    svg,
+    width: size,
+    height: size,
+    body: result.body,
+    viewBox: {
+      left: result.viewBox[0],
+      top: result.viewBox[1],
+      width: result.viewBox[2],
+      height: result.viewBox[3]
+    }
+  };
+  iconCache.set(cacheKey, data);
+  return data;
+}
+function getIconData2(name, size = 24) {
+  return iconCache.get(`${name}@${size}`) || null;
+}
+async function preloadIcons(icons) {
+  await Promise.all(icons.map(({ name, size }) => loadIconSvg(name, size || 24)));
+}
+function collectIcons(element) {
+  const icons = [];
+  function traverse(node) {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      node.forEach(traverse);
       return;
     }
-    const key = keys[index];
-    for (const value of variants[key]) {
-      combine(index + 1, { ...current, [key]: value });
+    const el = node;
+    if (!el.type)
+      return;
+    if (el.type === "icon") {
+      const props2 = el.props;
+      if (props2.icon) {
+        icons.push({ name: props2.icon, size: props2.size });
+      }
+    }
+    if (typeof el.type === "function") {
+      try {
+        const Component2 = el.type;
+        const rendered = Component2(el.props);
+        if (rendered)
+          traverse(rendered);
+      } catch {}
+    }
+    const props = el.props;
+    if (props.children) {
+      if (Array.isArray(props.children)) {
+        props.children.forEach(traverse);
+      } else {
+        traverse(props.children);
+      }
     }
   }
-  combine(0, {});
-  return result;
-}
-function buildVariantName(props) {
-  return Object.entries(props).map(([k6, v3]) => `${k6}=${v3}`).join(", ");
-}
-function buildStateGroupPropertyValueOrders(variants) {
-  return Object.entries(variants).map(([property, values]) => ({
-    property,
-    values: [...values]
-  }));
+  traverse(element);
+  return icons;
 }
 
 // packages/cli/src/render/reconciler.ts
@@ -29402,8 +32789,15 @@ function getPendingComponentSetInstances() {
 function clearPendingComponentSetInstances() {
   pendingComponentSetInstances.length = 0;
 }
+var pendingIcons = [];
+function getPendingIcons() {
+  return [...pendingIcons];
+}
+function clearPendingIcons() {
+  pendingIcons.length = 0;
+}
 function styleToNodeChange(type, props, localID, sessionID, parentGUID, position, textContent) {
-  const style = props.style || {};
+  const style = normalizeStyle(props.style || {});
   const name = props.name || type;
   const nodeChange = {
     guid: { sessionID, localID },
@@ -29414,6 +32808,9 @@ function styleToNodeChange(type, props, localID, sessionID, parentGUID, position
     visible: true,
     opacity: typeof style.opacity === "number" ? style.opacity : 1
   };
+  if (mapType(type) === "FRAME") {
+    nodeChange.clipsContent = false;
+  }
   const width = style.width ?? props.width;
   const height = style.height ?? props.height;
   if (width !== undefined && height !== undefined) {
@@ -29565,23 +32962,22 @@ function styleToNodeChange(type, props, localID, sessionID, parentGUID, position
     }
   }
   if (type.toLowerCase() === "text" && textContent) {
-    const nc = nodeChange;
-    nc.textData = { characters: textContent };
-    nc.textAutoResize = "WIDTH_AND_HEIGHT";
-    nc.textAlignVertical = "TOP";
+    nodeChange.textData = { characters: textContent };
+    nodeChange.textAutoResize = "WIDTH_AND_HEIGHT";
+    nodeChange.textAlignVertical = "TOP";
     if (style.fontSize)
-      nc.fontSize = Number(style.fontSize);
-    nc.lineHeight = { value: 100, units: "PERCENT" };
+      nodeChange.fontSize = Number(style.fontSize);
+    nodeChange.lineHeight = { value: 100, units: "PERCENT" };
     const family = style.fontFamily || "Inter";
     const fontStyle = mapFontWeight(style.fontWeight);
-    nc.fontName = {
+    nodeChange.fontName = {
       family,
       style: fontStyle,
       postscript: `${family}-${fontStyle}`.replace(/\s+/g, "")
     };
     if (style.textAlign) {
       const map = { left: "LEFT", center: "CENTER", right: "RIGHT" };
-      nc.textAlignHorizontal = map[style.textAlign] || "LEFT";
+      nodeChange.textAlignHorizontal = map[style.textAlign] || "LEFT";
     }
     if (style.color) {
       const textColor = style.color;
@@ -29615,8 +33011,7 @@ function styleToNodeChange(type, props, localID, sessionID, parentGUID, position
   if (type.toLowerCase() === "instance" && props.componentId) {
     const match = String(props.componentId).match(/(\d+):(\d+)/);
     if (match) {
-      const nc = nodeChange;
-      nc.symbolData = {
+      nodeChange.symbolData = {
         symbolID: {
           sessionID: parseInt(match[1], 10),
           localID: parseInt(match[2], 10)
@@ -29661,7 +33056,31 @@ function mapFontWeight(weight) {
   };
   return map[weight] || "Regular";
 }
-function collectNodeChanges(instance, sessionID, parentGUID, position, result, container) {
+function collectNodeChanges(instance, sessionID, parentGUID, position, childIndex, result, container) {
+  if (instance.type === "icon") {
+    const props = instance.props;
+    const { icon: iconName, size = 24, color, name: nodeName, style = {} } = props;
+    const iconData = getIconData2(iconName, size);
+    if (!iconData) {
+      consola2.error(`Icon "${iconName}" not found. Did you call preloadIcons()?`);
+      return;
+    }
+    let svg = iconData.svg;
+    if (color) {
+      svg = svg.replace(/currentColor/g, color);
+    } else {
+      svg = svg.replace(/currentColor/g, "#000000");
+    }
+    pendingIcons.push({
+      svg,
+      parentGUID,
+      childIndex,
+      x: style.x || 0,
+      y: style.y || 0,
+      name: nodeName || iconName.replace(":", "/")
+    });
+    return;
+  }
   if (instance.type === "__component_instance__") {
     const sym = instance.props.__componentSymbol;
     const name = instance.props.__componentName;
@@ -29682,8 +33101,8 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
         startLocalID: container.localIDCounter
       });
       container.localIDCounter = componentResult.nextLocalID;
-      if (componentResult.nodeChanges.length > 0) {
-        const rootChange = componentResult.nodeChanges[0];
+      const rootChange = componentResult.nodeChanges[0];
+      if (rootChange) {
         const originalRootGUID = { ...rootChange.guid };
         rootChange.guid = componentGUID;
         rootChange.type = "SYMBOL";
@@ -29691,7 +33110,7 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
         rootChange.parentIndex = { guid: parentGUID, position };
         for (let i3 = 1;i3 < componentResult.nodeChanges.length; i3++) {
           const child = componentResult.nodeChanges[i3];
-          if (child.parentIndex?.guid.localID === originalRootGUID.localID && child.parentIndex?.guid.sessionID === originalRootGUID.sessionID) {
+          if (child && child.parentIndex?.guid.localID === originalRootGUID.localID && child.parentIndex?.guid.sessionID === originalRootGUID.sessionID) {
             child.parentIndex.guid = componentGUID;
           }
         }
@@ -29718,8 +33137,7 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
         opacity: 1,
         transform: { m00: 1, m01: 0, m02: x3, m10: 0, m11: 1, m12: y5 }
       };
-      const nc = instanceChange;
-      nc.symbolData = { symbolID: componentGUID };
+      instanceChange.symbolData = { symbolID: componentGUID };
       result.push(instanceChange);
     }
     return;
@@ -29752,13 +33170,12 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
         opacity: 1,
         size: { x: 1, y: 1 }
       };
-      const setNc = setChange;
-      setNc.isStateGroup = true;
-      setNc.stateGroupPropertyValueOrders = buildStateGroupPropertyValueOrders(variants);
-      setNc.stackMode = "HORIZONTAL";
-      setNc.stackSpacing = 20;
-      setNc.stackPrimarySizing = "RESIZE_TO_FIT";
-      setNc.stackCounterSizing = "RESIZE_TO_FIT";
+      setChange.isStateGroup = true;
+      setChange.stateGroupPropertyValueOrders = buildStateGroupPropertyValueOrders(variants);
+      setChange.stackMode = "HORIZONTAL";
+      setChange.stackSpacing = 20;
+      setChange.stackPrimarySizing = "RESIZE_TO_FIT";
+      setChange.stackCounterSizing = "RESIZE_TO_FIT";
       result.push(setChange);
       combinations.forEach((combo, i3) => {
         const variantName = buildVariantName(combo);
@@ -29772,8 +33189,8 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
           startLocalID: container.localIDCounter
         });
         container.localIDCounter = variantResult.nextLocalID;
-        if (variantResult.nodeChanges.length > 0) {
-          const rootChange = variantResult.nodeChanges[0];
+        const rootChange = variantResult.nodeChanges[0];
+        if (rootChange) {
           const originalRootGUID = { ...rootChange.guid };
           rootChange.guid = variantGUID;
           rootChange.type = "SYMBOL";
@@ -29784,7 +33201,7 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
           };
           for (let j = 1;j < variantResult.nodeChanges.length; j++) {
             const child = variantResult.nodeChanges[j];
-            if (child.parentIndex?.guid.localID === originalRootGUID.localID && child.parentIndex?.guid.sessionID === originalRootGUID.sessionID) {
+            if (child && child.parentIndex?.guid.localID === originalRootGUID.localID && child.parentIndex?.guid.sessionID === originalRootGUID.sessionID) {
               child.parentIndex.guid = variantGUID;
             }
           }
@@ -29827,7 +33244,7 @@ function collectNodeChanges(instance, sessionID, parentGUID, position, result, c
   const thisGUID = { sessionID, localID: instance.localID };
   instance.children.forEach((child, i3) => {
     const childPosition = String.fromCharCode(33 + i3 % 90);
-    collectNodeChanges(child, sessionID, thisGUID, childPosition, result, container);
+    collectNodeChanges(child, sessionID, thisGUID, childPosition, i3, result, container);
   });
 }
 var hostConfig = {
@@ -29966,7 +33383,7 @@ function renderToNodeChanges(element, options) {
   const nodeChanges = [];
   container.children.forEach((child, i3) => {
     const position = String.fromCharCode(33 + i3 % 90);
-    collectNodeChanges(child, options.sessionID, options.parentGUID, position, nodeChanges, container);
+    collectNodeChanges(child, options.sessionID, options.parentGUID, position, i3, nodeChanges, container);
   });
   return {
     nodeChanges,
@@ -29976,8 +33393,9 @@ function renderToNodeChanges(element, options) {
 function getDefaultVariants(variants) {
   const defaults = {};
   for (const [key, values] of Object.entries(variants)) {
-    if (values.length > 0) {
-      defaults[key] = values[0];
+    const firstValue = values[0];
+    if (firstValue !== undefined) {
+      defaults[key] = firstValue;
     }
   }
   return defaults;
@@ -29990,6 +33408,13 @@ function resetRenderedComponents() {
 }
 // packages/cli/src/commands/render.ts
 var import_esbuild = __toESM(require_main(), 1);
+
+// packages/cli/src/retry.ts
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// packages/cli/src/commands/render.ts
 var PROXY_URL2 = process.env.FIGMA_PROXY_URL || "http://localhost:38451";
 async function readStdin() {
   const chunks = [];
@@ -30105,9 +33530,11 @@ var render_default = defineCommand({
     stdin: { type: "boolean", description: "Read TSX from stdin" },
     props: { type: "string", description: "JSON props to pass to component" },
     parent: { type: "string", description: "Parent node ID (sessionID:localID)" },
+    x: { type: "string", description: "X position of rendered root" },
+    y: { type: "string", description: "Y position of rendered root" },
     export: { type: "string", description: "Named export (default: default)" },
     json: { type: "boolean", description: "Output as JSON" },
-    dryRun: { type: "boolean", description: "Output NodeChanges without sending to Figma" }
+    "dry-run": { type: "boolean", description: "Output NodeChanges without sending to Figma" }
   },
   async run({ args }) {
     if (args.examples) {
@@ -30184,13 +33611,27 @@ var render_default = defineCommand({
       }
       const props = args.props ? JSON.parse(args.props) : {};
       const element = React3.createElement(Component2, props);
+      const icons = collectIcons(element);
+      if (icons.length > 0) {
+        if (!args.json) {
+          console.log(`Preloading ${icons.length} icon(s)...`);
+        }
+        await preloadIcons(icons);
+      }
       resetRenderedComponents();
       const result = renderToNodeChanges(element, {
         sessionID,
         parentGUID,
         startLocalID: Date.now() % 1e6
       });
-      if (args.dryRun) {
+      const rootNode = result.nodeChanges[0];
+      if ((args.x || args.y) && rootNode?.transform) {
+        if (args.x)
+          rootNode.transform.m02 = Number(args.x);
+        if (args.y)
+          rootNode.transform.m12 = Number(args.y);
+      }
+      if (args["dry-run"]) {
         console.log(JSON.stringify(result.nodeChanges, null, 2));
         return;
       }
@@ -30199,8 +33640,34 @@ var render_default = defineCommand({
       }
       const pendingInstances = getPendingComponentSetInstances();
       clearPendingComponentSetInstances();
+      const pendingIconsList = getPendingIcons();
+      clearPendingIcons();
       await sendNodeChanges(result.nodeChanges, pendingInstances);
-      const rootId = `${result.nodeChanges[0].guid.sessionID}:${result.nodeChanges[0].guid.localID}`;
+      if (pendingIconsList.length > 0) {
+        await sleep(100);
+      }
+      for (const icon of pendingIconsList) {
+        try {
+          const parentId = `${icon.parentGUID.sessionID}:${icon.parentGUID.localID}`;
+          await sendCommand("import-svg", {
+            svg: icon.svg,
+            x: icon.x,
+            y: icon.y,
+            parentId,
+            name: icon.name,
+            noFill: true,
+            insertIndex: icon.childIndex
+          });
+        } catch (e6) {
+          consola2.error(`Failed to import icon "${icon.name}":`, e6);
+        }
+      }
+      const firstNode = result.nodeChanges[0];
+      if (!firstNode) {
+        console.error(fail("No nodes rendered"));
+        process.exit(1);
+      }
+      const rootId = `${firstNode.guid.sessionID}:${firstNode.guid.localID}`;
       try {
         await sendCommand("trigger-layout", {
           nodeId: rootId,
@@ -30510,7 +33977,8 @@ var diff_default = defineCommand({
   subCommands: {
     apply: () => Promise.resolve().then(() => (init_apply2(), exports_apply)).then((m3) => m3.default),
     show: () => Promise.resolve().then(() => (init_show(), exports_show)).then((m3) => m3.default),
-    create: () => Promise.resolve().then(() => (init_create2(), exports_create)).then((m3) => m3.default)
+    create: () => Promise.resolve().then(() => (init_create2(), exports_create)).then((m3) => m3.default),
+    visual: () => Promise.resolve().then(() => (init_visual(), exports_visual)).then((m3) => m3.default)
   }
 });
 // packages/cli/src/commands/node/index.ts
@@ -30847,7 +34315,7 @@ var to_component_default = defineCommand({
         }
       }
     } catch (error) {
-      handleError(error, args.json);
+      handleError(error);
     }
   }
 });
@@ -31058,9 +34526,9 @@ var rect_default = defineCommand({
     height: { type: "string", description: "Height", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     radius: { type: "string", description: "Corner radius" },
     opacity: { type: "string", description: "Opacity (0-1)" },
     json: { type: "boolean", description: "Output as JSON" }
@@ -31076,7 +34544,7 @@ var rect_default = defineCommand({
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined,
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined,
         radius: args.radius ? Number(args.radius) : undefined,
         opacity: args.opacity ? Number(args.opacity) : undefined
       });
@@ -31099,9 +34567,9 @@ var ellipse_default = defineCommand({
     height: { type: "string", description: "Height", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     opacity: { type: "string", description: "Opacity (0-1)" },
     json: { type: "boolean", description: "Output as JSON" }
   },
@@ -31116,7 +34584,7 @@ var ellipse_default = defineCommand({
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined,
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined,
         opacity: args.opacity ? Number(args.opacity) : undefined
       });
       printResult(result, args.json, "create");
@@ -31137,8 +34605,8 @@ var line_default = defineCommand({
     length: { type: "string", description: "Length", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31150,7 +34618,7 @@ var line_default = defineCommand({
         name: args.name,
         parentId: args.parent,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined
       });
       printResult(result, args.json, "create");
     } catch (e6) {
@@ -31171,9 +34639,9 @@ var polygon_default = defineCommand({
     sides: { type: "string", description: "Number of sides", default: "6" },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31187,7 +34655,7 @@ var polygon_default = defineCommand({
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined
       });
       printResult(result, args.json, "create");
     } catch (e6) {
@@ -31206,12 +34674,12 @@ var star_default = defineCommand({
     y: { type: "string", description: "Y coordinate", required: true },
     size: { type: "string", description: "Size (width/height)", required: true },
     points: { type: "string", description: "Number of points", default: "5" },
-    innerRatio: { type: "string", description: "Inner radius ratio (0-1)", default: "0.5" },
+    "inner-ratio": { type: "string", description: "Inner radius ratio (0-1)", default: "0.5" },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31221,12 +34689,12 @@ var star_default = defineCommand({
         y: Number(args.y),
         size: Number(args.size),
         points: Number(args.points),
-        innerRadius: Number(args.innerRatio),
+        innerRadius: Number(args["inner-ratio"]),
         name: args.name,
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined
       });
       printResult(result, args.json, "create");
     } catch (e6) {
@@ -31246,9 +34714,9 @@ var vector_default = defineCommand({
     path: { type: "string", description: "SVG path data", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31261,7 +34729,7 @@ var vector_default = defineCommand({
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined
       });
       printResult(result, args.json, "create");
     } catch (e6) {
@@ -31282,9 +34750,9 @@ var frame_default = defineCommand({
     height: { type: "string", description: "Height", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
-    stroke: { type: "string", description: "Stroke color (hex)" },
-    strokeWeight: { type: "string", description: "Stroke weight" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
+    stroke: { type: "string", description: "Stroke color (hex or var:Name)" },
+    "stroke-weight": { type: "string", description: "Stroke weight" },
     radius: { type: "string", description: "Corner radius" },
     opacity: { type: "string", description: "Opacity (0-1)" },
     layout: { type: "string", description: "Layout mode: HORIZONTAL, VERTICAL, NONE" },
@@ -31298,7 +34766,8 @@ var frame_default = defineCommand({
       if (args.padding) {
         const parts = args.padding.split(",").map(Number);
         if (parts.length === 1) {
-          paddingObj = { top: parts[0], right: parts[0], bottom: parts[0], left: parts[0] };
+          const p4 = parts[0];
+          paddingObj = { top: p4, right: p4, bottom: p4, left: p4 };
         } else if (parts.length === 4) {
           paddingObj = { top: parts[0], right: parts[1], bottom: parts[2], left: parts[3] };
         }
@@ -31312,7 +34781,7 @@ var frame_default = defineCommand({
         parentId: args.parent,
         fill: args.fill,
         stroke: args.stroke,
-        strokeWeight: args.strokeWeight ? Number(args.strokeWeight) : undefined,
+        strokeWeight: args["stroke-weight"] ? Number(args["stroke-weight"]) : undefined,
         radius: args.radius ? Number(args.radius) : undefined,
         opacity: args.opacity ? Number(args.opacity) : undefined,
         layoutMode: args.layout,
@@ -31335,10 +34804,10 @@ var text_default = defineCommand({
     x: { type: "string", description: "X coordinate", required: true },
     y: { type: "string", description: "Y coordinate", required: true },
     text: { type: "string", description: "Text content", required: true },
-    fontSize: { type: "string", description: "Font size" },
-    fontFamily: { type: "string", description: "Font family (default: Inter)" },
-    fontStyle: { type: "string", description: "Font style (Regular, Bold, Medium, etc)" },
-    fill: { type: "string", description: "Text color (hex)" },
+    "font-size": { type: "string", description: "Font size" },
+    "font-family": { type: "string", description: "Font family (default: Inter)" },
+    "font-style": { type: "string", description: "Font style (Regular, Bold, Medium, etc)" },
+    fill: { type: "string", description: "Text color (hex or var:Name)" },
     opacity: { type: "string", description: "Opacity (0-1)" },
     name: { type: "string", description: "Node name" },
     parent: { type: "string", description: "Parent node ID" },
@@ -31350,9 +34819,9 @@ var text_default = defineCommand({
         x: Number(args.x),
         y: Number(args.y),
         text: args.text,
-        fontSize: args.fontSize ? Number(args.fontSize) : undefined,
-        fontFamily: args.fontFamily,
-        fontStyle: args.fontStyle,
+        fontSize: args["font-size"] ? Number(args["font-size"]) : undefined,
+        fontFamily: args["font-family"],
+        fontStyle: args["font-style"],
         fill: args.fill,
         opacity: args.opacity ? Number(args.opacity) : undefined,
         name: args.name,
@@ -31377,7 +34846,7 @@ var component_default = defineCommand({
     height: { type: "string", description: "Height", required: true },
     name: { type: "string", description: "Name" },
     parent: { type: "string", description: "Parent node ID" },
-    fill: { type: "string", description: "Fill color (hex)" },
+    fill: { type: "string", description: "Fill color (hex or var:Name)" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31508,6 +34977,77 @@ var slice_default = defineCommand({
   }
 });
 
+// packages/cli/src/commands/create/icon.ts
+init_dist2();
+init_client();
+init_format();
+var VAR_PREFIX_RE = /^(?:var:|[$])(.+)$/;
+async function replaceSvgCurrentColor(svg, color) {
+  const rewriter = new HTMLRewriter().on("*", {
+    element(el) {
+      if (el.getAttribute("fill") === "currentColor") {
+        el.setAttribute("fill", color);
+      }
+      if (el.getAttribute("stroke") === "currentColor") {
+        el.setAttribute("stroke", color);
+      }
+    }
+  });
+  return await rewriter.transform(new Response(svg)).text();
+}
+var icon_default = defineCommand({
+  meta: { description: "Create an icon from Iconify" },
+  args: {
+    name: { type: "positional", description: "Icon name (e.g., mdi:home, lucide:star)", required: true },
+    x: { type: "string", description: "X coordinate", default: "0" },
+    y: { type: "string", description: "Y coordinate", default: "0" },
+    size: { type: "string", description: "Size in pixels", default: "24" },
+    color: { type: "string", description: "Icon color (hex or var:Name)" },
+    parent: { type: "string", description: "Parent node ID" },
+    component: { type: "boolean", description: "Create as Figma component" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    try {
+      const size = Number(args.size);
+      const iconData = await loadIconSvg(args.name, size);
+      if (!iconData) {
+        console.error(fail(`Icon "${args.name}" not found`));
+        process.exit(1);
+      }
+      const varMatch = args.color?.match(VAR_PREFIX_RE);
+      const hexColor = varMatch ? "#000000" : args.color || "#000000";
+      const svg = await replaceSvgCurrentColor(iconData.svg, hexColor);
+      const result = await sendCommand("import-svg", {
+        svg,
+        x: Number(args.x),
+        y: Number(args.y),
+        parentId: args.parent
+      });
+      const iconName = args.name.replace(":", "/");
+      await sendCommand("rename-node", { id: result.id, name: iconName });
+      if (varMatch) {
+        await sendCommand("bind-fill-variable-by-name", {
+          id: result.id,
+          variableName: varMatch[1],
+          recursive: true
+        });
+      }
+      let finalId = result.id;
+      if (args.component) {
+        const componentResult = await sendCommand("convert-to-component", {
+          id: result.id
+        });
+        finalId = componentResult.id;
+      }
+      const finalResult = await sendCommand("get-node-info", { id: finalId });
+      printResult(finalResult, args.json, "create");
+    } catch (e6) {
+      handleError(e6);
+    }
+  }
+});
+
 // packages/cli/src/commands/create/index.ts
 var create_default2 = defineCommand({
   meta: { description: "Create nodes" },
@@ -31524,7 +35064,8 @@ var create_default2 = defineCommand({
     instance: instance_default,
     section: section_default,
     page: page_default,
-    slice: slice_default
+    slice: slice_default,
+    icon: icon_default
   }
 });
 // packages/cli/src/commands/set/index.ts
@@ -31537,7 +35078,7 @@ var fill_default = defineCommand({
   meta: { description: "Set fill color" },
   args: {
     id: { type: "positional", description: "Node ID", required: true },
-    color: { type: "positional", description: "Color (hex)", required: true },
+    color: { type: "positional", description: "Color (hex or var:Name)", required: true },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31557,7 +35098,7 @@ var stroke_default = defineCommand({
   meta: { description: "Set stroke color and weight" },
   args: {
     id: { type: "positional", description: "Node ID", required: true },
-    color: { type: "positional", description: "Color (hex)", required: true },
+    color: { type: "positional", description: "Color (hex or var:Name)", required: true },
     weight: { type: "string", description: "Stroke weight" },
     align: { type: "string", description: "Stroke align: INSIDE, CENTER, OUTSIDE" },
     json: { type: "boolean", description: "Output as JSON" }
@@ -31609,10 +35150,10 @@ var radius_default = defineCommand({
   args: {
     id: { type: "positional", description: "Node ID", required: true },
     radius: { type: "string", description: "Uniform radius" },
-    topLeft: { type: "string", description: "Top left radius" },
-    topRight: { type: "string", description: "Top right radius" },
-    bottomLeft: { type: "string", description: "Bottom left radius" },
-    bottomRight: { type: "string", description: "Bottom right radius" },
+    "top-left": { type: "string", description: "Top left radius" },
+    "top-right": { type: "string", description: "Top right radius" },
+    "bottom-left": { type: "string", description: "Bottom left radius" },
+    "bottom-right": { type: "string", description: "Bottom right radius" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31620,10 +35161,10 @@ var radius_default = defineCommand({
       const result = await sendCommand("set-corner-radius", {
         id: args.id,
         cornerRadius: args.radius ? Number(args.radius) : 0,
-        topLeftRadius: args.topLeft ? Number(args.topLeft) : undefined,
-        topRightRadius: args.topRight ? Number(args.topRight) : undefined,
-        bottomLeftRadius: args.bottomLeft ? Number(args.bottomLeft) : undefined,
-        bottomRightRadius: args.bottomRight ? Number(args.bottomRight) : undefined
+        topLeftRadius: args["top-left"] ? Number(args["top-left"]) : undefined,
+        topRightRadius: args["top-right"] ? Number(args["top-right"]) : undefined,
+        bottomLeftRadius: args["bottom-left"] ? Number(args["bottom-left"]) : undefined,
+        bottomRightRadius: args["bottom-right"] ? Number(args["bottom-right"]) : undefined
       });
       printResult(result, args.json);
     } catch (e6) {
@@ -31659,7 +35200,7 @@ var rotation_default = defineCommand({
   meta: { description: "Set rotation angle" },
   args: {
     id: { type: "positional", description: "Node ID", required: true },
-    angle: { type: "positional", description: "Angle in degrees", required: true },
+    angle: { type: "string", description: "Angle in degrees", required: true },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31775,7 +35316,7 @@ var font_range_default = defineCommand({
     family: { type: "string", description: "Font family" },
     style: { type: "string", description: "Font style (Regular, Bold, Italic, etc)" },
     size: { type: "string", description: "Font size" },
-    color: { type: "string", description: "Text color (hex)" },
+    color: { type: "string", description: "Text color (hex or var:Name)" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -31791,7 +35332,7 @@ var font_range_default = defineCommand({
       });
       printResult(result, args.json);
     } catch (error) {
-      handleError(error, args.json);
+      handleError(error);
     }
   }
 });
@@ -31809,8 +35350,8 @@ var effect_default = defineCommand({
       required: true
     },
     radius: { type: "string", description: "Blur radius" },
-    offsetX: { type: "string", description: "Shadow offset X" },
-    offsetY: { type: "string", description: "Shadow offset Y" },
+    "offset-x": { type: "string", description: "Shadow offset X" },
+    "offset-y": { type: "string", description: "Shadow offset Y" },
     color: { type: "string", description: "Shadow color (hex with alpha)" },
     spread: { type: "string", description: "Shadow spread" },
     json: { type: "boolean", description: "Output as JSON" }
@@ -31821,8 +35362,8 @@ var effect_default = defineCommand({
         id: args.id,
         type: args.type,
         radius: args.radius ? Number(args.radius) : undefined,
-        offsetX: args.offsetX ? Number(args.offsetX) : undefined,
-        offsetY: args.offsetY ? Number(args.offsetY) : undefined,
+        offsetX: args["offset-x"] ? Number(args["offset-x"]) : undefined,
+        offsetY: args["offset-y"] ? Number(args["offset-y"]) : undefined,
         color: args.color,
         spread: args.spread ? Number(args.spread) : undefined
       });
@@ -31847,7 +35388,7 @@ var layout_default = defineCommand({
       type: "string",
       description: "Primary axis alignment: MIN, CENTER, MAX, SPACE_BETWEEN"
     },
-    counterAlign: {
+    "counter-align": {
       type: "string",
       description: "Counter axis alignment: MIN, CENTER, MAX, BASELINE"
     },
@@ -31860,7 +35401,8 @@ var layout_default = defineCommand({
       if (args.padding) {
         const parts = args.padding.split(",").map(Number);
         if (parts.length === 1) {
-          paddingObj = { top: parts[0], right: parts[0], bottom: parts[0], left: parts[0] };
+          const p4 = parts[0];
+          paddingObj = { top: p4, right: p4, bottom: p4, left: p4 };
         } else if (parts.length === 4) {
           paddingObj = { top: parts[0], right: parts[1], bottom: parts[2], left: parts[3] };
         }
@@ -31871,7 +35413,7 @@ var layout_default = defineCommand({
         itemSpacing: args.gap ? Number(args.gap) : undefined,
         padding: paddingObj,
         primaryAlign: args.align,
-        counterAlign: args.counterAlign,
+        counterAlign: args["counter-align"],
         wrap: args.wrap
       });
       printResult(result, args.json);
@@ -32008,20 +35550,20 @@ var minmax_default = defineCommand({
   meta: { description: "Set min/max width and height constraints" },
   args: {
     id: { type: "positional", description: "Node ID", required: true },
-    minWidth: { type: "string", description: "Minimum width" },
-    maxWidth: { type: "string", description: "Maximum width" },
-    minHeight: { type: "string", description: "Minimum height" },
-    maxHeight: { type: "string", description: "Maximum height" },
+    "min-width": { type: "string", description: "Minimum width" },
+    "max-width": { type: "string", description: "Maximum width" },
+    "min-height": { type: "string", description: "Minimum height" },
+    "max-height": { type: "string", description: "Maximum height" },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
     try {
       const result = await sendCommand("set-min-max", {
         id: args.id,
-        minWidth: args.minWidth ? Number(args.minWidth) : undefined,
-        maxWidth: args.maxWidth ? Number(args.maxWidth) : undefined,
-        minHeight: args.minHeight ? Number(args.minHeight) : undefined,
-        maxHeight: args.maxHeight ? Number(args.maxHeight) : undefined
+        minWidth: args["min-width"] ? Number(args["min-width"]) : undefined,
+        maxWidth: args["max-width"] ? Number(args["max-width"]) : undefined,
+        minHeight: args["min-height"] ? Number(args["min-height"]) : undefined,
+        maxHeight: args["max-height"] ? Number(args["max-height"]) : undefined
       });
       printResult(result, args.json, "update");
     } catch (e6) {
@@ -32377,6 +35919,30 @@ var export_default = defineCommand({
 // packages/cli/src/commands/page/index.ts
 init_dist2();
 
+// packages/cli/src/commands/page/current.ts
+init_dist2();
+init_client();
+var current_default = defineCommand({
+  meta: { description: "Get current page" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    try {
+      const result = await sendCommand("eval", {
+        code: "return { id: figma.currentPage.id, name: figma.currentPage.name }"
+      });
+      if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`${result.name} (${result.id})`);
+      }
+    } catch (e6) {
+      handleError(e6);
+    }
+  }
+});
+
 // packages/cli/src/commands/page/list.ts
 init_dist2();
 init_client();
@@ -32418,6 +35984,7 @@ var set_default4 = defineCommand({
 var page_default2 = defineCommand({
   meta: { description: "Page operations" },
   subCommands: {
+    current: current_default,
     list: list_default2,
     set: set_default4
   }
@@ -32770,7 +36337,7 @@ var create_paint_default = defineCommand({
   meta: { description: "Create a paint/color style" },
   args: {
     name: { type: "positional", description: "Style name", required: true },
-    color: { type: "string", description: "Color (hex)", required: true },
+    color: { type: "string", description: "Color (hex or var:Name)", required: true },
     json: { type: "boolean", description: "Output as JSON" }
   },
   async run({ args }) {
@@ -32823,8 +36390,8 @@ var create_effect_default = defineCommand({
       required: true
     },
     radius: { type: "string", description: "Blur radius" },
-    offsetX: { type: "string", description: "Shadow offset X" },
-    offsetY: { type: "string", description: "Shadow offset Y" },
+    "offset-x": { type: "string", description: "Shadow offset X" },
+    "offset-y": { type: "string", description: "Shadow offset Y" },
     color: { type: "string", description: "Shadow color (hex with alpha)" },
     json: { type: "boolean", description: "Output as JSON" }
   },
@@ -32834,8 +36401,8 @@ var create_effect_default = defineCommand({
         name: args.name,
         type: args.type,
         radius: args.radius ? Number(args.radius) : undefined,
-        offsetX: args.offsetX ? Number(args.offsetX) : undefined,
-        offsetY: args.offsetY ? Number(args.offsetY) : undefined,
+        offsetX: args["offset-x"] ? Number(args["offset-x"]) : undefined,
+        offsetY: args["offset-y"] ? Number(args["offset-y"]) : undefined,
         color: args.color
       });
       printResult(result, args.json);
@@ -33065,7 +36632,7 @@ var edit_prop_default = defineCommand({
   args: {
     id: { type: "positional", description: "Component ID", required: true },
     name: { type: "string", description: "Property name", required: true },
-    newName: { type: "string", description: "New name" },
+    "new-name": { type: "string", description: "New name" },
     default: { type: "string", description: "New default value" },
     json: { type: "boolean", description: "Output as JSON" }
   },
@@ -33074,7 +36641,7 @@ var edit_prop_default = defineCommand({
       const result = await sendCommand("edit-component-property", {
         componentId: args.id,
         propertyName: args.name,
-        newName: args.newName,
+        newName: args["new-name"],
         newDefaultValue: args.default
       });
       printResult(result, args.json, "update");
@@ -33357,7 +36924,7 @@ var font_default2 = defineCommand({
   }
 });
 // package.json
-var version = "0.6.2";
+var version = "0.7.0";
 
 // packages/cli/src/index.ts
 var main = defineCommand({