@outerlayer/cli 0.33.0-next.20261021194303 → 0.33.0-next.20261021234516

package/dist/emit-demo-cmd-Q3BCRULM.js

@@ -0,0 +1,3022 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runEmitArtifact } from './chunk-YH2632RT.js';
+import './chunk-SFJD4MRY.js';
+import './chunk-RQKQTRXM.js';
+import './chunk-ESVW4MJY.js';
+import './chunk-TBT347UY.js';
+import { VoiceDownloadError, downloadPinned, sha256OfFile } from './chunk-2PGI6RDE.js';
+import { VOICE_PACK_FILES, VOICE_PACK_VERSION } from './chunk-LHYO4RDP.js';
+import { detectActiveSession, autoConnect } from './chunk-6TFTRVOA.js';
+import './chunk-5RUH3PCG.js';
+import './chunk-DM4EGXDO.js';
+import { resolveRepoIdentity } from './chunk-AKR32WHV.js';
+import './chunk-4IG6EZHU.js';
+import './chunk-RW52CUFX.js';
+import './chunk-G2JWZDFA.js';
+import { C } from './chunk-ANPNT6PM.js';
+import { defaultFetch, resolveGatewayCredentials } from './chunk-VQ2JGZSC.js';
+import './chunk-PJDQPF5N.js';
+import './chunk-JT3YO5MH.js';
+import './chunk-ESP5VZBD.js';
+import './chunk-HDSDUTX4.js';
+import './chunk-HT7LVCTX.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-2O5KA67H.js';
+import './chunk-BKO6JEZI.js';
+import './chunk-HCVLP7XA.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-KUTZ6XLS.js';
+import './chunk-5BHIBJDA.js';
+import './chunk-CDDED64E.js';
+import './chunk-RA3O54FC.js';
+import { launchedItemForSession } from './chunk-T2Q7ISPE.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-CRB3POP4.js';
+import './chunk-URIZRCRY.js';
+import './chunk-TUSYOL2O.js';
+import './chunk-OGCG5LOX.js';
+import { ARTIFACT_MAX_BYTES, ARTIFACT_MAX_CAPTION_LENGTH, DEMO_RECORD_MEDIA_TYPE, DemoManifestSchema } from './chunk-AKHGQKNR.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-XD4ZCMA4.js';
+import './chunk-MESOOLF4.js';
+import { __commonJS, __require, __toESM } from './chunk-Z5GEFMRW.js';
+import { createHash } from 'crypto';
+import { mkdtempSync, statSync, readFileSync, writeFileSync, rmSync, mkdirSync, accessSync, constants, realpathSync, existsSync, createReadStream, createWriteStream } from 'fs';
+import { tmpdir } from 'os';
+import { resolve, dirname, join, delimiter, normalize, sep } from 'path';
+import { execFileSync } from 'child_process';
+import { createRequire as createRequire$1 } from 'module';
+import { createGunzip } from 'zlib';
+
+createRequire(import.meta.url);
+
+// ../../node_modules/pngjs/lib/chunkstream.js
+var require_chunkstream = __commonJS({
+  "../../node_modules/pngjs/lib/chunkstream.js"(exports$1, 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),
+        // if length < 0 then at most this 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({
+  "../../node_modules/pngjs/lib/interlace.js"(exports$1) {
+    var imagePasses = [
+      {
+        // pass 1 - 1px
+        x: [0],
+        y: [0]
+      },
+      {
+        // pass 2 - 1px
+        x: [4],
+        y: [0]
+      },
+      {
+        // pass 3 - 2px
+        x: [0, 4],
+        y: [4]
+      },
+      {
+        // pass 4 - 4px
+        x: [2, 6],
+        y: [0, 4]
+      },
+      {
+        // pass 5 - 8px
+        x: [0, 2, 4, 6],
+        y: [2, 6]
+      },
+      {
+        // pass 6 - 16px
+        x: [1, 3, 5, 7],
+        y: [0, 2, 4, 6]
+      },
+      {
+        // pass 7 - 32px
+        x: [0, 1, 2, 3, 4, 5, 6, 7],
+        y: [1, 3, 5, 7]
+      }
+    ];
+    exports$1.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 i = 0; i < imagePasses.length; i++) {
+        let pass = imagePasses[i];
+        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: i });
+        }
+      }
+      return images;
+    };
+    exports$1.getInterlaceIterator = function(width) {
+      return function(x, y, pass) {
+        let outerXLeftOver = x % imagePasses[pass].x.length;
+        let outerX = (x - outerXLeftOver) / imagePasses[pass].x.length * 8 + imagePasses[pass].x[outerXLeftOver];
+        let outerYLeftOver = y % imagePasses[pass].y.length;
+        let outerY = (y - 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({
+  "../../node_modules/pngjs/lib/paeth-predictor.js"(exports$1, 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({
+  "../../node_modules/pngjs/lib/filter-parse.js"(exports$1, 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 i = 0; i < passes.length; i++) {
+          this._images.push({
+            byteWidth: getByteWidth(passes[i].width, bpp, depth),
+            height: passes[i].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 x = 0; x < byteWidth; x++) {
+        let rawByte = rawData[1 + x];
+        let f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+        unfilteredLine[x] = rawByte + f1Left;
+      }
+    };
+    Filter.prototype._unFilterType2 = function(rawData, unfilteredLine, byteWidth) {
+      let lastLine = this._lastLine;
+      for (let x = 0; x < byteWidth; x++) {
+        let rawByte = rawData[1 + x];
+        let f2Up = lastLine ? lastLine[x] : 0;
+        unfilteredLine[x] = rawByte + f2Up;
+      }
+    };
+    Filter.prototype._unFilterType3 = function(rawData, unfilteredLine, byteWidth) {
+      let xComparison = this._xComparison;
+      let xBiggerThan = xComparison - 1;
+      let lastLine = this._lastLine;
+      for (let x = 0; x < byteWidth; x++) {
+        let rawByte = rawData[1 + x];
+        let f3Up = lastLine ? lastLine[x] : 0;
+        let f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+        let f3Add = Math.floor((f3Left + f3Up) / 2);
+        unfilteredLine[x] = rawByte + f3Add;
+      }
+    };
+    Filter.prototype._unFilterType4 = function(rawData, unfilteredLine, byteWidth) {
+      let xComparison = this._xComparison;
+      let xBiggerThan = xComparison - 1;
+      let lastLine = this._lastLine;
+      for (let x = 0; x < byteWidth; x++) {
+        let rawByte = rawData[1 + x];
+        let f4Up = lastLine ? lastLine[x] : 0;
+        let f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+        let f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;
+        let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
+        unfilteredLine[x] = 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({
+  "../../node_modules/pngjs/lib/filter-parse-async.js"(exports$1, 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({
+  "../../node_modules/pngjs/lib/constants.js"(exports$1, 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,
+      // eslint-disable-line camelcase
+      TYPE_gAMA: 1732332865,
+      // eslint-disable-line camelcase
+      // color-type bits
+      COLORTYPE_GRAYSCALE: 0,
+      COLORTYPE_PALETTE: 1,
+      COLORTYPE_COLOR: 2,
+      COLORTYPE_ALPHA: 4,
+      // e.g. grayscale and alpha
+      // color-type combinations
+      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({
+  "../../node_modules/pngjs/lib/crc.js"(exports$1, module) {
+    var crcTable = [];
+    (function() {
+      for (let i = 0; i < 256; i++) {
+        let currentCrc = i;
+        for (let j = 0; j < 8; j++) {
+          if (currentCrc & 1) {
+            currentCrc = 3988292384 ^ currentCrc >>> 1;
+          } else {
+            currentCrc = currentCrc >>> 1;
+          }
+        }
+        crcTable[i] = currentCrc;
+      }
+    })();
+    var CrcCalculator = module.exports = function() {
+      this._crc = -1;
+    };
+    CrcCalculator.prototype.write = function(data) {
+      for (let i = 0; i < data.length; i++) {
+        this._crc = crcTable[(this._crc ^ data[i]) & 255] ^ this._crc >>> 8;
+      }
+      return true;
+    };
+    CrcCalculator.prototype.crc32 = function() {
+      return this._crc ^ -1;
+    };
+    CrcCalculator.crc32 = function(buf) {
+      let crc = -1;
+      for (let i = 0; i < buf.length; i++) {
+        crc = crcTable[(crc ^ buf[i]) & 255] ^ crc >>> 8;
+      }
+      return crc ^ -1;
+    };
+  }
+});
+
+// ../../node_modules/pngjs/lib/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/pngjs/lib/parser.js"(exports$1, module) {
+    var constants2 = 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[constants2.TYPE_IHDR] = this._handleIHDR.bind(this);
+      this._chunks[constants2.TYPE_IEND] = this._handleIEND.bind(this);
+      this._chunks[constants2.TYPE_IDAT] = this._handleIDAT.bind(this);
+      this._chunks[constants2.TYPE_PLTE] = this._handlePLTE.bind(this);
+      this._chunks[constants2.TYPE_tRNS] = this._handleTRNS.bind(this);
+      this._chunks[constants2.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(constants2.PNG_SIGNATURE.length, this._parseSignature.bind(this));
+    };
+    Parser.prototype._parseSignature = function(data) {
+      let signature = constants2.PNG_SIGNATURE;
+      for (let i = 0; i < signature.length; i++) {
+        if (data[i] !== signature[i]) {
+          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 i = 4; i < 8; i++) {
+        name += String.fromCharCode(data[i]);
+      }
+      let ancillary = Boolean(data[4] & 32);
+      if (!this._hasIHDR && type !== constants2.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 constants2.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 = constants2.COLORTYPE_TO_BPP_MAP[this._colorType];
+      this._hasIHDR = true;
+      this.metadata({
+        width,
+        height,
+        depth,
+        interlace: Boolean(interlace),
+        palette: Boolean(colorType & constants2.COLORTYPE_PALETTE),
+        color: Boolean(colorType & constants2.COLORTYPE_COLOR),
+        alpha: Boolean(colorType & constants2.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 i = 0; i < entries; i++) {
+        this._palette.push([data[i * 3], data[i * 3 + 1], data[i * 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 === constants2.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 i = 0; i < data.length; i++) {
+          this._palette[i][3] = data[i];
+        }
+        this.palette(this._palette);
+      }
+      if (this._colorType === constants2.COLORTYPE_GRAYSCALE) {
+        this.transColor([data.readUInt16BE(0)]);
+      }
+      if (this._colorType === constants2.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) / constants2.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 === constants2.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({
+  "../../node_modules/pngjs/lib/bitmapper.js"(exports$1) {
+    var interlaceUtils = require_interlace();
+    var pixelBppMapper = [
+      // 0 - dummy entry
+      function() {
+      },
+      // 1 - L
+      // 0: 0, 1: 0, 2: 0, 3: 0xff
+      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;
+      },
+      // 2 - LA
+      // 0: 0, 1: 0, 2: 0, 3: 1
+      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];
+      },
+      // 3 - RGB
+      // 0: 0, 1: 1, 2: 2, 3: 0xff
+      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;
+      },
+      // 4 - RGBA
+      // 0: 0, 1: 1, 2: 2, 3: 3
+      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 = [
+      // 0 - dummy entry
+      function() {
+      },
+      // 1 - L
+      // 0: 0, 1: 0, 2: 0, 3: 0xff
+      function(pxData, pixelData, pxPos, maxBit) {
+        let pixel = pixelData[0];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = maxBit;
+      },
+      // 2 - LA
+      // 0: 0, 1: 0, 2: 0, 3: 1
+      function(pxData, pixelData, pxPos) {
+        let pixel = pixelData[0];
+        pxData[pxPos] = pixel;
+        pxData[pxPos + 1] = pixel;
+        pxData[pxPos + 2] = pixel;
+        pxData[pxPos + 3] = pixelData[1];
+      },
+      // 3 - RGB
+      // 0: 0, 1: 1, 2: 2, 3: 0xff
+      function(pxData, pixelData, pxPos, maxBit) {
+        pxData[pxPos] = pixelData[0];
+        pxData[pxPos + 1] = pixelData[1];
+        pxData[pxPos + 2] = pixelData[2];
+        pxData[pxPos + 3] = maxBit;
+      },
+      // 4 - RGBA
+      // 0: 0, 1: 1, 2: 2, 3: 3
+      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 i = 0;
+      function split() {
+        if (i === data.length) {
+          throw new Error("Ran out of data");
+        }
+        let byte = data[i];
+        i++;
+        let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
+        switch (depth) {
+          default:
+            throw new Error("unrecognised depth");
+          case 16:
+            byte2 = data[i];
+            i++;
+            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 (i !== 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 y = 0; y < imageHeight; y++) {
+        for (let x = 0; x < imageWidth; x++) {
+          let pxPos = getPxPos(x, y, 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 y = 0; y < imageHeight; y++) {
+        for (let x = 0; x < imageWidth; x++) {
+          let pixelData = bits.get(bpp);
+          let pxPos = getPxPos(x, y, imagePass);
+          pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
+        }
+        bits.resetAfterLine();
+      }
+    }
+    exports$1.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({
+  "../../node_modules/pngjs/lib/format-normaliser.js"(exports$1, module) {
+    function dePalette(indata, outdata, width, height, palette) {
+      let pxPos = 0;
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          let color = palette[indata[pxPos]];
+          if (!color) {
+            throw new Error("index " + indata[pxPos] + " not in palette");
+          }
+          for (let i = 0; i < 4; i++) {
+            outdata[pxPos + i] = color[i];
+          }
+          pxPos += 4;
+        }
+      }
+    }
+    function replaceTransparentColor(indata, outdata, width, height, transColor) {
+      let pxPos = 0;
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          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 i = 0; i < 4; i++) {
+              outdata[pxPos + i] = 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 y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          for (let i = 0; i < 4; i++) {
+            outdata[pxPos + i] = Math.floor(
+              indata[pxPos + i] * 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({
+  "../../node_modules/pngjs/lib/parser-async.js"(exports$1, 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({
+  "../../node_modules/pngjs/lib/bitpacker.js"(exports$1, module) {
+    var constants2 = require_constants();
+    module.exports = function(dataIn, width, height, options) {
+      let outHasAlpha = [constants2.COLORTYPE_COLOR_ALPHA, constants2.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
+            /* littleEndian */
+          );
+          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 = constants2.COLORTYPE_TO_BPP_MAP[options.inputColorType];
+      if (inBpp === 4 && !options.inputHasAlpha) {
+        inBpp = 3;
+      }
+      let outBpp = constants2.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 === void 0) {
+        bgColor.red = maxValue;
+      }
+      if (bgColor.green === void 0) {
+        bgColor.green = maxValue;
+      }
+      if (bgColor.blue === void 0) {
+        bgColor.blue = maxValue;
+      }
+      function getRGBA() {
+        let red;
+        let green;
+        let blue;
+        let alpha = maxValue;
+        switch (options.inputColorType) {
+          case constants2.COLORTYPE_COLOR_ALPHA:
+            alpha = data[inIndex + 3];
+            red = data[inIndex];
+            green = data[inIndex + 1];
+            blue = data[inIndex + 2];
+            break;
+          case constants2.COLORTYPE_COLOR:
+            red = data[inIndex];
+            green = data[inIndex + 1];
+            blue = data[inIndex + 2];
+            break;
+          case constants2.COLORTYPE_ALPHA:
+            alpha = data[inIndex + 1];
+            red = data[inIndex];
+            green = red;
+            blue = red;
+            break;
+          case constants2.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 y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          let rgba = getRGBA();
+          switch (options.colorType) {
+            case constants2.COLORTYPE_COLOR_ALPHA:
+            case constants2.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 constants2.COLORTYPE_ALPHA:
+            case constants2.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({
+  "../../node_modules/pngjs/lib/filter-pack.js"(exports$1, module) {
+    var paethPredictor = require_paeth_predictor();
+    function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
+      for (let x = 0; x < byteWidth; x++) {
+        rawData[rawPos + x] = pxData[pxPos + x];
+      }
+    }
+    function filterSumNone(pxData, pxPos, byteWidth) {
+      let sum = 0;
+      let length = pxPos + byteWidth;
+      for (let i = pxPos; i < length; i++) {
+        sum += Math.abs(pxData[i]);
+      }
+      return sum;
+    }
+    function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let val = pxData[pxPos + x] - left;
+        rawData[rawPos + x] = val;
+      }
+    }
+    function filterSumSub(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let val = pxData[pxPos + x] - left;
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
+      for (let x = 0; x < byteWidth; x++) {
+        let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+        let val = pxData[pxPos + x] - up;
+        rawData[rawPos + x] = val;
+      }
+    }
+    function filterSumUp(pxData, pxPos, byteWidth) {
+      let sum = 0;
+      let length = pxPos + byteWidth;
+      for (let x = pxPos; x < length; x++) {
+        let up = pxPos > 0 ? pxData[x - byteWidth] : 0;
+        let val = pxData[x] - up;
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+        let val = pxData[pxPos + x] - (left + up >> 1);
+        rawData[rawPos + x] = val;
+      }
+    }
+    function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+        let val = pxData[pxPos + x] - (left + up >> 1);
+        sum += Math.abs(val);
+      }
+      return sum;
+    }
+    function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+        let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+        let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
+        rawData[rawPos + x] = val;
+      }
+    }
+    function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
+      let sum = 0;
+      for (let x = 0; x < byteWidth; x++) {
+        let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+        let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+        let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+        let val = pxData[pxPos + x] - 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 y = 0; y < height; y++) {
+        if (filterTypes.length > 1) {
+          let min = Infinity;
+          for (let i = 0; i < filterTypes.length; i++) {
+            let sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
+            if (sum < min) {
+              sel = filterTypes[i];
+              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({
+  "../../node_modules/pngjs/lib/packer.js"(exports$1, module) {
+    var constants2 = 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 : constants2.COLORTYPE_COLOR_ALPHA;
+      options.inputColorType = typeof options.inputColorType === "number" ? options.inputColorType : constants2.COLORTYPE_COLOR_ALPHA;
+      if ([
+        constants2.COLORTYPE_GRAYSCALE,
+        constants2.COLORTYPE_COLOR,
+        constants2.COLORTYPE_COLOR_ALPHA,
+        constants2.COLORTYPE_ALPHA
+      ].indexOf(options.colorType) === -1) {
+        throw new Error(
+          "option color type:" + options.colorType + " is not supported at present"
+        );
+      }
+      if ([
+        constants2.COLORTYPE_GRAYSCALE,
+        constants2.COLORTYPE_COLOR,
+        constants2.COLORTYPE_COLOR_ALPHA,
+        constants2.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 = constants2.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(gamma) {
+      let buf = Buffer.alloc(4);
+      buf.writeUInt32BE(Math.floor(gamma * constants2.GAMMA_DIVISION), 0);
+      return this._packChunk(constants2.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(constants2.TYPE_IHDR, buf);
+    };
+    Packer.prototype.packIDAT = function(data) {
+      return this._packChunk(constants2.TYPE_IDAT, data);
+    };
+    Packer.prototype.packIEND = function() {
+      return this._packChunk(constants2.TYPE_IEND, null);
+    };
+  }
+});
+
+// ../../node_modules/pngjs/lib/packer-async.js
+var require_packer_async = __commonJS({
+  "../../node_modules/pngjs/lib/packer-async.js"(exports$1, module) {
+    var util = __require("util");
+    var Stream = __require("stream");
+    var constants2 = 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, gamma) {
+      this.emit("data", Buffer.from(constants2.PNG_SIGNATURE));
+      this.emit("data", this._packer.packIHDR(width, height));
+      if (gamma) {
+        this.emit("data", this._packer.packGAMA(gamma));
+      }
+      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({
+  "../../node_modules/pngjs/lib/sync-inflate.js"(exports$1, 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 === void 0 ? 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 (!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,
+          // in
+          inOff,
+          // in_off
+          availInBefore,
+          // in_len
+          this._buffer,
+          // out
+          this._offset,
+          //out_off
+          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$1 = inflateSync;
+    exports$1.Inflate = Inflate;
+    exports$1.createInflate = createInflate;
+    exports$1.inflateSync = inflateSync;
+  }
+});
+
+// ../../node_modules/pngjs/lib/sync-reader.js
+var require_sync_reader = __commonJS({
+  "../../node_modules/pngjs/lib/sync-reader.js"(exports$1, 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),
+        // if length < 0 then at most this 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({
+  "../../node_modules/pngjs/lib/filter-parse-sync.js"(exports$1) {
+    var SyncReader = require_sync_reader();
+    var Filter = require_filter_parse();
+    exports$1.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({
+  "../../node_modules/pngjs/lib/parser-sync.js"(exports$1, 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 handleError(_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 gamma;
+      function handleGamma(_gamma_) {
+        gamma = _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: handleError,
+        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 = gamma || 0;
+      return metaData;
+    };
+  }
+});
+
+// ../../node_modules/pngjs/lib/packer-sync.js
+var require_packer_sync = __commonJS({
+  "../../node_modules/pngjs/lib/packer-sync.js"(exports$1, module) {
+    var hasSyncZlib = true;
+    var zlib = __require("zlib");
+    if (!zlib.deflateSync) {
+      hasSyncZlib = false;
+    }
+    var constants2 = 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(constants2.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({
+  "../../node_modules/pngjs/lib/png-sync.js"(exports$1) {
+    var parse = require_parser_sync();
+    var pack = require_packer_sync();
+    exports$1.read = function(buffer, options) {
+      return parse(buffer, options || {});
+    };
+    exports$1.write = function(png, options) {
+      return pack(png, options);
+    };
+  }
+});
+
+// ../../node_modules/pngjs/lib/png.js
+var require_png = __commonJS({
+  "../../node_modules/pngjs/lib/png.js"(exports$1) {
+    var util = __require("util");
+    var Stream = __require("stream");
+    var Parser = require_parser_async();
+    var Packer = require_packer_async();
+    var PNGSync = require_png_sync();
+    var PNG2 = exports$1.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(PNG2, Stream);
+    PNG2.sync = PNGSync;
+    PNG2.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;
+    };
+    PNG2.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;
+    };
+    PNG2.prototype.write = function(data) {
+      this._parser.write(data);
+      return true;
+    };
+    PNG2.prototype.end = function(data) {
+      this._parser.end(data);
+    };
+    PNG2.prototype._metadata = function(metadata) {
+      this.width = metadata.width;
+      this.height = metadata.height;
+      this.emit("metadata", metadata);
+    };
+    PNG2.prototype._gamma = function(gamma) {
+      this.gamma = gamma;
+    };
+    PNG2.prototype._handleClose = function() {
+      if (!this._parser.writable && !this._packer.readable) {
+        this.emit("close");
+      }
+    };
+    PNG2.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) {
+      srcX |= 0;
+      srcY |= 0;
+      width |= 0;
+      height |= 0;
+      deltaX |= 0;
+      deltaY |= 0;
+      if (srcX > src.width || srcY > src.height || srcX + width > src.width || srcY + height > src.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 y = 0; y < height; y++) {
+        src.data.copy(
+          dst.data,
+          (deltaY + y) * dst.width + deltaX << 2,
+          (srcY + y) * src.width + srcX << 2,
+          (srcY + y) * src.width + srcX + width << 2
+        );
+      }
+    };
+    PNG2.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) {
+      PNG2.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
+      return this;
+    };
+    PNG2.adjustGamma = function(src) {
+      if (src.gamma) {
+        for (let y = 0; y < src.height; y++) {
+          for (let x = 0; x < src.width; x++) {
+            let idx = src.width * y + x << 2;
+            for (let i = 0; i < 3; i++) {
+              let sample = src.data[idx + i] / 255;
+              sample = Math.pow(sample, 1 / 2.2 / src.gamma);
+              src.data[idx + i] = Math.round(sample * 255);
+            }
+          }
+        }
+        src.gamma = 0;
+      }
+    };
+    PNG2.prototype.adjustGamma = function() {
+      PNG2.adjustGamma(this);
+    };
+  }
+});
+
+// src/demo/manifest-checks.ts
+var END_TOLERANCE_SECONDS = 0.05;
+function chapterLabel(index, title) {
+  return `chapter ${index + 1} ("${title}")`;
+}
+function checkManifest(params) {
+  const { manifest, videoSeconds, recordedIds } = params;
+  const seen = /* @__PURE__ */ new Map();
+  let previousEnd = 0;
+  for (const [index, chapter] of manifest.chapters.entries()) {
+    const label = chapterLabel(index, chapter.title);
+    if (chapter.end > videoSeconds + END_TOLERANCE_SECONDS) {
+      return `${label} ends at ${chapter.end} s, but the video is ${videoSeconds.toFixed(1)} s long`;
+    }
+    if (chapter.start < previousEnd - END_TOLERANCE_SECONDS) {
+      return `${label} starts at ${chapter.start} s, before the previous chapter ends at ${previousEnd} s \u2014 chapters must be in order and must not overlap`;
+    }
+    previousEnd = chapter.end;
+    if (chapter.criterionId === null) {
+      if (index !== 0) {
+        return `${label} names no criterion \u2014 only the opening chapter may omit one`;
+      }
+      continue;
+    }
+    const first = seen.get(chapter.criterionId);
+    if (first !== void 0) {
+      return `${label} names criterion ${chapter.criterionId}, which chapter ${first + 1} already shows \u2014 one chapter proves each criterion`;
+    }
+    seen.set(chapter.criterionId, index);
+    if (recordedIds !== void 0 && !recordedIds.has(chapter.criterionId)) {
+      return `${label} names criterion ${chapter.criterionId}, which is not on the item's recorded criteria \u2014 record it with \`emit criteria\`, or fix the id`;
+    }
+  }
+  return void 0;
+}
+
+// src/demo/stills.ts
+var import_pngjs = __toESM(require_png(), 1);
+var StillError = class extends Error {
+};
+function readStill(dir, file, sha256) {
+  const path = resolve(dir, file);
+  let bytes;
+  try {
+    bytes = readFileSync(path);
+  } catch (err) {
+    throw new StillError(`cannot read the still "${file}" (${path}): ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (createHash("sha256").update(bytes).digest("hex") !== sha256) {
+    throw new StillError(`the still "${file}" does not match the SHA-256 in its manifest \u2014 the file changed after the run`);
+  }
+  return bytes;
+}
+function decode(bytes) {
+  try {
+    return import_pngjs.PNG.sync.read(bytes);
+  } catch (err) {
+    throw new StillError(`a still is not a valid PNG: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function diffStills(first, second) {
+  const a = decode(first);
+  const b = decode(second);
+  if (a.width !== b.width || a.height !== b.height) {
+    return { equal: false, region: { x: 0, y: 0, width: Math.max(a.width, b.width), height: Math.max(a.height, b.height) } };
+  }
+  let minX = a.width;
+  let minY = a.height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let at = 0; at < a.data.length; at += 4) {
+    if (a.data.compare(b.data, at, at + 4, at, at + 4) === 0) continue;
+    const pixel = at / 4;
+    const x = pixel % a.width;
+    const y = Math.floor(pixel / a.width);
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  }
+  if (maxX < 0) return { equal: true };
+  return { equal: false, region: { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 } };
+}
+
+// src/demo/compare.ts
+function stillsOf(chapter) {
+  return "stills" in chapter ? chapter.stills : [];
+}
+function pairManifests(first, second) {
+  if (first.chapters.length !== second.chapters.length) {
+    return `the runs differ in chapters: the first run has ${first.chapters.length} chapters and the second has ${second.chapters.length}`;
+  }
+  for (const [index, a] of first.chapters.entries()) {
+    const b = second.chapters[index];
+    const label = chapterLabel(index, a.title);
+    if (a.criterionId !== b.criterionId) {
+      return `${label} shows ${a.criterionId ?? "no criterion"} in the first run and ${b.criterionId ?? "no criterion"} in the second`;
+    }
+    if (a.title !== b.title) {
+      return `chapter ${index + 1} differs in title: "${a.title}" in the first run and "${b.title}" in the second`;
+    }
+    if (a.checks.length !== b.checks.length) {
+      return `${label} has ${a.checks.length} checks in the first run and ${b.checks.length} in the second`;
+    }
+    for (const [at, check] of a.checks.entries()) {
+      const other = b.checks[at];
+      if (check.text !== other.text) {
+        return `${label}, check ${at + 1} differs: "${check.text}" in the first run and "${other.text}" in the second`;
+      }
+      if (check.passed !== other.passed) {
+        return `${label}, check ${at + 1} "${check.text}" ${check.passed ? "passed" : "failed"} in the first run and ${other.passed ? "passed" : "failed"} in the second`;
+      }
+    }
+    const listed = (chapter) => stillsOf(chapter).map((still) => still.check + 1).join(", ") || "none";
+    if (listed(a) !== listed(b)) {
+      return `${label} has stills after checks ${listed(a)} in the first run and ${listed(b)} in the second`;
+    }
+  }
+  return void 0;
+}
+function compareChapters(params) {
+  const { first, second } = params;
+  return first.manifest.chapters.map((chapter, index) => {
+    const mine = stillsOf(chapter);
+    const stills = mine.map(({ check, sha256 }) => ({ check, sha256 }));
+    if (second === void 0 || mine.length === 0) return { comparable: "not checked", stills };
+    const theirs = stillsOf(second.manifest.chapters[index]);
+    let difference;
+    for (const [at, still] of mine.entries()) {
+      const other = theirs[at];
+      const bytes = readStill(first.dir, still.file, still.sha256);
+      const otherBytes = readStill(second.dir, other.file, other.sha256);
+      const diff = diffStills(bytes, otherBytes);
+      if (!diff.equal && difference === void 0) difference = { check: still.check, region: diff.region };
+    }
+    if (difference !== void 0) return { comparable: "no", stills, difference };
+    const followed = new Set(mine.map((still) => still.check));
+    if (chapter.checks.some((check, at) => check.passed && !followed.has(at))) return { comparable: "not checked", stills };
+    return { comparable: "yes", stills };
+  });
+}
+
+// src/demo/criteria.ts
+async function readRecordedCriteriaIds(params) {
+  const endpoint = new URL(`/v1/work-items/${params.item}`, params.url).toString();
+  const response = await params.fetchImpl(endpoint, {
+    method: "GET",
+    headers: { authorization: `Bearer ${params.apiKey}`, "x-outerlayer-app-id": params.appId }
+  });
+  if (!response.ok) throw new Error(`reading item ${params.item} failed (${response.status})`);
+  const body = await response.json();
+  const items = body.data?.criteria?.items;
+  if (!Array.isArray(items)) return void 0;
+  return new Set(items.flatMap((entry) => typeof entry.id === "string" ? [entry.id] : []));
+}
+
+// src/demo/fit.ts
+var MAX_TEMPO = 1.3;
+var SPEECH_LEAD_IN = 0.2;
+var SPEECH_TAIL = 0.2;
+var EPSILON = 1e-6;
+function fitSpeech(speechSeconds, chapterSeconds) {
+  const budget = chapterSeconds - SPEECH_LEAD_IN - SPEECH_TAIL;
+  if (budget > 0 && speechSeconds <= budget + EPSILON) return { ok: true, tempo: 1 };
+  if (budget > 0 && speechSeconds / budget <= MAX_TEMPO + EPSILON) {
+    return { ok: true, tempo: Math.min(MAX_TEMPO, speechSeconds / budget) };
+  }
+  return { ok: false, overrunSeconds: speechSeconds / MAX_TEMPO - budget };
+}
+function findProgram(name, env, platform = process.platform) {
+  const dirs = (env.PATH ?? env.Path ?? "").split(platform === "win32" ? ";" : delimiter).filter((dir) => dir !== "");
+  const extensions = platform === "win32" ? ["", ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => ext !== "")] : [""];
+  for (const dir of dirs) {
+    for (const extension of extensions) {
+      const candidate = join(dir, name + extension);
+      try {
+        if (!statSync(candidate).isFile()) continue;
+        if (platform !== "win32") accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+var INSTALL_HINT = {
+  ffmpeg: "ffmpeg (apt install ffmpeg, brew install ffmpeg, or winget install Gyan.FFmpeg)",
+  ffprobe: "ffmpeg, which includes ffprobe (apt install ffmpeg, brew install ffmpeg, or winget install Gyan.FFmpeg)",
+  "espeak-ng": "espeak-ng (apt install espeak-ng, brew install espeak-ng, or the eSpeak NG installer on Windows)"
+};
+function missingProgramMessage(name, narrated) {
+  const hint = INSTALL_HINT[name] ?? name;
+  const base = `install ${hint}, then run the command again`;
+  return name === "espeak-ng" && narrated ? `espeak-ng is not on PATH \u2014 ${base}, or pass --no-narration to store the clips without speech` : `${name} is not on PATH \u2014 ${base}`;
+}
+
+// src/demo/media.ts
+function clipArgs(plan) {
+  const duration = plan.end - plan.start;
+  const audio = plan.audio;
+  const pad = `apad=whole_dur=${duration.toFixed(3)}`;
+  const audioInput = audio === void 0 ? [] : audio === "silence" ? ["-f", "lavfi", "-t", duration.toFixed(3), "-i", "anullsrc=channel_layout=mono:sample_rate=48000"] : ["-i", audio.wavPath];
+  const audioFilter = audio === void 0 ? void 0 : audio === "silence" ? `[1:a]${pad}[speech]` : `[1:a]${audio.tempo === 1 ? "" : `atempo=${audio.tempo.toFixed(4)},`}adelay=${Math.round(audio.delaySeconds * 1e3)}:all=1,aresample=48000,${pad}[speech]`;
+  const speech = audioFilter === void 0 ? [] : ["-filter_complex", audioFilter, "-map", "[speech]", "-c:a", "libopus", "-b:a", "48k"];
+  return [
+    "-y",
+    "-v",
+    "error",
+    // The cut sits before the input and the clip is re-encoded, so it starts on the exact frame, not the nearest key frame.
+    "-ss",
+    plan.start.toFixed(3),
+    "-t",
+    duration.toFixed(3),
+    "-i",
+    plan.video,
+    ...audioInput,
+    "-map",
+    "0:v:0",
+    ...audio === void 0 ? ["-an"] : speech,
+    "-c:v",
+    "libvpx-vp9",
+    "-b:v",
+    "0",
+    "-crf",
+    "38",
+    "-deadline",
+    "realtime",
+    "-cpu-used",
+    "6",
+    "-row-mt",
+    "1",
+    "-pix_fmt",
+    "yuv420p",
+    // Without these, the WebM muxer writes a random segment id, and the same cut gives different bytes on every run.
+    "-fflags",
+    "+bitexact",
+    "-flags:v",
+    "+bitexact",
+    "-flags:a",
+    "+bitexact",
+    "-t",
+    duration.toFixed(3),
+    plan.output
+  ];
+}
+function durationFromProbe(formatDuration, lastPacketLines) {
+  const declared = Number(formatDuration);
+  if (Number.isFinite(declared) && declared > 0) return declared;
+  const packets = lastPacketLines.split("\n").filter((line) => line.trim() !== "").map((line) => line.split(",").map(Number)).filter((fields) => Number.isFinite(fields[0]));
+  const last = packets.at(-1);
+  if (last === void 0) return void 0;
+  return last[0] + (Number.isFinite(last[1]) ? last[1] : 0);
+}
+var TOOL_TIMEOUT_MS = 10 * 60 * 1e3;
+function createMediaTools(env, exec = execFileSync) {
+  const ffmpeg = findProgram("ffmpeg", env) ?? "ffmpeg";
+  const ffprobe = findProgram("ffprobe", env) ?? "ffprobe";
+  const run = (program, args) => exec(program, args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: TOOL_TIMEOUT_MS
+  });
+  return {
+    probe(video) {
+      const format = run(ffprobe, ["-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", video]);
+      const declared = durationFromProbe(format, "");
+      if (declared !== void 0) return declared;
+      const lines = run(ffprobe, ["-v", "error", "-select_streams", "v:0", "-show_entries", "packet=pts_time,duration_time", "-of", "csv=p=0", video]);
+      const duration = durationFromProbe("", lines);
+      if (duration === void 0) throw new Error(`cannot read the length of ${video}`);
+      return duration;
+    },
+    renderClip(plan) {
+      run(ffmpeg, clipArgs(plan));
+    }
+  };
+}
+
+// src/demo/record.ts
+function chapterPassed(checks) {
+  return checks.length > 0 && checks.every((check) => check.passed);
+}
+function buildDemoRecord(manifest, clips, comparisons) {
+  if (clips.length !== manifest.chapters.length) {
+    throw new Error(`the demo has ${manifest.chapters.length} chapters but ${clips.length} clips`);
+  }
+  if (comparisons.length !== manifest.chapters.length) {
+    throw new Error(`the demo has ${manifest.chapters.length} chapters but ${comparisons.length} comparisons`);
+  }
+  return {
+    schemaVersion: 2,
+    chapters: manifest.chapters.map((chapter, index) => {
+      const comparison = comparisons[index];
+      return {
+        criterionId: chapter.criterionId,
+        start: chapter.start,
+        end: chapter.end,
+        title: chapter.title,
+        narration: chapter.narration,
+        checks: chapter.checks,
+        clipArtifactId: clips[index].clipArtifactId,
+        bound: clips[index].bound,
+        comparable: comparison.comparable,
+        stills: comparison.stills,
+        ...comparison.difference === void 0 ? {} : { difference: comparison.difference }
+      };
+    })
+  };
+}
+var PUNCTUATION = ';:,.!?\xA1\xBF\u2014\u2026"\xAB\xBB\u201C\u201D(){}[]';
+var PUNCTUATION_RUN = new RegExp(`(\\s*[${PUNCTUATION.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}]+\\s*)+`, "g");
+function splitYear(text) {
+  if (text.includes(".")) return text;
+  if (text.includes(":")) {
+    const [hours, minutes] = text.split(":").map(Number);
+    return minutes === 0 ? `${hours} o'clock` : minutes < 10 ? `${hours} oh ${minutes}` : `${hours} ${minutes}`;
+  }
+  const year = parseInt(text.slice(0, 4), 10);
+  if (year < 1100 || year % 1e3 < 10) return text;
+  const high = text.slice(0, 2);
+  const low = parseInt(text.slice(2, 4), 10);
+  const plural = text.endsWith("s") ? "s" : "";
+  if (low === 0) return `${high} hundred${plural}`;
+  if (low < 10) return `${high} oh ${low}${plural}`;
+  return `${high} ${low}${plural}`;
+}
+function spellMoney(text) {
+  const unit = text[0] === "$" ? "dollar" : "pound";
+  if (Number.isNaN(Number(text.slice(1)))) return `${text.slice(1)} ${unit}s`;
+  if (!text.includes(".")) return `${text.slice(1)} ${unit}${text.slice(1) === "1" ? "" : "s"}`;
+  const [whole, fraction] = text.slice(1).split(".");
+  const cents = parseInt(fraction.padEnd(2, "0"), 10);
+  const small = text[0] === "$" ? cents === 1 ? "cent" : "cents" : cents === 1 ? "penny" : "pence";
+  return `${whole} ${unit}${whole === "1" ? "" : "s"} and ${cents} ${small}`;
+}
+function spellDecimal(text) {
+  const [whole, fraction] = text.split(".");
+  return `${whole} point ${fraction.split("").join(" ")}`;
+}
+function prepareText(text) {
+  return text.replace(/[‘’]/g, "'").replace(/«/g, "\u201C").replace(/»/g, "\u201D").replace(/[“”]/g, '"').replace(/\(/g, "\xAB").replace(/\)/g, "\xBB").replace(/、/g, ", ").replace(/。/g, ". ").replace(/！/g, "! ").replace(/，/g, ", ").replace(/：/g, ": ").replace(/；/g, "; ").replace(/？/g, "? ").replace(/[^\S \n]/g, " ").replace(/ {2,}/g, " ").replace(/(?<=\n) +(?=\n)/g, "").replace(/\bD[Rr]\.(?= [A-Z])/g, "Doctor").replace(/\b(?:Mr\.|MR\.(?= [A-Z]))/g, "Mister").replace(/\b(?:Ms\.|MS\.(?= [A-Z]))/g, "Miss").replace(/\b(?:Mrs\.|MRS\.(?= [A-Z]))/g, "Mrs").replace(/\betc\.(?! [A-Z])/gi, "etc").replace(/\b(y)eah?\b/gi, "$1e'a").replace(/\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)/g, splitYear).replace(/(?<=\d),(?=\d)/g, "").replace(/[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b/gi, spellMoney).replace(/\d*\.\d+/g, spellDecimal).replace(/(?<=\d)-(?=\d)/g, " to ").replace(/(?<=\d)S/g, " S").replace(/(?<=[BCDFGHJ-NP-TV-Z])'?s\b/g, "'S").replace(/(?<=X')S\b/g, "s").replace(/(?:[A-Za-z]\.){2,} [a-z]/g, (match) => match.replace(/\./g, "-")).replace(/(?<=[A-Z])\.(?=[A-Z])/gi, "-").trim();
+}
+function splitOnPunctuation(text) {
+  const parts = [];
+  let at = 0;
+  for (const match of text.matchAll(PUNCTUATION_RUN)) {
+    const index = match.index ?? 0;
+    if (at < index) parts.push({ punctuation: false, text: text.slice(at, index) });
+    parts.push({ punctuation: true, text: match[0] });
+    at = index + match[0].length;
+  }
+  if (at < text.length) parts.push({ punctuation: false, text: text.slice(at) });
+  return parts;
+}
+function normalizePhonemes(ipa) {
+  return ipa.replace(/kəkˈoːɹoʊ/g, "k\u02C8o\u028Ak\u0259\u0279o\u028A").replace(/kəkˈɔːɹəʊ/g, "k\u02C8\u0259\u028Ak\u0259\u0279\u0259\u028A").replace(/ʲ/g, "j").replace(/r/g, "\u0279").replace(/x/g, "k").replace(/ɬ/g, "l").replace(/(?<=[a-zɹː])(?=hˈʌndɹɪd)/g, " ").replace(/ z(?=[;:,.!?¡¿—…"«»“” ]|$)/g, "z").replace(/(?<=nˈaɪn)ti(?!ː)/g, "di").trim();
+}
+var ESPEAK_TIMEOUT_MS = 60 * 1e3;
+function espeakRunner(espeakPath, run = execFileSync) {
+  return (words) => run(espeakPath, ["-q", "--ipa", "-v", "en-us"], { input: words, encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: ESPEAK_TIMEOUT_MS }).split("\n").map((line) => line.trim()).filter((line) => line !== "").join(" ");
+}
+function phonemize(text, ipa) {
+  const parts = splitOnPunctuation(prepareText(text));
+  return normalizePhonemes(parts.map((part) => part.punctuation ? part.text : ipa(part.text)).join(""));
+}
+
+// src/demo/voice/kokoro.ts
+var SAMPLE_RATE = 24e3;
+var VOICE_ROWS = 510;
+var STYLE_SIZE = 256;
+var SENTENCE_GAP = 0.18;
+function tokenize(phonemes, vocab) {
+  const ids = [];
+  for (const symbol of phonemes) {
+    const id = vocab[symbol];
+    if (id !== void 0) ids.push(id);
+  }
+  return [0, ...ids, 0];
+}
+function styleRow(voice, tokenCount) {
+  const row = Math.min(Math.max(tokenCount - 2, 0), VOICE_ROWS - 1);
+  return voice.slice(row * STYLE_SIZE, (row + 1) * STYLE_SIZE);
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => sentence !== "");
+}
+function encodeWav(samples, sampleRate = SAMPLE_RATE) {
+  const data = Buffer.alloc(samples.length * 2);
+  samples.forEach((sample, index) => data.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * 32767), index * 2));
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + data.length, 4);
+  header.write("WAVEfmt ", 8);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(data.length, 40);
+  return Buffer.concat([header, data]);
+}
+function createKokoroSpeaker(opts) {
+  const ipa = opts.ipa ?? espeakRunner(opts.espeakPath);
+  let loaded;
+  let counter = 0;
+  const load = async () => {
+    if (loaded !== void 0) return loaded;
+    const ort = createRequire$1(join(opts.runtimeDir, "package.json"))("onnxruntime-node");
+    const session = await ort.InferenceSession.create(join(opts.packDir, "model.onnx"));
+    const vocab = JSON.parse(readFileSync(join(opts.packDir, "tokenizer.json"), "utf8")).model.vocab;
+    const bytes = readFileSync(join(opts.packDir, "af_heart.bin"));
+    const voice = new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    loaded = { ort, session, vocab, voice };
+    return loaded;
+  };
+  return async (text) => {
+    const { ort, session, vocab, voice } = await load();
+    const pieces = [];
+    for (const sentence of splitSentences(text)) {
+      const ids = tokenize(phonemize(sentence, ipa), vocab).slice(0, VOICE_ROWS + 1);
+      if (ids.length <= 2) continue;
+      const out = await session.run({
+        input_ids: new ort.Tensor("int64", BigInt64Array.from(ids.map(BigInt)), [1, ids.length]),
+        style: new ort.Tensor("float32", styleRow(voice, ids.length), [1, STYLE_SIZE]),
+        speed: new ort.Tensor("float32", Float32Array.of(1), [1])
+      });
+      if (pieces.length > 0) pieces.push(new Float32Array(Math.round(SENTENCE_GAP * SAMPLE_RATE)));
+      pieces.push(out.waveform.data);
+    }
+    const length = pieces.reduce((sum, piece) => sum + piece.length, 0);
+    if (length === 0) throw new Error(`the narration line "${text}" has nothing to say`);
+    const samples = new Float32Array(length);
+    let at = 0;
+    for (const piece of pieces) {
+      samples.set(piece, at);
+      at += piece.length;
+    }
+    counter += 1;
+    const wavPath = join(opts.workDir, `speech-${counter}.wav`);
+    writeFileSync(wavPath, encodeWav(samples));
+    return { wavPath, seconds: samples.length / SAMPLE_RATE };
+  };
+}
+var BLOCK = 512;
+function field(block, start, length) {
+  const raw = block.subarray(start, start + length);
+  const end = raw.indexOf(0);
+  return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+}
+function octal(block, start, length) {
+  return parseInt(field(block, start, length), 8) || 0;
+}
+function paxPath(data) {
+  let at = 0;
+  while (at < data.length) {
+    const space = data.indexOf(32, at);
+    if (space === -1) return void 0;
+    const length = Number(data.subarray(at, space).toString("utf8"));
+    if (!Number.isFinite(length) || length <= 0) return void 0;
+    const record = data.subarray(space + 1, at + length - 1).toString("utf8");
+    if (record.startsWith("path=")) return record.slice("path=".length);
+    at += length;
+  }
+  return void 0;
+}
+async function extractNpmTarball(tarball, destDir, keep = () => true) {
+  let pending = Buffer.alloc(0);
+  let header;
+  let longPath;
+  let remaining = 0;
+  let padding = 0;
+  let collected = [];
+  let sink;
+  const finished = [];
+  const closeSink = () => {
+    const done = sink;
+    sink = void 0;
+    if (done !== void 0) {
+      finished.push(new Promise((resolve3, reject) => done.on("close", resolve3).on("error", reject)));
+      done.end();
+    }
+  };
+  const startEntry = (entry) => {
+    header = entry;
+    remaining = entry.size;
+    padding = (BLOCK - entry.size % BLOCK) % BLOCK;
+    collected = [];
+    if (entry.type !== "0" && entry.type !== "\0") return;
+    const relative = entry.path.split("/").slice(1).join("/");
+    if (relative === "" || !keep(relative)) return;
+    const target = normalize(join(destDir, relative));
+    if (!target.startsWith(normalize(destDir) + sep)) throw new Error(`the archive has a path outside its folder: ${entry.path}`);
+    mkdirSync(dirname(target), { recursive: true });
+    sink = createWriteStream(target, { mode: 493 });
+  };
+  const consume = (chunk) => {
+    pending = Buffer.concat([pending, chunk]);
+    for (; ; ) {
+      if (header === void 0) {
+        if (pending.length < BLOCK) return;
+        const block = pending.subarray(0, BLOCK);
+        pending = pending.subarray(BLOCK);
+        const name = field(block, 0, 100);
+        const prefix = field(block, 345, 155);
+        const type = String.fromCharCode(block[156] ?? 48);
+        const path = longPath ?? (prefix === "" ? name : `${prefix}/${name}`);
+        longPath = void 0;
+        startEntry({ path, size: octal(block, 124, 12), type });
+        continue;
+      }
+      if (remaining > 0) {
+        if (pending.length === 0) return;
+        const take = Math.min(remaining, pending.length);
+        const part = pending.subarray(0, take);
+        pending = pending.subarray(take);
+        remaining -= take;
+        if (sink !== void 0) sink.write(part);
+        else if (header.type === "x") collected.push(Buffer.from(part));
+        continue;
+      }
+      if (pending.length < padding) return;
+      pending = pending.subarray(padding);
+      if (header.type === "x") longPath = paxPath(Buffer.concat(collected));
+      closeSink();
+      header = void 0;
+    }
+  };
+  await new Promise((resolve3, reject) => {
+    const input = createReadStream(tarball).on("error", reject);
+    const gunzip = createGunzip();
+    input.pipe(gunzip);
+    gunzip.on("data", (chunk) => {
+      try {
+        consume(chunk);
+      } catch (err) {
+        input.destroy();
+        reject(err);
+        return;
+      }
+      const writing = sink;
+      if (writing !== void 0 && writing.writableNeedDrain) {
+        gunzip.pause();
+        writing.once("drain", () => gunzip.resume());
+      }
+    }).on("end", resolve3).on("error", reject);
+  });
+  closeSink();
+  await Promise.all(finished);
+}
+
+// src/demo/voice/pack.ts
+var VoicePackError = class extends Error {
+};
+var DEFAULT_VOICE_PACK_PINS = { version: VOICE_PACK_VERSION, files: VOICE_PACK_FILES };
+var IMAGE_VOICE_ROOT = "/opt/outerlayer/voice";
+function voicePackHomeDir(home, version) {
+  return join(home, ".outerlayer", "voice", version);
+}
+function mismatch(file, actual, dir) {
+  return new VoicePackError(
+    `the voice pack file ${file.name} does not match its pinned sha256 (expected ${file.sha256}, found ${actual}). Delete ${join(dir, file.name)} to download it again. Nothing was spoken.`
+  );
+}
+async function verifyPresent(dir, pins) {
+  const missing = [];
+  for (const file of pins.files) {
+    const path = join(dir, file.name);
+    if (!existsSync(path)) {
+      missing.push(file.name);
+      continue;
+    }
+    const actual = await sha256OfFile(path);
+    if (actual !== file.sha256) throw mismatch(file, actual, dir);
+  }
+  return missing;
+}
+async function ensureVoicePack(opts) {
+  const pins = opts.pins ?? DEFAULT_VOICE_PACK_PINS;
+  const env = opts.env ?? process.env;
+  const log = opts.log ?? (() => void 0);
+  const installed = join(opts.installedRoot ?? IMAGE_VOICE_ROOT, pins.version);
+  if (existsSync(installed)) {
+    const missing2 = await verifyPresent(installed, pins);
+    if (missing2.length === 0) return { dir: installed, version: pins.version };
+  }
+  const dir = voicePackHomeDir(opts.home, pins.version);
+  const missing = await verifyPresent(dir, pins);
+  if (missing.length === 0) return { dir, version: pins.version };
+  const mirror = env.OUTERLAYER_VOICE_MIRROR?.replace(/\/+$/, "");
+  log(`Downloading the narration voice pack to ${dir} (first narrated run only; later runs use the copy there)`);
+  mkdirSync(dir, { recursive: true });
+  for (const file of pins.files.filter((entry) => missing.includes(entry.name))) {
+    await downloadPinned({
+      url: mirror !== void 0 ? `${mirror}/${encodeURIComponent(file.name)}` : file.url,
+      dest: join(dir, file.name),
+      sha256: file.sha256,
+      name: file.name,
+      fetchImpl: opts.fetchImpl ?? fetch,
+      progress: log
+    });
+  }
+  return { dir, version: pins.version };
+}
+var RUNTIME_PACKAGES = [
+  { prefix: "onnxruntime-node-", folder: "onnxruntime-node" },
+  { prefix: "onnxruntime-common-", folder: "onnxruntime-common" }
+];
+async function ensureVoiceRuntime(pack, pins, home) {
+  const dir = join(voicePackHomeDir(home, pack.version), "runtime", `${process.platform}-${process.arch}`);
+  const archives = RUNTIME_PACKAGES.map(({ prefix, folder }) => {
+    const file = pins.files.find((entry) => entry.name.startsWith(prefix) && entry.name.endsWith(".tgz"));
+    if (file === void 0) throw new VoicePackError(`the voice pack pins no ${folder} archive`);
+    return { file, folder };
+  });
+  const marker = join(dir, ".complete");
+  const wanted = JSON.stringify(archives.map(({ file }) => [file.name, file.sha256]));
+  if (existsSync(marker) && readFileSync(marker, "utf8") === wanted) return { dir };
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(dir, { recursive: true });
+  const nativeDir = `bin/napi-v3/${process.platform}/${process.arch}/`;
+  for (const { file, folder } of archives) {
+    await extractNpmTarball(join(pack.dir, file.name), join(dir, "node_modules", folder), (path) => {
+      if (path.startsWith("bin/")) return path.startsWith(nativeDir);
+      return path === "package.json" || path === "LICENSE" || path.startsWith("dist/");
+    });
+  }
+  if (!existsSync(join(dir, "node_modules", "onnxruntime-node", nativeDir))) {
+    rmSync(dir, { recursive: true, force: true });
+    throw new VoicePackError(`the ONNX Runtime has no build for ${process.platform} ${process.arch}, so narration cannot run here; pass --no-narration`);
+  }
+  writeFileSync(join(dir, "package.json"), '{"private":true}\n');
+  writeFileSync(marker, wanted);
+  return { dir };
+}
+
+// src/emit-demo-cmd.ts
+var EmitDemoError = class extends Error {
+};
+var MIB = 1024 * 1024;
+function parseManifest(path, options) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    throw new EmitDemoError(`cannot read the manifest "${path}": ${String(err)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw new EmitDemoError(`the manifest "${path}" is not valid JSON: ${String(err)}`);
+  }
+  const parsed = DemoManifestSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const where = issue.path.length > 0 ? ` at ${issue.path.join(".")}` : "";
+    throw new EmitDemoError(`the manifest "${path}" is not valid${where}: ${issue.message}`);
+  }
+  const videoPath = resolve(dirname(path), parsed.data.video);
+  if (!options.needVideo) return { manifest: parsed.data, videoPath, text };
+  try {
+    if (!statSync(videoPath).isFile()) throw new Error("not a file");
+  } catch {
+    throw new EmitDemoError(`the manifest names the video "${parsed.data.video}", but ${videoPath} does not exist`);
+  }
+  return { manifest: parsed.data, videoPath, text };
+}
+async function runEmitDemo(opts) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const home = opts.home ?? homeFromEnv(env);
+  const say = (line) => {
+    if (!opts.quiet) process.stderr.write(`${line}
+`);
+  };
+  const manifestPath = resolve(cwd, opts.manifest);
+  const { manifest, videoPath, text: manifestText } = parseManifest(manifestPath, { needVideo: true });
+  const comparisons = compareRuns({ first: { manifest, dir: dirname(manifestPath) }, firstPath: manifestPath, secondPath: opts.compare === void 0 ? void 0 : resolve(cwd, opts.compare) });
+  const narrated = opts.noNarration !== true && manifest.chapters.some((chapter) => chapter.narration.trim() !== "");
+  for (const program of narrated ? ["ffmpeg", "ffprobe", "espeak-ng"] : ["ffmpeg", "ffprobe"]) {
+    if (findProgram(program, env) === void 0) throw new EmitDemoError(missingProgramMessage(program, narrated));
+  }
+  const fetchImpl = opts.fetchImpl ?? defaultFetch;
+  const media = opts.media ?? createMediaTools(env);
+  const recordedIds = await recordedCriteria({ opts, env, cwd, home, fetchImpl, say });
+  let videoSeconds;
+  try {
+    videoSeconds = media.probe(videoPath);
+  } catch (err) {
+    throw new EmitDemoError(`cannot read the video ${videoPath}: ${String(err)}`);
+  }
+  const problem = checkManifest({ manifest, videoSeconds, recordedIds });
+  if (problem !== void 0) throw new EmitDemoError(problem);
+  const work = mkdtempSync(join(tmpdir(), "outerlayer-demo-"));
+  try {
+    const speaker = narrated ? opts.speaker ?? await realSpeaker({ env, home, work, say, installedRoot: opts.installedVoiceRoot }) : void 0;
+    const plans = [];
+    for (const [index, chapter] of manifest.chapters.entries()) {
+      const plan = {
+        video: videoPath,
+        start: chapter.start,
+        end: chapter.end,
+        output: join(work, `chapter-${String(index + 1).padStart(2, "0")}.webm`)
+      };
+      if (speaker !== void 0 && chapter.narration.trim() !== "") {
+        let speech;
+        try {
+          speech = await speaker(chapter.narration);
+        } catch (err) {
+          throw new EmitDemoError(`${chapterLabel(index, chapter.title)}: the narration could not be spoken: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const fit = fitSpeech(speech.seconds, chapter.end - chapter.start);
+        if (!fit.ok) {
+          throw new EmitDemoError(
+            `${chapterLabel(index, chapter.title)}: the narration runs ${fit.overrunSeconds.toFixed(1)} s too long even at 1.3 times speed \u2014 shorten the line or lengthen the chapter`
+          );
+        }
+        plan.audio = { wavPath: speech.wavPath, tempo: fit.tempo, delaySeconds: SPEECH_LEAD_IN };
+      } else if (speaker !== void 0) {
+        plan.audio = "silence";
+      }
+      plans.push(plan);
+    }
+    for (const [index, plan] of plans.entries()) {
+      const chapter = manifest.chapters[index];
+      try {
+        media.renderClip(plan);
+      } catch (err) {
+        throw new EmitDemoError(`${chapterLabel(index, chapter.title)}: ffmpeg could not cut the clip: ${String(err)}`);
+      }
+      const bytes = statSync(plan.output).size;
+      if (bytes > ARTIFACT_MAX_BYTES) {
+        throw new EmitDemoError(
+          `${chapterLabel(index, chapter.title)}: the clip is ${(bytes / MIB).toFixed(1)} MiB, over the ${ARTIFACT_MAX_BYTES / MIB} MiB limit \u2014 shorten the chapter or record a smaller window`
+        );
+      }
+    }
+    const seed = createHash("sha256").update(manifestText).update("\0").update(readFileSync(videoPath)).update(`\0${opts.item ?? ""}\0${opts.pr ?? ""}`).digest("hex");
+    const idFor = (label, file) => `demo-${createHash("sha256").update(seed).update("\0").update(label).update("\0").update(readFileSync(file)).digest("hex").slice(0, 40)}`;
+    const clipIds = plans.map((plan, index) => idFor(`clip-${index + 1}`, plan.output));
+    const plannedRecord = JSON.stringify(
+      buildDemoRecord(
+        manifest,
+        manifest.chapters.map((chapter, index) => ({ clipArtifactId: clipIds[index], bound: chapter.criterionId !== null && chapterPassed(chapter.checks) })),
+        comparisons
+      )
+    );
+    const recordBytes = Buffer.byteLength(plannedRecord);
+    if (recordBytes > ARTIFACT_MAX_BYTES) {
+      throw new EmitDemoError(
+        `the demo record is ${(recordBytes / MIB).toFixed(1)} MiB, over the ${ARTIFACT_MAX_BYTES / MIB} MiB limit \u2014 shorten the checks, titles and narration`
+      );
+    }
+    const emit = opts.emitArtifact ?? runEmitArtifact;
+    const base = {
+      pr: opts.pr,
+      url: opts.url,
+      apiKey: opts.apiKey,
+      appId: opts.appId,
+      quiet: true,
+      json: true,
+      cwd,
+      home,
+      env,
+      fetchImpl: opts.fetchImpl
+    };
+    const clips = [];
+    const failures = [];
+    for (const [index, chapter] of manifest.chapters.entries()) {
+      const bound = chapter.criterionId !== null && chapterPassed(chapter.checks);
+      const failed = chapter.checks.filter((check) => !check.passed);
+      if (failed.length > 0) {
+        failures.push(`${chapterLabel(index, chapter.title)} failed: ${failed.map((check) => `"${check.text}"`).join(", ")}`);
+      } else if (chapter.criterionId !== null && chapter.checks.length === 0) {
+        say(`${C.yellow}!${C.reset} ${chapterLabel(index, chapter.title)} ran no checks, so its clip is not bound to ${chapter.criterionId}`);
+      }
+      const caption = `Demo chapter ${index + 1}: ${chapter.title}${failed.length > 0 ? ` (${failed.length} failed check${failed.length === 1 ? "" : "s"})` : ""}`;
+      const result = await emitOrExplain(emit, {
+        ...base,
+        file: plans[index].output,
+        artifactId: clipIds[index],
+        caption: caption.slice(0, ARTIFACT_MAX_CAPTION_LENGTH),
+        ...bound ? { criterionId: chapter.criterionId } : {}
+      }, clips.length, manifest.chapters.length);
+      clips.push({ clipArtifactId: artifactIdOf(result), bound, title: chapter.title, comparable: comparisons[index].comparable });
+    }
+    const record = buildDemoRecord(manifest, clips, comparisons);
+    const recordPath = join(work, "demo.json");
+    writeFileSync(recordPath, JSON.stringify(record));
+    const recorded = await emitOrExplain(emit, {
+      ...base,
+      file: recordPath,
+      artifactId: idFor("record", recordPath),
+      caption: `Demo record: ${clips.length} chapter${clips.length === 1 ? "" : "s"}, ${clips.filter((clip) => clip.bound).length} bound to a criterion`,
+      mediaType: DEMO_RECORD_MEDIA_TYPE
+    }, clips.length, manifest.chapters.length);
+    const recordArtifactId = artifactIdOf(recorded);
+    const exitCode = failures.length > 0 ? 1 : 0;
+    const differences = manifest.chapters.flatMap((chapter, index) => {
+      const difference = comparisons[index].difference;
+      if (difference === void 0) return [];
+      const { x, y, width, height } = difference.region;
+      return [`${chapterLabel(index, chapter.title)} is not comparable: the still after check ${difference.check + 1} differs in the region x ${x}, y ${y}, ${width} \xD7 ${height} (width \xD7 height)`];
+    });
+    const compared = comparisons.filter((comparison) => comparison.comparable !== "not checked").length;
+    const summary = `${C.green}\u2713${C.reset} demo emitted ${C.dim}\xB7${C.reset} ${clips.length} clip${clips.length === 1 ? "" : "s"}, ${clips.filter((clip) => clip.bound).length} bound to a criterion ${C.dim}\xB7${C.reset} record ${recordArtifactId}`;
+    const output = opts.json ? JSON.stringify({ recordArtifactId, clips, failures, differences, exitCode }) : [
+      ...differences.map((line) => `${C.yellow}!${C.reset} ${line}`),
+      summary + (opts.compare === void 0 ? "" : ` ${C.dim}\xB7${C.reset} ${compared} of ${clips.length} chapter${clips.length === 1 ? "" : "s"} compared, ${comparisons.filter((comparison) => comparison.comparable === "yes").length} comparable`)
+    ].join("\n");
+    if (!opts.quiet) process.stdout.write(output + "\n");
+    return { exitCode, output, failures, recordArtifactId, clips, differences };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+function compareRuns(params) {
+  const { first, firstPath, secondPath } = params;
+  try {
+    if (secondPath === void 0) return compareChapters({ first });
+    if (sameFile(firstPath, secondPath)) {
+      throw new EmitDemoError(`the two runs are the same manifest "${firstPath}" \u2014 one run cannot confirm itself, so pass the manifest of a second run`);
+    }
+    const second = { manifest: parseManifest(secondPath, { needVideo: false }).manifest, dir: dirname(secondPath) };
+    const unpaired = pairManifests(first.manifest, second.manifest);
+    if (unpaired !== void 0) throw new EmitDemoError(`the two runs cannot be compared \u2014 ${unpaired}`);
+    return compareChapters({ first, second });
+  } catch (err) {
+    if (err instanceof StillError) throw new EmitDemoError(err.message);
+    throw err;
+  }
+}
+function sameFile(a, b) {
+  const real = (path) => {
+    try {
+      return realpathSync(path);
+    } catch {
+      return path;
+    }
+  };
+  return real(a) === real(b);
+}
+function artifactIdOf(result) {
+  const id = result.record?.artifactId ?? result.data?.clientArtifactId;
+  if (typeof id !== "string") throw new EmitDemoError("the artifact was emitted but its id was not returned");
+  return id;
+}
+async function emitOrExplain(emit, opts, emitted, total) {
+  try {
+    return await emit(opts);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new EmitDemoError(
+      emitted > 0 ? `${message} \u2014 ${emitted} of ${total} clips were already emitted; run the command again to emit the whole demo` : message
+    );
+  }
+}
+async function recordedCriteria(params) {
+  const { opts, env, cwd, home, fetchImpl, say } = params;
+  let item = opts.item;
+  if (item === void 0) {
+    const identity = resolveRepoIdentity(cwd);
+    const sessionId = detectActiveSession({
+      env,
+      home,
+      cwds: identity.repoRoot !== void 0 ? [identity.repoRoot, cwd] : [cwd],
+      nowMs: Date.now()
+    });
+    item = sessionId === void 0 ? void 0 : launchedItemForSession(sessionId, home);
+  }
+  if (item === void 0) {
+    say(`${C.yellow}!${C.reset} no work item, so the chapters' criterion ids are not checked against the recorded criteria (pass --item <number>)`);
+    return void 0;
+  }
+  try {
+    const refusal = await autoConnect({ url: opts.url, apiKey: opts.apiKey, appId: opts.appId, cwd, home, env, fetchImpl: opts.fetchImpl });
+    if (refusal !== void 0) throw new Error(refusal);
+    const resolved = resolveGatewayCredentials({ url: opts.url, apiKey: opts.apiKey, appId: opts.appId, cwd, home, env });
+    if (!resolved.ok) throw new Error(resolved.message);
+    const ids = await readRecordedCriteriaIds({ url: resolved.url, apiKey: resolved.credential, appId: resolved.appId, item, fetchImpl });
+    if (ids === void 0) say(`${C.yellow}!${C.reset} item ${item} has no recorded criteria, so the chapters' criterion ids are not checked`);
+    return ids;
+  } catch (err) {
+    say(`${C.yellow}!${C.reset} could not read the recorded criteria of item ${item}, so the chapters' criterion ids are not checked: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+async function realSpeaker(params) {
+  const { env, home, work, say, installedRoot } = params;
+  try {
+    const pack = await ensureVoicePack({ home, env, log: say, ...installedRoot ? { installedRoot } : {} });
+    const runtime = await ensureVoiceRuntime(pack, DEFAULT_VOICE_PACK_PINS, home);
+    mkdirSync(work, { recursive: true });
+    return createKokoroSpeaker({ packDir: pack.dir, runtimeDir: runtime.dir, espeakPath: findProgram("espeak-ng", env) ?? "espeak-ng", workDir: work });
+  } catch (err) {
+    if (err instanceof VoicePackError || err instanceof VoiceDownloadError) throw new EmitDemoError(err.message);
+    throw err;
+  }
+}
+
+export { EmitDemoError, runEmitDemo };