@energy8platform/golem 0.1.1 → 0.2.1

package/dist/editor.js

@@ -42875,6 +42875,818 @@ var init_TextStyle = __esm({
   }
 });
 
+// node_modules/gifenc/dist/gifenc.js
+var require_gifenc = __commonJS({
+  "node_modules/gifenc/dist/gifenc.js"(exports) {
+    var __defProp2 = Object.defineProperty;
+    var __markAsModule = (target) => __defProp2(target, "__esModule", { value: true });
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    __markAsModule(exports);
+    __export2(exports, {
+      GIFEncoder: () => GIFEncoder2,
+      applyPalette: () => applyPalette2,
+      default: () => src_default,
+      nearestColor: () => nearestColor,
+      nearestColorIndex: () => nearestColorIndex,
+      nearestColorIndexWithDistance: () => nearestColorIndexWithDistance,
+      prequantize: () => prequantize,
+      quantize: () => quantize2,
+      snapColorsToPalette: () => snapColorsToPalette
+    });
+    var constants_default = {
+      signature: "GIF",
+      version: "89a",
+      trailer: 59,
+      extensionIntroducer: 33,
+      applicationExtensionLabel: 255,
+      graphicControlExtensionLabel: 249,
+      imageSeparator: 44,
+      signatureSize: 3,
+      versionSize: 3,
+      globalColorTableFlagMask: 128,
+      colorResolutionMask: 112,
+      sortFlagMask: 8,
+      globalColorTableSizeMask: 7,
+      applicationIdentifierSize: 8,
+      applicationAuthCodeSize: 3,
+      disposalMethodMask: 28,
+      userInputFlagMask: 2,
+      transparentColorFlagMask: 1,
+      localColorTableFlagMask: 128,
+      interlaceFlagMask: 64,
+      idSortFlagMask: 32,
+      localColorTableSizeMask: 7
+    };
+    function createStream(initialCapacity = 256) {
+      let cursor2 = 0;
+      let contents = new Uint8Array(initialCapacity);
+      return {
+        get buffer() {
+          return contents.buffer;
+        },
+        reset() {
+          cursor2 = 0;
+        },
+        bytesView() {
+          return contents.subarray(0, cursor2);
+        },
+        bytes() {
+          return contents.slice(0, cursor2);
+        },
+        writeByte(byte) {
+          expand(cursor2 + 1);
+          contents[cursor2] = byte;
+          cursor2++;
+        },
+        writeBytes(data, offset = 0, byteLength = data.length) {
+          expand(cursor2 + byteLength);
+          for (let i6 = 0; i6 < byteLength; i6++) {
+            contents[cursor2++] = data[i6 + offset];
+          }
+        },
+        writeBytesView(data, offset = 0, byteLength = data.byteLength) {
+          expand(cursor2 + byteLength);
+          contents.set(data.subarray(offset, offset + byteLength), cursor2);
+          cursor2 += byteLength;
+        }
+      };
+      function expand(newCapacity) {
+        var prevCapacity = contents.length;
+        if (prevCapacity >= newCapacity)
+          return;
+        var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+        newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
+        if (prevCapacity != 0)
+          newCapacity = Math.max(newCapacity, 256);
+        const oldContents = contents;
+        contents = new Uint8Array(newCapacity);
+        if (cursor2 > 0)
+          contents.set(oldContents.subarray(0, cursor2), 0);
+      }
+    }
+    var BITS = 12;
+    var DEFAULT_HSIZE = 5003;
+    var MASKS = [
+      0,
+      1,
+      3,
+      7,
+      15,
+      31,
+      63,
+      127,
+      255,
+      511,
+      1023,
+      2047,
+      4095,
+      8191,
+      16383,
+      32767,
+      65535
+    ];
+    function lzwEncode(width, height, pixels, colorDepth, outStream = createStream(512), accum = new Uint8Array(256), htab = new Int32Array(DEFAULT_HSIZE), codetab = new Int32Array(DEFAULT_HSIZE)) {
+      const hsize = htab.length;
+      const initCodeSize = Math.max(2, colorDepth);
+      accum.fill(0);
+      codetab.fill(0);
+      htab.fill(-1);
+      let cur_accum = 0;
+      let cur_bits = 0;
+      const init_bits = initCodeSize + 1;
+      const g_init_bits = init_bits;
+      let clear_flg = false;
+      let n_bits = g_init_bits;
+      let maxcode = (1 << n_bits) - 1;
+      const ClearCode = 1 << init_bits - 1;
+      const EOFCode = ClearCode + 1;
+      let free_ent = ClearCode + 2;
+      let a_count = 0;
+      let ent = pixels[0];
+      let hshift = 0;
+      for (let fcode = hsize; fcode < 65536; fcode *= 2) {
+        ++hshift;
+      }
+      hshift = 8 - hshift;
+      outStream.writeByte(initCodeSize);
+      output(ClearCode);
+      const length2 = pixels.length;
+      for (let idx = 1; idx < length2; idx++) {
+        next_block: {
+          const c5 = pixels[idx];
+          const fcode = (c5 << BITS) + ent;
+          let i6 = c5 << hshift ^ ent;
+          if (htab[i6] === fcode) {
+            ent = codetab[i6];
+            break next_block;
+          }
+          const disp = i6 === 0 ? 1 : hsize - i6;
+          while (htab[i6] >= 0) {
+            i6 -= disp;
+            if (i6 < 0)
+              i6 += hsize;
+            if (htab[i6] === fcode) {
+              ent = codetab[i6];
+              break next_block;
+            }
+          }
+          output(ent);
+          ent = c5;
+          if (free_ent < 1 << BITS) {
+            codetab[i6] = free_ent++;
+            htab[i6] = fcode;
+          } else {
+            htab.fill(-1);
+            free_ent = ClearCode + 2;
+            clear_flg = true;
+            output(ClearCode);
+          }
+        }
+      }
+      output(ent);
+      output(EOFCode);
+      outStream.writeByte(0);
+      return outStream.bytesView();
+      function output(code) {
+        cur_accum &= MASKS[cur_bits];
+        if (cur_bits > 0)
+          cur_accum |= code << cur_bits;
+        else
+          cur_accum = code;
+        cur_bits += n_bits;
+        while (cur_bits >= 8) {
+          accum[a_count++] = cur_accum & 255;
+          if (a_count >= 254) {
+            outStream.writeByte(a_count);
+            outStream.writeBytesView(accum, 0, a_count);
+            a_count = 0;
+          }
+          cur_accum >>= 8;
+          cur_bits -= 8;
+        }
+        if (free_ent > maxcode || clear_flg) {
+          if (clear_flg) {
+            n_bits = g_init_bits;
+            maxcode = (1 << n_bits) - 1;
+            clear_flg = false;
+          } else {
+            ++n_bits;
+            maxcode = n_bits === BITS ? 1 << n_bits : (1 << n_bits) - 1;
+          }
+        }
+        if (code == EOFCode) {
+          while (cur_bits > 0) {
+            accum[a_count++] = cur_accum & 255;
+            if (a_count >= 254) {
+              outStream.writeByte(a_count);
+              outStream.writeBytesView(accum, 0, a_count);
+              a_count = 0;
+            }
+            cur_accum >>= 8;
+            cur_bits -= 8;
+          }
+          if (a_count > 0) {
+            outStream.writeByte(a_count);
+            outStream.writeBytesView(accum, 0, a_count);
+            a_count = 0;
+          }
+        }
+      }
+    }
+    var lzwEncode_default = lzwEncode;
+    function rgb888_to_rgb565(r5, g4, b4) {
+      return r5 << 8 & 63488 | g4 << 2 & 992 | b4 >> 3;
+    }
+    function rgba8888_to_rgba4444(r5, g4, b4, a5) {
+      return r5 >> 4 | g4 & 240 | (b4 & 240) << 4 | (a5 & 240) << 8;
+    }
+    function rgb888_to_rgb444(r5, g4, b4) {
+      return r5 >> 4 << 8 | g4 & 240 | b4 >> 4;
+    }
+    function clamp3(value, min, max) {
+      return value < min ? min : value > max ? max : value;
+    }
+    function sqr(value) {
+      return value * value;
+    }
+    function find_nn(bins, idx, hasAlpha) {
+      var nn = 0;
+      var err = 1e100;
+      const bin1 = bins[idx];
+      const n1 = bin1.cnt;
+      const wa = bin1.ac;
+      const wr = bin1.rc;
+      const wg = bin1.gc;
+      const wb = bin1.bc;
+      for (var i6 = bin1.fw; i6 != 0; i6 = bins[i6].fw) {
+        const bin = bins[i6];
+        const n22 = bin.cnt;
+        const nerr2 = n1 * n22 / (n1 + n22);
+        if (nerr2 >= err)
+          continue;
+        var nerr = 0;
+        if (hasAlpha) {
+          nerr += nerr2 * sqr(bin.ac - wa);
+          if (nerr >= err)
+            continue;
+        }
+        nerr += nerr2 * sqr(bin.rc - wr);
+        if (nerr >= err)
+          continue;
+        nerr += nerr2 * sqr(bin.gc - wg);
+        if (nerr >= err)
+          continue;
+        nerr += nerr2 * sqr(bin.bc - wb);
+        if (nerr >= err)
+          continue;
+        err = nerr;
+        nn = i6;
+      }
+      bin1.err = err;
+      bin1.nn = nn;
+    }
+    function create_bin() {
+      return {
+        ac: 0,
+        rc: 0,
+        gc: 0,
+        bc: 0,
+        cnt: 0,
+        nn: 0,
+        fw: 0,
+        bk: 0,
+        tm: 0,
+        mtm: 0,
+        err: 0
+      };
+    }
+    function create_bin_list(data, format) {
+      const bincount = format === "rgb444" ? 4096 : 65536;
+      const bins = new Array(bincount);
+      const size = data.length;
+      if (format === "rgba4444") {
+        for (let i6 = 0; i6 < size; ++i6) {
+          const color = data[i6];
+          const a5 = color >> 24 & 255;
+          const b4 = color >> 16 & 255;
+          const g4 = color >> 8 & 255;
+          const r5 = color & 255;
+          const index = rgba8888_to_rgba4444(r5, g4, b4, a5);
+          let bin = index in bins ? bins[index] : bins[index] = create_bin();
+          bin.rc += r5;
+          bin.gc += g4;
+          bin.bc += b4;
+          bin.ac += a5;
+          bin.cnt++;
+        }
+      } else if (format === "rgb444") {
+        for (let i6 = 0; i6 < size; ++i6) {
+          const color = data[i6];
+          const b4 = color >> 16 & 255;
+          const g4 = color >> 8 & 255;
+          const r5 = color & 255;
+          const index = rgb888_to_rgb444(r5, g4, b4);
+          let bin = index in bins ? bins[index] : bins[index] = create_bin();
+          bin.rc += r5;
+          bin.gc += g4;
+          bin.bc += b4;
+          bin.cnt++;
+        }
+      } else {
+        for (let i6 = 0; i6 < size; ++i6) {
+          const color = data[i6];
+          const b4 = color >> 16 & 255;
+          const g4 = color >> 8 & 255;
+          const r5 = color & 255;
+          const index = rgb888_to_rgb565(r5, g4, b4);
+          let bin = index in bins ? bins[index] : bins[index] = create_bin();
+          bin.rc += r5;
+          bin.gc += g4;
+          bin.bc += b4;
+          bin.cnt++;
+        }
+      }
+      return bins;
+    }
+    function quantize2(rgba, maxColors, opts = {}) {
+      const {
+        format = "rgb565",
+        clearAlpha = true,
+        clearAlphaColor = 0,
+        clearAlphaThreshold = 0,
+        oneBitAlpha = false
+      } = opts;
+      if (!rgba || !rgba.buffer) {
+        throw new Error("quantize() expected RGBA Uint8Array data");
+      }
+      if (!(rgba instanceof Uint8Array) && !(rgba instanceof Uint8ClampedArray)) {
+        throw new Error("quantize() expected RGBA Uint8Array data");
+      }
+      const data = new Uint32Array(rgba.buffer);
+      let useSqrt = opts.useSqrt !== false;
+      const hasAlpha = format === "rgba4444";
+      const bins = create_bin_list(data, format);
+      const bincount = bins.length;
+      const bincountMinusOne = bincount - 1;
+      const heap = new Uint32Array(bincount + 1);
+      var maxbins = 0;
+      for (var i6 = 0; i6 < bincount; ++i6) {
+        const bin = bins[i6];
+        if (bin != null) {
+          var d5 = 1 / bin.cnt;
+          if (hasAlpha)
+            bin.ac *= d5;
+          bin.rc *= d5;
+          bin.gc *= d5;
+          bin.bc *= d5;
+          bins[maxbins++] = bin;
+        }
+      }
+      if (sqr(maxColors) / maxbins < 0.022) {
+        useSqrt = false;
+      }
+      var i6 = 0;
+      for (; i6 < maxbins - 1; ++i6) {
+        bins[i6].fw = i6 + 1;
+        bins[i6 + 1].bk = i6;
+        if (useSqrt)
+          bins[i6].cnt = Math.sqrt(bins[i6].cnt);
+      }
+      if (useSqrt)
+        bins[i6].cnt = Math.sqrt(bins[i6].cnt);
+      var h6, l6, l22;
+      for (i6 = 0; i6 < maxbins; ++i6) {
+        find_nn(bins, i6, false);
+        var err = bins[i6].err;
+        for (l6 = ++heap[0]; l6 > 1; l6 = l22) {
+          l22 = l6 >> 1;
+          if (bins[h6 = heap[l22]].err <= err)
+            break;
+          heap[l6] = h6;
+        }
+        heap[l6] = i6;
+      }
+      var extbins = maxbins - maxColors;
+      for (i6 = 0; i6 < extbins; ) {
+        var tb;
+        for (; ; ) {
+          var b1 = heap[1];
+          tb = bins[b1];
+          if (tb.tm >= tb.mtm && bins[tb.nn].mtm <= tb.tm)
+            break;
+          if (tb.mtm == bincountMinusOne)
+            b1 = heap[1] = heap[heap[0]--];
+          else {
+            find_nn(bins, b1, false);
+            tb.tm = i6;
+          }
+          var err = bins[b1].err;
+          for (l6 = 1; (l22 = l6 + l6) <= heap[0]; l6 = l22) {
+            if (l22 < heap[0] && bins[heap[l22]].err > bins[heap[l22 + 1]].err)
+              l22++;
+            if (err <= bins[h6 = heap[l22]].err)
+              break;
+            heap[l6] = h6;
+          }
+          heap[l6] = b1;
+        }
+        var nb = bins[tb.nn];
+        var n1 = tb.cnt;
+        var n22 = nb.cnt;
+        var d5 = 1 / (n1 + n22);
+        if (hasAlpha)
+          tb.ac = d5 * (n1 * tb.ac + n22 * nb.ac);
+        tb.rc = d5 * (n1 * tb.rc + n22 * nb.rc);
+        tb.gc = d5 * (n1 * tb.gc + n22 * nb.gc);
+        tb.bc = d5 * (n1 * tb.bc + n22 * nb.bc);
+        tb.cnt += nb.cnt;
+        tb.mtm = ++i6;
+        bins[nb.bk].fw = nb.fw;
+        bins[nb.fw].bk = nb.bk;
+        nb.mtm = bincountMinusOne;
+      }
+      let palette = [];
+      var k4 = 0;
+      for (i6 = 0; ; ++k4) {
+        let r5 = clamp3(Math.round(bins[i6].rc), 0, 255);
+        let g4 = clamp3(Math.round(bins[i6].gc), 0, 255);
+        let b4 = clamp3(Math.round(bins[i6].bc), 0, 255);
+        let a5 = 255;
+        if (hasAlpha) {
+          a5 = clamp3(Math.round(bins[i6].ac), 0, 255);
+          if (oneBitAlpha) {
+            const threshold = typeof oneBitAlpha === "number" ? oneBitAlpha : 127;
+            a5 = a5 <= threshold ? 0 : 255;
+          }
+          if (clearAlpha && a5 <= clearAlphaThreshold) {
+            r5 = g4 = b4 = clearAlphaColor;
+            a5 = 0;
+          }
+        }
+        const color = hasAlpha ? [r5, g4, b4, a5] : [r5, g4, b4];
+        const exists = existsInPalette(palette, color);
+        if (!exists)
+          palette.push(color);
+        if ((i6 = bins[i6].fw) == 0)
+          break;
+      }
+      return palette;
+    }
+    function existsInPalette(palette, color) {
+      for (let i6 = 0; i6 < palette.length; i6++) {
+        const p6 = palette[i6];
+        let matchesRGB = p6[0] === color[0] && p6[1] === color[1] && p6[2] === color[2];
+        let matchesAlpha = p6.length >= 4 && color.length >= 4 ? p6[3] === color[3] : true;
+        if (matchesRGB && matchesAlpha)
+          return true;
+      }
+      return false;
+    }
+    function euclideanDistanceSquared(a5, b4) {
+      var sum = 0;
+      var n4;
+      for (n4 = 0; n4 < a5.length; n4++) {
+        const dx = a5[n4] - b4[n4];
+        sum += dx * dx;
+      }
+      return sum;
+    }
+    function roundStep(byte, step) {
+      return step > 1 ? Math.round(byte / step) * step : byte;
+    }
+    function prequantize(rgba, { roundRGB = 5, roundAlpha = 10, oneBitAlpha = null } = {}) {
+      const data = new Uint32Array(rgba.buffer);
+      for (let i6 = 0; i6 < data.length; i6++) {
+        const color = data[i6];
+        let a5 = color >> 24 & 255;
+        let b4 = color >> 16 & 255;
+        let g4 = color >> 8 & 255;
+        let r5 = color & 255;
+        a5 = roundStep(a5, roundAlpha);
+        if (oneBitAlpha) {
+          const threshold = typeof oneBitAlpha === "number" ? oneBitAlpha : 127;
+          a5 = a5 <= threshold ? 0 : 255;
+        }
+        r5 = roundStep(r5, roundRGB);
+        g4 = roundStep(g4, roundRGB);
+        b4 = roundStep(b4, roundRGB);
+        data[i6] = a5 << 24 | b4 << 16 | g4 << 8 | r5 << 0;
+      }
+    }
+    function applyPalette2(rgba, palette, format = "rgb565") {
+      if (!rgba || !rgba.buffer) {
+        throw new Error("quantize() expected RGBA Uint8Array data");
+      }
+      if (!(rgba instanceof Uint8Array) && !(rgba instanceof Uint8ClampedArray)) {
+        throw new Error("quantize() expected RGBA Uint8Array data");
+      }
+      if (palette.length > 256) {
+        throw new Error("applyPalette() only works with 256 colors or less");
+      }
+      const data = new Uint32Array(rgba.buffer);
+      const length2 = data.length;
+      const bincount = format === "rgb444" ? 4096 : 65536;
+      const index = new Uint8Array(length2);
+      const cache = new Array(bincount);
+      const hasAlpha = format === "rgba4444";
+      if (format === "rgba4444") {
+        for (let i6 = 0; i6 < length2; i6++) {
+          const color = data[i6];
+          const a5 = color >> 24 & 255;
+          const b4 = color >> 16 & 255;
+          const g4 = color >> 8 & 255;
+          const r5 = color & 255;
+          const key = rgba8888_to_rgba4444(r5, g4, b4, a5);
+          const idx = key in cache ? cache[key] : cache[key] = nearestColorIndexRGBA(r5, g4, b4, a5, palette);
+          index[i6] = idx;
+        }
+      } else {
+        const rgb888_to_key = format === "rgb444" ? rgb888_to_rgb444 : rgb888_to_rgb565;
+        for (let i6 = 0; i6 < length2; i6++) {
+          const color = data[i6];
+          const b4 = color >> 16 & 255;
+          const g4 = color >> 8 & 255;
+          const r5 = color & 255;
+          const key = rgb888_to_key(r5, g4, b4);
+          const idx = key in cache ? cache[key] : cache[key] = nearestColorIndexRGB(r5, g4, b4, palette);
+          index[i6] = idx;
+        }
+      }
+      return index;
+    }
+    function nearestColorIndexRGBA(r5, g4, b4, a5, palette) {
+      let k4 = 0;
+      let mindist = 1e100;
+      for (let i6 = 0; i6 < palette.length; i6++) {
+        const px2 = palette[i6];
+        const a22 = px2[3];
+        let curdist = sqr2(a22 - a5);
+        if (curdist > mindist)
+          continue;
+        const r22 = px2[0];
+        curdist += sqr2(r22 - r5);
+        if (curdist > mindist)
+          continue;
+        const g22 = px2[1];
+        curdist += sqr2(g22 - g4);
+        if (curdist > mindist)
+          continue;
+        const b22 = px2[2];
+        curdist += sqr2(b22 - b4);
+        if (curdist > mindist)
+          continue;
+        mindist = curdist;
+        k4 = i6;
+      }
+      return k4;
+    }
+    function nearestColorIndexRGB(r5, g4, b4, palette) {
+      let k4 = 0;
+      let mindist = 1e100;
+      for (let i6 = 0; i6 < palette.length; i6++) {
+        const px2 = palette[i6];
+        const r22 = px2[0];
+        let curdist = sqr2(r22 - r5);
+        if (curdist > mindist)
+          continue;
+        const g22 = px2[1];
+        curdist += sqr2(g22 - g4);
+        if (curdist > mindist)
+          continue;
+        const b22 = px2[2];
+        curdist += sqr2(b22 - b4);
+        if (curdist > mindist)
+          continue;
+        mindist = curdist;
+        k4 = i6;
+      }
+      return k4;
+    }
+    function snapColorsToPalette(palette, knownColors, threshold = 5) {
+      if (!palette.length || !knownColors.length)
+        return;
+      const paletteRGB = palette.map((p6) => p6.slice(0, 3));
+      const thresholdSq = threshold * threshold;
+      const dim2 = palette[0].length;
+      for (let i6 = 0; i6 < knownColors.length; i6++) {
+        let color = knownColors[i6];
+        if (color.length < dim2) {
+          color = [color[0], color[1], color[2], 255];
+        } else if (color.length > dim2) {
+          color = color.slice(0, 3);
+        } else {
+          color = color.slice();
+        }
+        const r5 = nearestColorIndexWithDistance(paletteRGB, color.slice(0, 3), euclideanDistanceSquared);
+        const idx = r5[0];
+        const distanceSq = r5[1];
+        if (distanceSq > 0 && distanceSq <= thresholdSq) {
+          palette[idx] = color;
+        }
+      }
+    }
+    function sqr2(a5) {
+      return a5 * a5;
+    }
+    function nearestColorIndex(colors, pixel, distanceFn = euclideanDistanceSquared) {
+      let minDist = Infinity;
+      let minDistIndex = -1;
+      for (let j5 = 0; j5 < colors.length; j5++) {
+        const paletteColor = colors[j5];
+        const dist = distanceFn(pixel, paletteColor);
+        if (dist < minDist) {
+          minDist = dist;
+          minDistIndex = j5;
+        }
+      }
+      return minDistIndex;
+    }
+    function nearestColorIndexWithDistance(colors, pixel, distanceFn = euclideanDistanceSquared) {
+      let minDist = Infinity;
+      let minDistIndex = -1;
+      for (let j5 = 0; j5 < colors.length; j5++) {
+        const paletteColor = colors[j5];
+        const dist = distanceFn(pixel, paletteColor);
+        if (dist < minDist) {
+          minDist = dist;
+          minDistIndex = j5;
+        }
+      }
+      return [minDistIndex, minDist];
+    }
+    function nearestColor(colors, pixel, distanceFn = euclideanDistanceSquared) {
+      return colors[nearestColorIndex(colors, pixel, distanceFn)];
+    }
+    function GIFEncoder2(opt = {}) {
+      const { initialCapacity = 4096, auto = true } = opt;
+      const stream = createStream(initialCapacity);
+      const HSIZE = 5003;
+      const accum = new Uint8Array(256);
+      const htab = new Int32Array(HSIZE);
+      const codetab = new Int32Array(HSIZE);
+      let hasInit = false;
+      return {
+        reset() {
+          stream.reset();
+          hasInit = false;
+        },
+        finish() {
+          stream.writeByte(constants_default.trailer);
+        },
+        bytes() {
+          return stream.bytes();
+        },
+        bytesView() {
+          return stream.bytesView();
+        },
+        get buffer() {
+          return stream.buffer;
+        },
+        get stream() {
+          return stream;
+        },
+        writeHeader,
+        writeFrame(index, width, height, opts = {}) {
+          const {
+            transparent = false,
+            transparentIndex = 0,
+            delay = 0,
+            palette = null,
+            repeat = 0,
+            colorDepth = 8,
+            dispose = -1
+          } = opts;
+          let first = false;
+          if (auto) {
+            if (!hasInit) {
+              first = true;
+              writeHeader();
+              hasInit = true;
+            }
+          } else {
+            first = Boolean(opts.first);
+          }
+          width = Math.max(0, Math.floor(width));
+          height = Math.max(0, Math.floor(height));
+          if (first) {
+            if (!palette) {
+              throw new Error("First frame must include a { palette } option");
+            }
+            encodeLogicalScreenDescriptor(stream, width, height, palette, colorDepth);
+            encodeColorTable(stream, palette);
+            if (repeat >= 0) {
+              encodeNetscapeExt(stream, repeat);
+            }
+          }
+          const delayTime = Math.round(delay / 10);
+          encodeGraphicControlExt(stream, dispose, delayTime, transparent, transparentIndex);
+          const useLocalColorTable = Boolean(palette) && !first;
+          encodeImageDescriptor(stream, width, height, useLocalColorTable ? palette : null);
+          if (useLocalColorTable)
+            encodeColorTable(stream, palette);
+          encodePixels(stream, index, width, height, colorDepth, accum, htab, codetab);
+        }
+      };
+      function writeHeader() {
+        writeUTFBytes(stream, "GIF89a");
+      }
+    }
+    function encodeGraphicControlExt(stream, dispose, delay, transparent, transparentIndex) {
+      stream.writeByte(33);
+      stream.writeByte(249);
+      stream.writeByte(4);
+      if (transparentIndex < 0) {
+        transparentIndex = 0;
+        transparent = false;
+      }
+      var transp, disp;
+      if (!transparent) {
+        transp = 0;
+        disp = 0;
+      } else {
+        transp = 1;
+        disp = 2;
+      }
+      if (dispose >= 0) {
+        disp = dispose & 7;
+      }
+      disp <<= 2;
+      const userInput = 0;
+      stream.writeByte(0 | disp | userInput | transp);
+      writeUInt16(stream, delay);
+      stream.writeByte(transparentIndex || 0);
+      stream.writeByte(0);
+    }
+    function encodeLogicalScreenDescriptor(stream, width, height, palette, colorDepth = 8) {
+      const globalColorTableFlag = 1;
+      const sortFlag = 0;
+      const globalColorTableSize = colorTableSize(palette.length) - 1;
+      const fields = globalColorTableFlag << 7 | colorDepth - 1 << 4 | sortFlag << 3 | globalColorTableSize;
+      const backgroundColorIndex = 0;
+      const pixelAspectRatio = 0;
+      writeUInt16(stream, width);
+      writeUInt16(stream, height);
+      stream.writeBytes([fields, backgroundColorIndex, pixelAspectRatio]);
+    }
+    function encodeNetscapeExt(stream, repeat) {
+      stream.writeByte(33);
+      stream.writeByte(255);
+      stream.writeByte(11);
+      writeUTFBytes(stream, "NETSCAPE2.0");
+      stream.writeByte(3);
+      stream.writeByte(1);
+      writeUInt16(stream, repeat);
+      stream.writeByte(0);
+    }
+    function encodeColorTable(stream, palette) {
+      const colorTableLength = 1 << colorTableSize(palette.length);
+      for (let i6 = 0; i6 < colorTableLength; i6++) {
+        let color = [0, 0, 0];
+        if (i6 < palette.length) {
+          color = palette[i6];
+        }
+        stream.writeByte(color[0]);
+        stream.writeByte(color[1]);
+        stream.writeByte(color[2]);
+      }
+    }
+    function encodeImageDescriptor(stream, width, height, localPalette) {
+      stream.writeByte(44);
+      writeUInt16(stream, 0);
+      writeUInt16(stream, 0);
+      writeUInt16(stream, width);
+      writeUInt16(stream, height);
+      if (localPalette) {
+        const interlace = 0;
+        const sorted = 0;
+        const palSize = colorTableSize(localPalette.length) - 1;
+        stream.writeByte(128 | interlace | sorted | 0 | palSize);
+      } else {
+        stream.writeByte(0);
+      }
+    }
+    function encodePixels(stream, index, width, height, colorDepth = 8, accum, htab, codetab) {
+      lzwEncode_default(width, height, index, colorDepth, stream, accum, htab, codetab);
+    }
+    function writeUInt16(stream, short) {
+      stream.writeByte(short & 255);
+      stream.writeByte(short >> 8 & 255);
+    }
+    function writeUTFBytes(stream, text) {
+      for (var i6 = 0; i6 < text.length; i6++) {
+        stream.writeByte(text.charCodeAt(i6));
+      }
+    }
+    function colorTableSize(length2) {
+      return Math.max(Math.ceil(Math.log2(length2)), 1);
+    }
+    var src_default = GIFEncoder2;
+  }
+});
+
 // node_modules/preact/dist/preact.module.js
 var n;
 var l;
@@ -50199,6 +51011,7 @@ __export(store_exports, {
   setRect: () => setRect,
   setStatus: () => setStatus,
   setWeightsMode: () => setWeightsMode,
+  showBones: () => showBones,
   shown: () => shown,
   skeleton: () => skeleton,
   snap: () => snap,
@@ -50691,6 +51504,8 @@ var store = (key, v6) => {
 };
 var lockImages = y2(stored("rig-editor.lockImages") === "1");
 j3(() => store("rig-editor.lockImages", lockImages.value ? "1" : "0"));
+var showBones = y2(stored("rig-editor.showBones") !== "0");
+j3(() => store("rig-editor.showBones", showBones.value ? "1" : "0"));
 var sections = y2((() => {
   try {
     return JSON.parse(stored("rig-editor.sections") ?? "{}");
@@ -56529,6 +57344,9 @@ init_Sprite();
 init_eventemitter3();
 extensions.add(browserExt, webworkerExt);
 
+// src/editor/stage.ts
+var import_gifenc = __toESM(require_gifenc(), 1);
+
 // src/rig-state.ts
 var AnimationState = class {
   constructor(sink, opts = {}) {
@@ -56675,6 +57493,7 @@ function hit(t5, prev, cur, d5, loop2) {
 // src/rig-runtime.ts
 var DEG4 = Math.PI / 180;
 var MESH_GRID = 9;
+var GHOST_ALPHA = 0.5;
 async function createTextures(doc2, loadSource) {
   const bySrc = /* @__PURE__ */ new Map(), out2 = /* @__PURE__ */ new Map();
   for (const a5 of doc2.assets) {
@@ -56764,6 +57583,8 @@ var RigPlayer = class {
   pages = /* @__PURE__ */ new Map();
   /** slots the editor hides; honoured by setPose */
   hidden = /* @__PURE__ */ new Set();
+  /** slots the editor has selected; setPose draws them at GHOST_ALPHA at least */
+  ghosts = /* @__PURE__ */ new Set();
   /** whole atlas page as a plain texture (identity uv mapping) for skinned meshes */
   pageTexture(tex) {
     let page = this.pages.get(tex.source);
@@ -56804,6 +57625,10 @@ var RigPlayer = class {
     if (visible) this.hidden.delete(slotId);
     else this.hidden.add(slotId);
   }
+  /** Editor-only: draw these slots at GHOST_ALPHA at least, whatever the pose says (an empty list clears it). */
+  setGhostSlots(slotIds) {
+    this.ghosts = new Set(slotIds);
+  }
   /** Stop playback and immediately restore the complete setup pose. */
   stop() {
     this.state.stop();
@@ -56828,7 +57653,8 @@ var RigPlayer = class {
       it.node.visible = true;
       const colorV = pose2.get(pk("slot", s6.id, "color"));
       const color = Array.isArray(colorV) && typeof colorV[0] === "number" ? colorV : colorToArray(s6.color);
-      it.node.alpha = numOf(pose2, pk("slot", s6.id, "alpha"), s6.alpha) * color[3];
+      const alpha = numOf(pose2, pk("slot", s6.id, "alpha"), s6.alpha) * color[3];
+      it.node.alpha = this.ghosts.has(s6.id) ? Math.max(alpha, GHOST_ALPHA) : alpha;
       it.node.tint = rgbOf(color);
       it.node.zIndex = order.size ? order.get(s6.id) ?? 0 : numOf(pose2, pk("slot", s6.id, "z"), s6.z);
       if (it.skinned) {
@@ -57161,6 +57987,7 @@ var Stage = class {
     }));
     this.dispose.push(j3(() => {
       hiddenSlots.value;
+      selection.value;
       f3(() => this.applyPose());
     }));
     this.dispose.push(j3(() => {
@@ -57211,6 +58038,7 @@ var Stage = class {
     }));
     this.dispose.push(j3(() => {
       boneTool.value;
+      showBones.value;
       f3(() => this.drawOverlay());
     }));
     this.dispose.push(j3(() => {
@@ -57294,6 +58122,7 @@ var Stage = class {
     if (!p6 || !d5) return;
     const hidden = hiddenSlots.value;
     for (const s6 of d5.slots) p6.setSlotVisible(s6.id, !hidden.has(s6.id));
+    p6.setGhostSlots(playing.peek() ? [] : this.selectedSlots(d5));
     const anim = currentAnim.value;
     if (mode.value === "animate" && anim) {
       void p6.play(anim.id, { loop: loop.value });
@@ -57307,6 +58136,21 @@ var Stage = class {
     }
     this.drawOverlay();
   }
+  /**
+   * The slots the selection is about — a slot, the one an attachment (or a vertex of it) hangs in, or every slot on
+   * a selected bone. The player draws them half-visible at least, so a part faded out at rest (runes that only light
+   * up in `win`) is not an invisible box of grips. Not while playing: the animation's own fade is what is watched.
+   */
+  selectedSlots(d5) {
+    const sel = selection.peek();
+    if (sel?.kind === "slot") return [sel.id];
+    if (sel?.kind === "attachment" || sel?.kind === "vertex") {
+      const a5 = d5.attachments.find((a6) => a6.id === sel.id);
+      return a5 ? [a5.slot] : [];
+    }
+    if (sel?.kind === "bone") return d5.slots.filter((s6) => s6.bone === sel.id).map((s6) => s6.id);
+    return [];
+  }
   // ---------- reference underlay ----------
   reference;
   referenceSrc;
@@ -57374,6 +58218,54 @@ var Stage = class {
     time.value = this.t;
     this.drawOverlay();
   }
+  // ---------- GIF export ----------
+  /** one export at a time: two runs would interleave their seeks into the same player and produce a mixed file */
+  exporting = false;
+  /**
+   * The current animation as GIF bytes — the top bar hands them to a download link, and the tests read them.
+   *
+   * Each frame is the DOCUMENT rectangle rendered on its own: `extract` REPLACES the target's transform with the
+   * frame's, so the file ignores the camera's zoom and pan and comes out at `meta.width` × `meta.height` whatever
+   * is on screen. The overlay (bones, labels, gizmos) is switched off for the duration, so nothing of the editor
+   * ends up in it; the paper stays, which is what makes every pixel opaque — GIF has no partial transparency.
+   */
+  async exportGif(fps = FPS) {
+    const d5 = shown.peek(), anim = currentAnim.peek(), p6 = this.player;
+    if (!p6 || !d5 || !anim || mode.peek() !== "animate") {
+      setStatus("gif: pick an animation in animate mode", "warn");
+      return;
+    }
+    if (this.exporting) return;
+    this.exporting = true;
+    const wasPlaying = playing.peek();
+    playing.value = false;
+    this.overlay.visible = false;
+    p6.setGhostSlots([]);
+    try {
+      const w5 = d5.meta.width, h6 = d5.meta.height, n4 = Math.max(1, Math.round(anim.duration * fps));
+      const frame = new Rectangle(0, 0, w5, h6), gif = (0, import_gifenc.GIFEncoder)();
+      for (let i6 = 0; i6 < n4; i6++) {
+        if (this.destroyed) return;
+        void p6.play(anim.id, { loop: false });
+        p6.tick(i6 / fps);
+        const { pixels } = this.app.renderer.extract.pixels({ target: this.camera, frame });
+        const palette = (0, import_gifenc.quantize)(pixels, 256);
+        gif.writeFrame((0, import_gifenc.applyPalette)(pixels, palette), w5, h6, { palette, delay: 1e3 / fps });
+        setStatus(`gif: frame ${i6 + 1}/${n4}`);
+        await new Promise((r5) => setTimeout(r5));
+      }
+      gif.finish();
+      setStatus(`gif: ${anim.id}, ${n4} frames at ${fps} fps`);
+      return gif.bytes();
+    } finally {
+      this.exporting = false;
+      if (!this.destroyed) {
+        this.overlay.visible = true;
+        playing.value = wasPlaying;
+        this.applyPose();
+      }
+    }
+  }
   // ---------- camera ----------
   /** doc px → screen px (canvas client coords); the camera never rotates, so this is exact without a render */
   toScreen(x4, y4) {
@@ -57953,7 +58845,7 @@ var Stage = class {
     this.paper.rect(0, 0, d5.meta.width, d5.meta.height).fill({ color: CANVAS_BG });
     this.gfx.rect(0, 0, d5.meta.width, d5.meta.height).stroke({ color: CANVAS_LINE, width: 1 / z3 });
     const skel = this.skeleton;
-    for (const b4 of d5.bones) {
+    if (showBones.value) for (const b4 of d5.bones) {
       const w5 = skel.bones.get(b4.id)?.world;
       if (!w5) continue;
       const parent = b4.parent && skel.bones.get(b4.parent)?.world;
@@ -58670,6 +59562,16 @@ async function history(tool) {
     historyBusy = false;
   }
 }
+async function exportGif() {
+  const bytes = await stage?.exportGif();
+  if (!bytes) return;
+  const url = URL.createObjectURL(new Blob([bytes], { type: "image/gif" }));
+  const a5 = document.createElement("a");
+  a5.href = url;
+  a5.download = `${shown.peek()?.meta.name ?? "rig"}_${animId.peek() ?? "anim"}.gif`;
+  a5.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1e4);
+}
 function setMode(m5) {
   if (m5 === "animate" && !shown.value?.animations.length) {
     setStatus("no animations \u2014 create one in the properties panel", "warn");
@@ -58887,7 +59789,25 @@ function TopBar() {
       /* @__PURE__ */ u4("input", { class: "loop", type: "checkbox", checked: loop.value, onChange: (e5) => loop.value = e5.target.checked }),
       "loop"
     ] }),
+    /* @__PURE__ */ u4(
+      "button",
+      {
+        class: "gif",
+        title: "export the current animation as a GIF, at document size, without the overlay",
+        onClick: click(() => void exportGif()),
+        children: "gif"
+      }
+    ),
     /* @__PURE__ */ u4("button", { class: "fit", title: "fit the document to the viewport (F)", onClick: click(() => stage?.fit()), children: "fit" }),
+    /* @__PURE__ */ u4(
+      "button",
+      {
+        class: "bones" + (showBones.value ? " on" : ""),
+        title: "show the bone overlay (H)",
+        onClick: click(() => showBones.value = !showBones.value),
+        children: "bones"
+      }
+    ),
     /* @__PURE__ */ u4(
       "button",
       {
@@ -59115,6 +60035,10 @@ function onKeyDown(e5) {
     setBoneTool(!boneTool.value);
     return;
   }
+  if (e5.key === "h" || e5.key === "H") {
+    showBones.value = !showBones.value;
+    return;
+  }
   if ((e5.key === "[" || e5.key === "]") && weightsMode.value) {
     const b4 = brush.value;
     const radius = Math.min(400, Math.max(4, b4.radius * (e5.key === "]" ? 1.25 : 0.8)));