brs-js 2.1.3 → 3.0.1

package/dist/dist.js.map

@@ -1 +1 @@
-{"version":3,"file":"dist.js","mappings":"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","sources":["webpack://brs-js/./node_modules/pako/lib/inflate.js","webpack://brs-js/./node_modules/pako/lib/zlib/adler32.js","webpack://brs-js/./node_modules/pako/lib/zlib/inffast.js","webpack://brs-js/./node_modules/pako/lib/deflate.js","webpack://brs-js/./node_modules/pako/lib/zlib/deflate.js","webpack://brs-js/./node_modules/pako/lib/zlib/gzheader.js","webpack://brs-js/./node_modules/pako/lib/zlib/zstream.js","webpack://brs-js/./node_modules/pako/lib/zlib/inflate.js","webpack://brs-js/./node_modules/pako/lib/zlib/trees.js","webpack://brs-js/./node_modules/pako/index.js","webpack://brs-js/./node_modules/pako/lib/zlib/messages.js","webpack://brs-js/./node_modules/pako/lib/zlib/constants.js","webpack://brs-js/./node_modules/pako/lib/utils/common.js","webpack://brs-js/./node_modules/pako/lib/zlib/crc32.js","webpack://brs-js/./node_modules/pako/lib/utils/strings.js","webpack://brs-js/./node_modules/pako/lib/zlib/inftrees.js","webpack://brs-js/webpack/bootstrap","webpack://brs-js/webpack/runtime/define property getters","webpack://brs-js/webpack/runtime/hasOwnProperty shorthand","webpack://brs-js/webpack/runtime/make namespace object","webpack://brs-js/./src/constants.ts","webpack://brs-js/./src/uuid.ts","webpack://brs-js/./src/utils.ts","webpack://brs-js/./src/write.ts","webpack://brs-js/./src/types.ts","webpack://brs-js/./src/index.ts","webpack://brs-js/./src/read.ts","webpack://brs-js/./src/read.v1.ts","webpack://brs-js/./src/read.v2.ts","webpack://brs-js/./src/read.v3.ts","webpack://brs-js/./src/read.v4.ts","webpack://brs-js/./src/read.v8.ts","webpack://brs-js/./src/read.v9.ts","webpack://brs-js/./src/read.v10.ts","webpack://brs-js/./src/read.v14.ts"],"sourcesContent":["'use strict';\n\n\nvar zlib_inflate = require('./zlib/inflate');\nvar utils        = require('./utils/common');\nvar strings      = require('./utils/strings');\nvar c            = require('./zlib/constants');\nvar msg          = require('./zlib/messages');\nvar ZStream      = require('./zlib/zstream');\nvar GZheader     = require('./zlib/gzheader');\n\nvar toString = Object.prototype.toString;\n\n/**\n * class Inflate\n *\n * Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[inflate]]\n * and [[inflateRaw]].\n **/\n\n/* internal\n * inflate.chunks -> Array\n *\n * Chunks of output data, if [[Inflate#onData]] not overridden.\n **/\n\n/**\n * Inflate.result -> Uint8Array|Array|String\n *\n * Uncompressed result, generated by default [[Inflate#onData]]\n * and [[Inflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you\n * push a chunk with explicit flush (call [[Inflate#push]] with\n * `Z_SYNC_FLUSH` param).\n **/\n\n/**\n * Inflate.err -> Number\n *\n * Error code after inflate finished. 0 (Z_OK) on success.\n * Should be checked if broken data possible.\n **/\n\n/**\n * Inflate.msg -> String\n *\n * Error message, if [[Inflate.err]] != 0\n **/\n\n\n/**\n * new Inflate(options)\n * - options (Object): zlib inflate options.\n *\n * Creates new inflator instance with specified params. Throws exception\n * on bad params. Supported options:\n *\n * - `windowBits`\n * - `dictionary`\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Additional options, for internal needs:\n *\n * - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw inflate\n * - `to` (String) - if equal to 'string', then result will be converted\n *   from utf8 to utf16 (javascript) string. When string output requested,\n *   chunk length can differ from `chunkSize`, depending on content.\n *\n * By default, when no options set, autodetect deflate/gzip data format via\n * wrapper header.\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])\n *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n *\n * var inflate = new pako.Inflate({ level: 3});\n *\n * inflate.push(chunk1, false);\n * inflate.push(chunk2, true);  // true -> last chunk\n *\n * if (inflate.err) { throw new Error(inflate.err); }\n *\n * console.log(inflate.result);\n * ```\n **/\nfunction Inflate(options) {\n  if (!(this instanceof Inflate)) return new Inflate(options);\n\n  this.options = utils.assign({\n    chunkSize: 16384,\n    windowBits: 0,\n    to: ''\n  }, options || {});\n\n  var opt = this.options;\n\n  // Force window size for `raw` data, if not set directly,\n  // because we have no header for autodetect.\n  if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {\n    opt.windowBits = -opt.windowBits;\n    if (opt.windowBits === 0) { opt.windowBits = -15; }\n  }\n\n  // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate\n  if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&\n      !(options && options.windowBits)) {\n    opt.windowBits += 32;\n  }\n\n  // Gzip header has no info about windows size, we can do autodetect only\n  // for deflate. So, if window size not set, force it to max when gzip possible\n  if ((opt.windowBits > 15) && (opt.windowBits < 48)) {\n    // bit 3 (16) -> gzipped data\n    // bit 4 (32) -> autodetect gzip/deflate\n    if ((opt.windowBits & 15) === 0) {\n      opt.windowBits |= 15;\n    }\n  }\n\n  this.err    = 0;      // error code, if happens (0 = Z_OK)\n  this.msg    = '';     // error message\n  this.ended  = false;  // used to avoid multiple onEnd() calls\n  this.chunks = [];     // chunks of compressed data\n\n  this.strm   = new ZStream();\n  this.strm.avail_out = 0;\n\n  var status  = zlib_inflate.inflateInit2(\n    this.strm,\n    opt.windowBits\n  );\n\n  if (status !== c.Z_OK) {\n    throw new Error(msg[status]);\n  }\n\n  this.header = new GZheader();\n\n  zlib_inflate.inflateGetHeader(this.strm, this.header);\n\n  // Setup dictionary\n  if (opt.dictionary) {\n    // Convert data if needed\n    if (typeof opt.dictionary === 'string') {\n      opt.dictionary = strings.string2buf(opt.dictionary);\n    } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n      opt.dictionary = new Uint8Array(opt.dictionary);\n    }\n    if (opt.raw) { //In raw mode we need to set the dictionary early\n      status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);\n      if (status !== c.Z_OK) {\n        throw new Error(msg[status]);\n      }\n    }\n  }\n}\n\n/**\n * Inflate#push(data[, mode]) -> Boolean\n * - data (Uint8Array|Array|ArrayBuffer|String): input data\n * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n *\n * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with\n * new output chunks. Returns `true` on success. The last data block must have\n * mode Z_FINISH (or `true`). That will flush internal pending buffers and call\n * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you\n * can use mode Z_SYNC_FLUSH, keeping the decompression context.\n *\n * On fail call [[Inflate#onEnd]] with error code and return false.\n *\n * We strongly recommend to use `Uint8Array` on input for best speed (output\n * format is detected automatically). Also, don't skip last param and always\n * use the same type in your code (boolean or number). That will improve JS speed.\n *\n * For regular `Array`-s make sure all elements are [0..255].\n *\n * ##### Example\n *\n * ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true);  // push last chunk\n * ```\n **/\nInflate.prototype.push = function (data, mode) {\n  var strm = this.strm;\n  var chunkSize = this.options.chunkSize;\n  var dictionary = this.options.dictionary;\n  var status, _mode;\n  var next_out_utf8, tail, utf8str;\n\n  // Flag to properly process Z_BUF_ERROR on testing inflate call\n  // when we check that all output data was flushed.\n  var allowBufError = false;\n\n  if (this.ended) { return false; }\n  _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);\n\n  // Convert data if needed\n  if (typeof data === 'string') {\n    // Only binary strings can be decompressed on practice\n    strm.input = strings.binstring2buf(data);\n  } else if (toString.call(data) === '[object ArrayBuffer]') {\n    strm.input = new Uint8Array(data);\n  } else {\n    strm.input = data;\n  }\n\n  strm.next_in = 0;\n  strm.avail_in = strm.input.length;\n\n  do {\n    if (strm.avail_out === 0) {\n      strm.output = new utils.Buf8(chunkSize);\n      strm.next_out = 0;\n      strm.avail_out = chunkSize;\n    }\n\n    status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);    /* no bad return value */\n\n    if (status === c.Z_NEED_DICT && dictionary) {\n      status = zlib_inflate.inflateSetDictionary(this.strm, dictionary);\n    }\n\n    if (status === c.Z_BUF_ERROR && allowBufError === true) {\n      status = c.Z_OK;\n      allowBufError = false;\n    }\n\n    if (status !== c.Z_STREAM_END && status !== c.Z_OK) {\n      this.onEnd(status);\n      this.ended = true;\n      return false;\n    }\n\n    if (strm.next_out) {\n      if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {\n\n        if (this.options.to === 'string') {\n\n          next_out_utf8 = strings.utf8border(strm.output, strm.next_out);\n\n          tail = strm.next_out - next_out_utf8;\n          utf8str = strings.buf2string(strm.output, next_out_utf8);\n\n          // move tail\n          strm.next_out = tail;\n          strm.avail_out = chunkSize - tail;\n          if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }\n\n          this.onData(utf8str);\n\n        } else {\n          this.onData(utils.shrinkBuf(strm.output, strm.next_out));\n        }\n      }\n    }\n\n    // When no more input data, we should check that internal inflate buffers\n    // are flushed. The only way to do it when avail_out = 0 - run one more\n    // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.\n    // Here we set flag to process this error properly.\n    //\n    // NOTE. Deflate does not return error in this case and does not needs such\n    // logic.\n    if (strm.avail_in === 0 && strm.avail_out === 0) {\n      allowBufError = true;\n    }\n\n  } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);\n\n  if (status === c.Z_STREAM_END) {\n    _mode = c.Z_FINISH;\n  }\n\n  // Finalize on the last chunk.\n  if (_mode === c.Z_FINISH) {\n    status = zlib_inflate.inflateEnd(this.strm);\n    this.onEnd(status);\n    this.ended = true;\n    return status === c.Z_OK;\n  }\n\n  // callback interim results if Z_SYNC_FLUSH.\n  if (_mode === c.Z_SYNC_FLUSH) {\n    this.onEnd(c.Z_OK);\n    strm.avail_out = 0;\n    return true;\n  }\n\n  return true;\n};\n\n\n/**\n * Inflate#onData(chunk) -> Void\n * - chunk (Uint8Array|Array|String): output data. Type of array depends\n *   on js engine support. When string output requested, each chunk\n *   will be string.\n *\n * By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n **/\nInflate.prototype.onData = function (chunk) {\n  this.chunks.push(chunk);\n};\n\n\n/**\n * Inflate#onEnd(status) -> Void\n * - status (Number): inflate status. 0 (Z_OK) on success,\n *   other if not.\n *\n * Called either after you tell inflate that the input stream is\n * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)\n * or if an error happened. By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n **/\nInflate.prototype.onEnd = function (status) {\n  // On success - join\n  if (status === c.Z_OK) {\n    if (this.options.to === 'string') {\n      // Glue & convert here, until we teach pako to send\n      // utf8 aligned strings to onData\n      this.result = this.chunks.join('');\n    } else {\n      this.result = utils.flattenChunks(this.chunks);\n    }\n  }\n  this.chunks = [];\n  this.err = status;\n  this.msg = this.strm.msg;\n};\n\n\n/**\n * inflate(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * Decompress `data` with inflate/ungzip and `options`. Autodetect\n * format via wrapper header by default. That's why we don't provide\n * separate `ungzip` method.\n *\n * Supported options are:\n *\n * - windowBits\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information.\n *\n * Sugar (options):\n *\n * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n *   negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be converted\n *   from utf8 to utf16 (javascript) string. When string output requested,\n *   chunk length can differ from `chunkSize`, depending on content.\n *\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , input = pako.deflate([1,2,3,4,5,6,7,8,9])\n *   , output;\n *\n * try {\n *   output = pako.inflate(input);\n * } catch (err)\n *   console.log(err);\n * }\n * ```\n **/\nfunction inflate(input, options) {\n  var inflator = new Inflate(options);\n\n  inflator.push(input, true);\n\n  // That will never happens, if you don't cheat with options :)\n  if (inflator.err) { throw inflator.msg || msg[inflator.err]; }\n\n  return inflator.result;\n}\n\n\n/**\n * inflateRaw(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * The same as [[inflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n **/\nfunction inflateRaw(input, options) {\n  options = options || {};\n  options.raw = true;\n  return inflate(input, options);\n}\n\n\n/**\n * ungzip(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * Just shortcut to [[inflate]], because it autodetects format\n * by header.content. Done for convenience.\n **/\n\n\nexports.Inflate = Inflate;\nexports.inflate = inflate;\nexports.inflateRaw = inflateRaw;\nexports.ungzip  = inflate;\n","'use strict';\n\n// Note: adler32 takes 12% for level 0 and 2% for level 6.\n// It isn't worth it to make additional optimizations as in original.\n// Small size is preferable.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction adler32(adler, buf, len, pos) {\n  var s1 = (adler & 0xffff) |0,\n      s2 = ((adler >>> 16) & 0xffff) |0,\n      n = 0;\n\n  while (len !== 0) {\n    // Set limit ~ twice less than 5552, to keep\n    // s2 in 31-bits, because we force signed ints.\n    // in other case %= will fail.\n    n = len > 2000 ? 2000 : len;\n    len -= n;\n\n    do {\n      s1 = (s1 + buf[pos++]) |0;\n      s2 = (s2 + s1) |0;\n    } while (--n);\n\n    s1 %= 65521;\n    s2 %= 65521;\n  }\n\n  return (s1 | (s2 << 16)) |0;\n}\n\n\nmodule.exports = adler32;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// See state defs from inflate.js\nvar BAD = 30;       /* got a data error -- remain here until reset */\nvar TYPE = 12;      /* i: waiting for type bits, including last-flag bit */\n\n/*\n   Decode literal, length, and distance codes and write out the resulting\n   literal and match bytes until either not enough input or output is\n   available, an end-of-block is encountered, or a data error is encountered.\n   When large enough input and output buffers are supplied to inflate(), for\n   example, a 16K input buffer and a 64K output buffer, more than 95% of the\n   inflate execution time is spent in this routine.\n\n   Entry assumptions:\n\n        state.mode === LEN\n        strm.avail_in >= 6\n        strm.avail_out >= 258\n        start >= strm.avail_out\n        state.bits < 8\n\n   On return, state.mode is one of:\n\n        LEN -- ran out of enough output space or enough available input\n        TYPE -- reached end of block code, inflate() to interpret next block\n        BAD -- error in block data\n\n   Notes:\n\n    - The maximum input bits used by a length/distance pair is 15 bits for the\n      length code, 5 bits for the length extra, 15 bits for the distance code,\n      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.\n      Therefore if strm.avail_in >= 6, then there is enough input to avoid\n      checking for available input while decoding.\n\n    - The maximum bytes that a single length/distance pair can output is 258\n      bytes, which is the maximum length that can be coded.  inflate_fast()\n      requires strm.avail_out >= 258 for each loop to avoid checking for\n      output space.\n */\nmodule.exports = function inflate_fast(strm, start) {\n  var state;\n  var _in;                    /* local strm.input */\n  var last;                   /* have enough input while in < last */\n  var _out;                   /* local strm.output */\n  var beg;                    /* inflate()'s initial strm.output */\n  var end;                    /* while out < end, enough space available */\n//#ifdef INFLATE_STRICT\n  var dmax;                   /* maximum distance from zlib header */\n//#endif\n  var wsize;                  /* window size or zero if not using window */\n  var whave;                  /* valid bytes in the window */\n  var wnext;                  /* window write index */\n  // Use `s_window` instead `window`, avoid conflict with instrumentation tools\n  var s_window;               /* allocated sliding window, if wsize != 0 */\n  var hold;                   /* local strm.hold */\n  var bits;                   /* local strm.bits */\n  var lcode;                  /* local strm.lencode */\n  var dcode;                  /* local strm.distcode */\n  var lmask;                  /* mask for first level of length codes */\n  var dmask;                  /* mask for first level of distance codes */\n  var here;                   /* retrieved table entry */\n  var op;                     /* code bits, operation, extra bits, or */\n                              /*  window position, window bytes to copy */\n  var len;                    /* match length, unused bytes */\n  var dist;                   /* match distance */\n  var from;                   /* where to copy match from */\n  var from_source;\n\n\n  var input, output; // JS specific, because we have no pointers\n\n  /* copy state to local variables */\n  state = strm.state;\n  //here = state.here;\n  _in = strm.next_in;\n  input = strm.input;\n  last = _in + (strm.avail_in - 5);\n  _out = strm.next_out;\n  output = strm.output;\n  beg = _out - (start - strm.avail_out);\n  end = _out + (strm.avail_out - 257);\n//#ifdef INFLATE_STRICT\n  dmax = state.dmax;\n//#endif\n  wsize = state.wsize;\n  whave = state.whave;\n  wnext = state.wnext;\n  s_window = state.window;\n  hold = state.hold;\n  bits = state.bits;\n  lcode = state.lencode;\n  dcode = state.distcode;\n  lmask = (1 << state.lenbits) - 1;\n  dmask = (1 << state.distbits) - 1;\n\n\n  /* decode literals and length/distances until end-of-block or not enough\n     input data or output space */\n\n  top:\n  do {\n    if (bits < 15) {\n      hold += input[_in++] << bits;\n      bits += 8;\n      hold += input[_in++] << bits;\n      bits += 8;\n    }\n\n    here = lcode[hold & lmask];\n\n    dolen:\n    for (;;) { // Goto emulation\n      op = here >>> 24/*here.bits*/;\n      hold >>>= op;\n      bits -= op;\n      op = (here >>> 16) & 0xff/*here.op*/;\n      if (op === 0) {                          /* literal */\n        //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n        //        \"inflate:         literal '%c'\\n\" :\n        //        \"inflate:         literal 0x%02x\\n\", here.val));\n        output[_out++] = here & 0xffff/*here.val*/;\n      }\n      else if (op & 16) {                     /* length base */\n        len = here & 0xffff/*here.val*/;\n        op &= 15;                           /* number of extra bits */\n        if (op) {\n          if (bits < op) {\n            hold += input[_in++] << bits;\n            bits += 8;\n          }\n          len += hold & ((1 << op) - 1);\n          hold >>>= op;\n          bits -= op;\n        }\n        //Tracevv((stderr, \"inflate:         length %u\\n\", len));\n        if (bits < 15) {\n          hold += input[_in++] << bits;\n          bits += 8;\n          hold += input[_in++] << bits;\n          bits += 8;\n        }\n        here = dcode[hold & dmask];\n\n        dodist:\n        for (;;) { // goto emulation\n          op = here >>> 24/*here.bits*/;\n          hold >>>= op;\n          bits -= op;\n          op = (here >>> 16) & 0xff/*here.op*/;\n\n          if (op & 16) {                      /* distance base */\n            dist = here & 0xffff/*here.val*/;\n            op &= 15;                       /* number of extra bits */\n            if (bits < op) {\n              hold += input[_in++] << bits;\n              bits += 8;\n              if (bits < op) {\n                hold += input[_in++] << bits;\n                bits += 8;\n              }\n            }\n            dist += hold & ((1 << op) - 1);\n//#ifdef INFLATE_STRICT\n            if (dist > dmax) {\n              strm.msg = 'invalid distance too far back';\n              state.mode = BAD;\n              break top;\n            }\n//#endif\n            hold >>>= op;\n            bits -= op;\n            //Tracevv((stderr, \"inflate:         distance %u\\n\", dist));\n            op = _out - beg;                /* max distance in output */\n            if (dist > op) {                /* see if copy from window */\n              op = dist - op;               /* distance back in window */\n              if (op > whave) {\n                if (state.sane) {\n                  strm.msg = 'invalid distance too far back';\n                  state.mode = BAD;\n                  break top;\n                }\n\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n//                if (len <= op - whave) {\n//                  do {\n//                    output[_out++] = 0;\n//                  } while (--len);\n//                  continue top;\n//                }\n//                len -= op - whave;\n//                do {\n//                  output[_out++] = 0;\n//                } while (--op > whave);\n//                if (op === 0) {\n//                  from = _out - dist;\n//                  do {\n//                    output[_out++] = output[from++];\n//                  } while (--len);\n//                  continue top;\n//                }\n//#endif\n              }\n              from = 0; // window index\n              from_source = s_window;\n              if (wnext === 0) {           /* very common case */\n                from += wsize - op;\n                if (op < len) {         /* some from window */\n                  len -= op;\n                  do {\n                    output[_out++] = s_window[from++];\n                  } while (--op);\n                  from = _out - dist;  /* rest from output */\n                  from_source = output;\n                }\n              }\n              else if (wnext < op) {      /* wrap around window */\n                from += wsize + wnext - op;\n                op -= wnext;\n                if (op < len) {         /* some from end of window */\n                  len -= op;\n                  do {\n                    output[_out++] = s_window[from++];\n                  } while (--op);\n                  from = 0;\n                  if (wnext < len) {  /* some from start of window */\n                    op = wnext;\n                    len -= op;\n                    do {\n                      output[_out++] = s_window[from++];\n                    } while (--op);\n                    from = _out - dist;      /* rest from output */\n                    from_source = output;\n                  }\n                }\n              }\n              else {                      /* contiguous in window */\n                from += wnext - op;\n                if (op < len) {         /* some from window */\n                  len -= op;\n                  do {\n                    output[_out++] = s_window[from++];\n                  } while (--op);\n                  from = _out - dist;  /* rest from output */\n                  from_source = output;\n                }\n              }\n              while (len > 2) {\n                output[_out++] = from_source[from++];\n                output[_out++] = from_source[from++];\n                output[_out++] = from_source[from++];\n                len -= 3;\n              }\n              if (len) {\n                output[_out++] = from_source[from++];\n                if (len > 1) {\n                  output[_out++] = from_source[from++];\n                }\n              }\n            }\n            else {\n              from = _out - dist;          /* copy direct from output */\n              do {                        /* minimum length is three */\n                output[_out++] = output[from++];\n                output[_out++] = output[from++];\n                output[_out++] = output[from++];\n                len -= 3;\n              } while (len > 2);\n              if (len) {\n                output[_out++] = output[from++];\n                if (len > 1) {\n                  output[_out++] = output[from++];\n                }\n              }\n            }\n          }\n          else if ((op & 64) === 0) {          /* 2nd level distance code */\n            here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];\n            continue dodist;\n          }\n          else {\n            strm.msg = 'invalid distance code';\n            state.mode = BAD;\n            break top;\n          }\n\n          break; // need to emulate goto via \"continue\"\n        }\n      }\n      else if ((op & 64) === 0) {              /* 2nd level length code */\n        here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];\n        continue dolen;\n      }\n      else if (op & 32) {                     /* end-of-block */\n        //Tracevv((stderr, \"inflate:         end of block\\n\"));\n        state.mode = TYPE;\n        break top;\n      }\n      else {\n        strm.msg = 'invalid literal/length code';\n        state.mode = BAD;\n        break top;\n      }\n\n      break; // need to emulate goto via \"continue\"\n    }\n  } while (_in < last && _out < end);\n\n  /* return unused bytes (on entry, bits < 8, so in won't go too far back) */\n  len = bits >> 3;\n  _in -= len;\n  bits -= len << 3;\n  hold &= (1 << bits) - 1;\n\n  /* update state and return */\n  strm.next_in = _in;\n  strm.next_out = _out;\n  strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));\n  strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));\n  state.hold = hold;\n  state.bits = bits;\n  return;\n};\n","'use strict';\n\n\nvar zlib_deflate = require('./zlib/deflate');\nvar utils        = require('./utils/common');\nvar strings      = require('./utils/strings');\nvar msg          = require('./zlib/messages');\nvar ZStream      = require('./zlib/zstream');\n\nvar toString = Object.prototype.toString;\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\nvar Z_NO_FLUSH      = 0;\nvar Z_FINISH        = 4;\n\nvar Z_OK            = 0;\nvar Z_STREAM_END    = 1;\nvar Z_SYNC_FLUSH    = 2;\n\nvar Z_DEFAULT_COMPRESSION = -1;\n\nvar Z_DEFAULT_STRATEGY    = 0;\n\nvar Z_DEFLATED  = 8;\n\n/* ===========================================================================*/\n\n\n/**\n * class Deflate\n *\n * Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[deflate]],\n * [[deflateRaw]] and [[gzip]].\n **/\n\n/* internal\n * Deflate.chunks -> Array\n *\n * Chunks of output data, if [[Deflate#onData]] not overridden.\n **/\n\n/**\n * Deflate.result -> Uint8Array|Array\n *\n * Compressed result, generated by default [[Deflate#onData]]\n * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Deflate#push]] with `Z_FINISH` / `true` param)  or if you\n * push a chunk with explicit flush (call [[Deflate#push]] with\n * `Z_SYNC_FLUSH` param).\n **/\n\n/**\n * Deflate.err -> Number\n *\n * Error code after deflate finished. 0 (Z_OK) on success.\n * You will not need it in real life, because deflate errors\n * are possible only on wrong options or bad `onData` / `onEnd`\n * custom handlers.\n **/\n\n/**\n * Deflate.msg -> String\n *\n * Error message, if [[Deflate.err]] != 0\n **/\n\n\n/**\n * new Deflate(options)\n * - options (Object): zlib deflate options.\n *\n * Creates new deflator instance with specified params. Throws exception\n * on bad params. Supported options:\n *\n * - `level`\n * - `windowBits`\n * - `memLevel`\n * - `strategy`\n * - `dictionary`\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Additional options, for internal needs:\n *\n * - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw deflate\n * - `gzip` (Boolean) - create gzip wrapper\n * - `to` (String) - if equal to 'string', then result will be \"binary string\"\n *    (each char code [0..255])\n * - `header` (Object) - custom header for gzip\n *   - `text` (Boolean) - true if compressed data believed to be text\n *   - `time` (Number) - modification time, unix timestamp\n *   - `os` (Number) - operation system code\n *   - `extra` (Array) - array of bytes with extra data (max 65536)\n *   - `name` (String) - file name (binary string)\n *   - `comment` (String) - comment (binary string)\n *   - `hcrc` (Boolean) - true if header crc should be added\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])\n *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n *\n * var deflate = new pako.Deflate({ level: 3});\n *\n * deflate.push(chunk1, false);\n * deflate.push(chunk2, true);  // true -> last chunk\n *\n * if (deflate.err) { throw new Error(deflate.err); }\n *\n * console.log(deflate.result);\n * ```\n **/\nfunction Deflate(options) {\n  if (!(this instanceof Deflate)) return new Deflate(options);\n\n  this.options = utils.assign({\n    level: Z_DEFAULT_COMPRESSION,\n    method: Z_DEFLATED,\n    chunkSize: 16384,\n    windowBits: 15,\n    memLevel: 8,\n    strategy: Z_DEFAULT_STRATEGY,\n    to: ''\n  }, options || {});\n\n  var opt = this.options;\n\n  if (opt.raw && (opt.windowBits > 0)) {\n    opt.windowBits = -opt.windowBits;\n  }\n\n  else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {\n    opt.windowBits += 16;\n  }\n\n  this.err    = 0;      // error code, if happens (0 = Z_OK)\n  this.msg    = '';     // error message\n  this.ended  = false;  // used to avoid multiple onEnd() calls\n  this.chunks = [];     // chunks of compressed data\n\n  this.strm = new ZStream();\n  this.strm.avail_out = 0;\n\n  var status = zlib_deflate.deflateInit2(\n    this.strm,\n    opt.level,\n    opt.method,\n    opt.windowBits,\n    opt.memLevel,\n    opt.strategy\n  );\n\n  if (status !== Z_OK) {\n    throw new Error(msg[status]);\n  }\n\n  if (opt.header) {\n    zlib_deflate.deflateSetHeader(this.strm, opt.header);\n  }\n\n  if (opt.dictionary) {\n    var dict;\n    // Convert data if needed\n    if (typeof opt.dictionary === 'string') {\n      // If we need to compress text, change encoding to utf8.\n      dict = strings.string2buf(opt.dictionary);\n    } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n      dict = new Uint8Array(opt.dictionary);\n    } else {\n      dict = opt.dictionary;\n    }\n\n    status = zlib_deflate.deflateSetDictionary(this.strm, dict);\n\n    if (status !== Z_OK) {\n      throw new Error(msg[status]);\n    }\n\n    this._dict_set = true;\n  }\n}\n\n/**\n * Deflate#push(data[, mode]) -> Boolean\n * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be\n *   converted to utf8 byte sequence.\n * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n *\n * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n * new compressed chunks. Returns `true` on success. The last data block must have\n * mode Z_FINISH (or `true`). That will flush internal pending buffers and call\n * [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you\n * can use mode Z_SYNC_FLUSH, keeping the compression context.\n *\n * On fail call [[Deflate#onEnd]] with error code and return false.\n *\n * We strongly recommend to use `Uint8Array` on input for best speed (output\n * array format is detected automatically). Also, don't skip last param and always\n * use the same type in your code (boolean or number). That will improve JS speed.\n *\n * For regular `Array`-s make sure all elements are [0..255].\n *\n * ##### Example\n *\n * ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true);  // push last chunk\n * ```\n **/\nDeflate.prototype.push = function (data, mode) {\n  var strm = this.strm;\n  var chunkSize = this.options.chunkSize;\n  var status, _mode;\n\n  if (this.ended) { return false; }\n\n  _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH);\n\n  // Convert data if needed\n  if (typeof data === 'string') {\n    // If we need to compress text, change encoding to utf8.\n    strm.input = strings.string2buf(data);\n  } else if (toString.call(data) === '[object ArrayBuffer]') {\n    strm.input = new Uint8Array(data);\n  } else {\n    strm.input = data;\n  }\n\n  strm.next_in = 0;\n  strm.avail_in = strm.input.length;\n\n  do {\n    if (strm.avail_out === 0) {\n      strm.output = new utils.Buf8(chunkSize);\n      strm.next_out = 0;\n      strm.avail_out = chunkSize;\n    }\n    status = zlib_deflate.deflate(strm, _mode);    /* no bad return value */\n\n    if (status !== Z_STREAM_END && status !== Z_OK) {\n      this.onEnd(status);\n      this.ended = true;\n      return false;\n    }\n    if (strm.avail_out === 0 || (strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))) {\n      if (this.options.to === 'string') {\n        this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));\n      } else {\n        this.onData(utils.shrinkBuf(strm.output, strm.next_out));\n      }\n    }\n  } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);\n\n  // Finalize on the last chunk.\n  if (_mode === Z_FINISH) {\n    status = zlib_deflate.deflateEnd(this.strm);\n    this.onEnd(status);\n    this.ended = true;\n    return status === Z_OK;\n  }\n\n  // callback interim results if Z_SYNC_FLUSH.\n  if (_mode === Z_SYNC_FLUSH) {\n    this.onEnd(Z_OK);\n    strm.avail_out = 0;\n    return true;\n  }\n\n  return true;\n};\n\n\n/**\n * Deflate#onData(chunk) -> Void\n * - chunk (Uint8Array|Array|String): output data. Type of array depends\n *   on js engine support. When string output requested, each chunk\n *   will be string.\n *\n * By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n **/\nDeflate.prototype.onData = function (chunk) {\n  this.chunks.push(chunk);\n};\n\n\n/**\n * Deflate#onEnd(status) -> Void\n * - status (Number): deflate status. 0 (Z_OK) on success,\n *   other if not.\n *\n * Called once after you tell deflate that the input stream is\n * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)\n * or if an error happened. By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n **/\nDeflate.prototype.onEnd = function (status) {\n  // On success - join\n  if (status === Z_OK) {\n    if (this.options.to === 'string') {\n      this.result = this.chunks.join('');\n    } else {\n      this.result = utils.flattenChunks(this.chunks);\n    }\n  }\n  this.chunks = [];\n  this.err = status;\n  this.msg = this.strm.msg;\n};\n\n\n/**\n * deflate(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * Compress `data` with deflate algorithm and `options`.\n *\n * Supported options are:\n *\n * - level\n * - windowBits\n * - memLevel\n * - strategy\n * - dictionary\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Sugar (options):\n *\n * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n *   negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be \"binary string\"\n *    (each char code [0..255])\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , data = Uint8Array([1,2,3,4,5,6,7,8,9]);\n *\n * console.log(pako.deflate(data));\n * ```\n **/\nfunction deflate(input, options) {\n  var deflator = new Deflate(options);\n\n  deflator.push(input, true);\n\n  // That will never happens, if you don't cheat with options :)\n  if (deflator.err) { throw deflator.msg || msg[deflator.err]; }\n\n  return deflator.result;\n}\n\n\n/**\n * deflateRaw(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * The same as [[deflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n **/\nfunction deflateRaw(input, options) {\n  options = options || {};\n  options.raw = true;\n  return deflate(input, options);\n}\n\n\n/**\n * gzip(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * The same as [[deflate]], but create gzip wrapper instead of\n * deflate one.\n **/\nfunction gzip(input, options) {\n  options = options || {};\n  options.gzip = true;\n  return deflate(input, options);\n}\n\n\nexports.Deflate = Deflate;\nexports.deflate = deflate;\nexports.deflateRaw = deflateRaw;\nexports.gzip = gzip;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nvar utils   = require('../utils/common');\nvar trees   = require('./trees');\nvar adler32 = require('./adler32');\nvar crc32   = require('./crc32');\nvar msg     = require('./messages');\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n/* Allowed flush values; see deflate() and inflate() below for details */\nvar Z_NO_FLUSH      = 0;\nvar Z_PARTIAL_FLUSH = 1;\n//var Z_SYNC_FLUSH    = 2;\nvar Z_FULL_FLUSH    = 3;\nvar Z_FINISH        = 4;\nvar Z_BLOCK         = 5;\n//var Z_TREES         = 6;\n\n\n/* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\nvar Z_OK            = 0;\nvar Z_STREAM_END    = 1;\n//var Z_NEED_DICT     = 2;\n//var Z_ERRNO         = -1;\nvar Z_STREAM_ERROR  = -2;\nvar Z_DATA_ERROR    = -3;\n//var Z_MEM_ERROR     = -4;\nvar Z_BUF_ERROR     = -5;\n//var Z_VERSION_ERROR = -6;\n\n\n/* compression levels */\n//var Z_NO_COMPRESSION      = 0;\n//var Z_BEST_SPEED          = 1;\n//var Z_BEST_COMPRESSION    = 9;\nvar Z_DEFAULT_COMPRESSION = -1;\n\n\nvar Z_FILTERED            = 1;\nvar Z_HUFFMAN_ONLY        = 2;\nvar Z_RLE                 = 3;\nvar Z_FIXED               = 4;\nvar Z_DEFAULT_STRATEGY    = 0;\n\n/* Possible values of the data_type field (though see inflate()) */\n//var Z_BINARY              = 0;\n//var Z_TEXT                = 1;\n//var Z_ASCII               = 1; // = Z_TEXT\nvar Z_UNKNOWN             = 2;\n\n\n/* The deflate compression method */\nvar Z_DEFLATED  = 8;\n\n/*============================================================================*/\n\n\nvar MAX_MEM_LEVEL = 9;\n/* Maximum value for memLevel in deflateInit2 */\nvar MAX_WBITS = 15;\n/* 32K LZ77 window */\nvar DEF_MEM_LEVEL = 8;\n\n\nvar LENGTH_CODES  = 29;\n/* number of length codes, not counting the special END_BLOCK code */\nvar LITERALS      = 256;\n/* number of literal bytes 0..255 */\nvar L_CODES       = LITERALS + 1 + LENGTH_CODES;\n/* number of Literal or Length codes, including the END_BLOCK code */\nvar D_CODES       = 30;\n/* number of distance codes */\nvar BL_CODES      = 19;\n/* number of codes used to transfer the bit lengths */\nvar HEAP_SIZE     = 2 * L_CODES + 1;\n/* maximum heap size */\nvar MAX_BITS  = 15;\n/* All codes must not exceed MAX_BITS bits */\n\nvar MIN_MATCH = 3;\nvar MAX_MATCH = 258;\nvar MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);\n\nvar PRESET_DICT = 0x20;\n\nvar INIT_STATE = 42;\nvar EXTRA_STATE = 69;\nvar NAME_STATE = 73;\nvar COMMENT_STATE = 91;\nvar HCRC_STATE = 103;\nvar BUSY_STATE = 113;\nvar FINISH_STATE = 666;\n\nvar BS_NEED_MORE      = 1; /* block not completed, need more input or more output */\nvar BS_BLOCK_DONE     = 2; /* block flush performed */\nvar BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */\nvar BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */\n\nvar OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n\nfunction err(strm, errorCode) {\n  strm.msg = msg[errorCode];\n  return errorCode;\n}\n\nfunction rank(f) {\n  return ((f) << 1) - ((f) > 4 ? 9 : 0);\n}\n\nfunction zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }\n\n\n/* =========================================================================\n * Flush as much pending output as possible. All deflate() output goes\n * through this function so some applications may wish to modify it\n * to avoid allocating a large strm->output buffer and copying into it.\n * (See also read_buf()).\n */\nfunction flush_pending(strm) {\n  var s = strm.state;\n\n  //_tr_flush_bits(s);\n  var len = s.pending;\n  if (len > strm.avail_out) {\n    len = strm.avail_out;\n  }\n  if (len === 0) { return; }\n\n  utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);\n  strm.next_out += len;\n  s.pending_out += len;\n  strm.total_out += len;\n  strm.avail_out -= len;\n  s.pending -= len;\n  if (s.pending === 0) {\n    s.pending_out = 0;\n  }\n}\n\n\nfunction flush_block_only(s, last) {\n  trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);\n  s.block_start = s.strstart;\n  flush_pending(s.strm);\n}\n\n\nfunction put_byte(s, b) {\n  s.pending_buf[s.pending++] = b;\n}\n\n\n/* =========================================================================\n * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n * IN assertion: the stream state is correct and there is enough room in\n * pending_buf.\n */\nfunction putShortMSB(s, b) {\n//  put_byte(s, (Byte)(b >> 8));\n//  put_byte(s, (Byte)(b & 0xff));\n  s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n  s.pending_buf[s.pending++] = b & 0xff;\n}\n\n\n/* ===========================================================================\n * Read a new buffer from the current input stream, update the adler32\n * and total number of bytes read.  All deflate() input goes through\n * this function so some applications may wish to modify it to avoid\n * allocating a large strm->input buffer and copying from it.\n * (See also flush_pending()).\n */\nfunction read_buf(strm, buf, start, size) {\n  var len = strm.avail_in;\n\n  if (len > size) { len = size; }\n  if (len === 0) { return 0; }\n\n  strm.avail_in -= len;\n\n  // zmemcpy(buf, strm->next_in, len);\n  utils.arraySet(buf, strm.input, strm.next_in, len, start);\n  if (strm.state.wrap === 1) {\n    strm.adler = adler32(strm.adler, buf, len, start);\n  }\n\n  else if (strm.state.wrap === 2) {\n    strm.adler = crc32(strm.adler, buf, len, start);\n  }\n\n  strm.next_in += len;\n  strm.total_in += len;\n\n  return len;\n}\n\n\n/* ===========================================================================\n * Set match_start to the longest match starting at the given string and\n * return its length. Matches shorter or equal to prev_length are discarded,\n * in which case the result is equal to prev_length and match_start is\n * garbage.\n * IN assertions: cur_match is the head of the hash chain for the current\n *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n * OUT assertion: the match length is not greater than s->lookahead.\n */\nfunction longest_match(s, cur_match) {\n  var chain_length = s.max_chain_length;      /* max hash chain length */\n  var scan = s.strstart; /* current string */\n  var match;                       /* matched string */\n  var len;                           /* length of current match */\n  var best_len = s.prev_length;              /* best match length so far */\n  var nice_match = s.nice_match;             /* stop if match long enough */\n  var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?\n      s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/;\n\n  var _win = s.window; // shortcut\n\n  var wmask = s.w_mask;\n  var prev  = s.prev;\n\n  /* Stop when cur_match becomes <= limit. To simplify the code,\n   * we prevent matches with the string of window index 0.\n   */\n\n  var strend = s.strstart + MAX_MATCH;\n  var scan_end1  = _win[scan + best_len - 1];\n  var scan_end   = _win[scan + best_len];\n\n  /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n   * It is easy to get rid of this optimization if necessary.\n   */\n  // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n\n  /* Do not waste too much time if we already have a good match: */\n  if (s.prev_length >= s.good_match) {\n    chain_length >>= 2;\n  }\n  /* Do not look for matches beyond the end of the input. This is necessary\n   * to make deflate deterministic.\n   */\n  if (nice_match > s.lookahead) { nice_match = s.lookahead; }\n\n  // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n\n  do {\n    // Assert(cur_match < s->strstart, \"no future\");\n    match = cur_match;\n\n    /* Skip to next match if the match length cannot increase\n     * or if the match length is less than 2.  Note that the checks below\n     * for insufficient lookahead only occur occasionally for performance\n     * reasons.  Therefore uninitialized memory will be accessed, and\n     * conditional jumps will be made that depend on those values.\n     * However the length of the match is limited to the lookahead, so\n     * the output of deflate is not affected by the uninitialized values.\n     */\n\n    if (_win[match + best_len]     !== scan_end  ||\n        _win[match + best_len - 1] !== scan_end1 ||\n        _win[match]                !== _win[scan] ||\n        _win[++match]              !== _win[scan + 1]) {\n      continue;\n    }\n\n    /* The check at best_len-1 can be removed because it will be made\n     * again later. (This heuristic is not always a win.)\n     * It is not necessary to compare scan[2] and match[2] since they\n     * are always equal when the other bytes match, given that\n     * the hash keys are equal and that HASH_BITS >= 8.\n     */\n    scan += 2;\n    match++;\n    // Assert(*scan == *match, \"match[2]?\");\n\n    /* We check for insufficient lookahead only every 8th comparison;\n     * the 256th check will be made at strstart+258.\n     */\n    do {\n      /*jshint noempty:false*/\n    } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             _win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&\n             scan < strend);\n\n    // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n\n    len = MAX_MATCH - (strend - scan);\n    scan = strend - MAX_MATCH;\n\n    if (len > best_len) {\n      s.match_start = cur_match;\n      best_len = len;\n      if (len >= nice_match) {\n        break;\n      }\n      scan_end1  = _win[scan + best_len - 1];\n      scan_end   = _win[scan + best_len];\n    }\n  } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n\n  if (best_len <= s.lookahead) {\n    return best_len;\n  }\n  return s.lookahead;\n}\n\n\n/* ===========================================================================\n * Fill the window when the lookahead becomes insufficient.\n * Updates strstart and lookahead.\n *\n * IN assertion: lookahead < MIN_LOOKAHEAD\n * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n *    At least one byte has been read, or avail_in == 0; reads are\n *    performed for at least two bytes (required for the zip translate_eol\n *    option -- not supported here).\n */\nfunction fill_window(s) {\n  var _w_size = s.w_size;\n  var p, n, m, more, str;\n\n  //Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n\n  do {\n    more = s.window_size - s.lookahead - s.strstart;\n\n    // JS ints have 32 bit, block below not needed\n    /* Deal with !@#$% 64K limit: */\n    //if (sizeof(int) <= 2) {\n    //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n    //        more = wsize;\n    //\n    //  } else if (more == (unsigned)(-1)) {\n    //        /* Very unlikely, but possible on 16 bit machine if\n    //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n    //         */\n    //        more--;\n    //    }\n    //}\n\n\n    /* If the window is almost full and there is insufficient lookahead,\n     * move the upper half to the lower one to make room in the upper half.\n     */\n    if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n\n      utils.arraySet(s.window, s.window, _w_size, _w_size, 0);\n      s.match_start -= _w_size;\n      s.strstart -= _w_size;\n      /* we now have strstart >= MAX_DIST */\n      s.block_start -= _w_size;\n\n      /* Slide the hash table (could be avoided with 32 bit values\n       at the expense of memory usage). We slide even when level == 0\n       to keep the hash table consistent if we switch back to level > 0\n       later. (Using level 0 permanently is not an optimal usage of\n       zlib, so we don't care about this pathological case.)\n       */\n\n      n = s.hash_size;\n      p = n;\n      do {\n        m = s.head[--p];\n        s.head[p] = (m >= _w_size ? m - _w_size : 0);\n      } while (--n);\n\n      n = _w_size;\n      p = n;\n      do {\n        m = s.prev[--p];\n        s.prev[p] = (m >= _w_size ? m - _w_size : 0);\n        /* If n is not on any hash chain, prev[n] is garbage but\n         * its value will never be used.\n         */\n      } while (--n);\n\n      more += _w_size;\n    }\n    if (s.strm.avail_in === 0) {\n      break;\n    }\n\n    /* If there was no sliding:\n     *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n     *    more == window_size - lookahead - strstart\n     * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n     * => more >= window_size - 2*WSIZE + 2\n     * In the BIG_MEM or MMAP case (not yet supported),\n     *   window_size == input_size + MIN_LOOKAHEAD  &&\n     *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n     * Otherwise, window_size == 2*WSIZE so more >= 2.\n     * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n     */\n    //Assert(more >= 2, \"more < 2\");\n    n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n    s.lookahead += n;\n\n    /* Initialize the hash value now that we have some input: */\n    if (s.lookahead + s.insert >= MIN_MATCH) {\n      str = s.strstart - s.insert;\n      s.ins_h = s.window[str];\n\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask;\n//#if MIN_MATCH != 3\n//        Call update_hash() MIN_MATCH-3 more times\n//#endif\n      while (s.insert) {\n        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n        s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n\n        s.prev[str & s.w_mask] = s.head[s.ins_h];\n        s.head[s.ins_h] = str;\n        str++;\n        s.insert--;\n        if (s.lookahead + s.insert < MIN_MATCH) {\n          break;\n        }\n      }\n    }\n    /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n     * but this is not important since only literal bytes will be emitted.\n     */\n\n  } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n\n  /* If the WIN_INIT bytes after the end of the current data have never been\n   * written, then zero those bytes in order to avoid memory check reports of\n   * the use of uninitialized (or uninitialised as Julian writes) bytes by\n   * the longest match routines.  Update the high water mark for the next\n   * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n   * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n   */\n//  if (s.high_water < s.window_size) {\n//    var curr = s.strstart + s.lookahead;\n//    var init = 0;\n//\n//    if (s.high_water < curr) {\n//      /* Previous high water mark below current data -- zero WIN_INIT\n//       * bytes or up to end of window, whichever is less.\n//       */\n//      init = s.window_size - curr;\n//      if (init > WIN_INIT)\n//        init = WIN_INIT;\n//      zmemzero(s->window + curr, (unsigned)init);\n//      s->high_water = curr + init;\n//    }\n//    else if (s->high_water < (ulg)curr + WIN_INIT) {\n//      /* High water mark at or above current data, but below current data\n//       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n//       * to end of window, whichever is less.\n//       */\n//      init = (ulg)curr + WIN_INIT - s->high_water;\n//      if (init > s->window_size - s->high_water)\n//        init = s->window_size - s->high_water;\n//      zmemzero(s->window + s->high_water, (unsigned)init);\n//      s->high_water += init;\n//    }\n//  }\n//\n//  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n//    \"not enough room for search\");\n}\n\n/* ===========================================================================\n * Copy without compression as much as possible from the input stream, return\n * the current block state.\n * This function does not insert new strings in the dictionary since\n * uncompressible data is probably not useful. This function is used\n * only for the level=0 compression option.\n * NOTE: this function should be optimized to avoid extra copying from\n * window to pending_buf.\n */\nfunction deflate_stored(s, flush) {\n  /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n   * to pending_buf_size, and each stored block has a 5 byte header:\n   */\n  var max_block_size = 0xffff;\n\n  if (max_block_size > s.pending_buf_size - 5) {\n    max_block_size = s.pending_buf_size - 5;\n  }\n\n  /* Copy as much as possible from input to output: */\n  for (;;) {\n    /* Fill the window as much as possible: */\n    if (s.lookahead <= 1) {\n\n      //Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n      //  s->block_start >= (long)s->w_size, \"slide too late\");\n//      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n//        s.block_start >= s.w_size)) {\n//        throw  new Error(\"slide too late\");\n//      }\n\n      fill_window(s);\n      if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n\n      if (s.lookahead === 0) {\n        break;\n      }\n      /* flush the current block */\n    }\n    //Assert(s->block_start >= 0L, \"block gone\");\n//    if (s.block_start < 0) throw new Error(\"block gone\");\n\n    s.strstart += s.lookahead;\n    s.lookahead = 0;\n\n    /* Emit a stored block if pending_buf will be full: */\n    var max_start = s.block_start + max_block_size;\n\n    if (s.strstart === 0 || s.strstart >= max_start) {\n      /* strstart == 0 is possible when wraparound on 16-bit machine */\n      s.lookahead = s.strstart - max_start;\n      s.strstart = max_start;\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n\n\n    }\n    /* Flush if we may have to slide, otherwise block_start may become\n     * negative and the data will be gone:\n     */\n    if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n\n  s.insert = 0;\n\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n\n  if (s.strstart > s.block_start) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n\n  return BS_NEED_MORE;\n}\n\n/* ===========================================================================\n * Compress as much as possible from the input stream, return the current\n * block state.\n * This function does not perform lazy evaluation of matches and inserts\n * new strings in the dictionary only for unmatched strings or for short\n * matches. It is used only for the fast compression options.\n */\nfunction deflate_fast(s, flush) {\n  var hash_head;        /* head of the hash chain */\n  var bflush;           /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) {\n        break; /* flush the current block */\n      }\n    }\n\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n    hash_head = 0/*NIL*/;\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n\n    /* Find the longest match, discarding those <= prev_length.\n     * At this point we have always match_length < MIN_MATCH\n     */\n    if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n    }\n    if (s.match_length >= MIN_MATCH) {\n      // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n\n      /*** _tr_tally_dist(s, s.strstart - s.match_start,\n                     s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);\n\n      s.lookahead -= s.match_length;\n\n      /* Insert new strings in the hash table only if the match length\n       * is not too large. This saves time but degrades compression.\n       */\n      if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) {\n        s.match_length--; /* string at strstart already in table */\n        do {\n          s.strstart++;\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n          s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n          /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n           * always MIN_MATCH bytes ahead.\n           */\n        } while (--s.match_length !== 0);\n        s.strstart++;\n      } else\n      {\n        s.strstart += s.match_length;\n        s.match_length = 0;\n        s.ins_h = s.window[s.strstart];\n        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n        s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask;\n\n//#if MIN_MATCH != 3\n//                Call UPDATE_HASH() MIN_MATCH-3 more times\n//#endif\n        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n         * matter since it will be recomputed at next deflate call.\n         */\n      }\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s.window[s.strstart]));\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n\n      s.lookahead--;\n      s.strstart++;\n    }\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* ===========================================================================\n * Same as above, but achieves better compression. We use a lazy\n * evaluation for matches: a match is finally adopted only if there is\n * no better match at the next window position.\n */\nfunction deflate_slow(s, flush) {\n  var hash_head;          /* head of hash chain */\n  var bflush;              /* set if current block must be flushed */\n\n  var max_insert;\n\n  /* Process the input block. */\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the next match, plus MIN_MATCH bytes to insert the\n     * string following the next match.\n     */\n    if (s.lookahead < MIN_LOOKAHEAD) {\n      fill_window(s);\n      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) { break; } /* flush the current block */\n    }\n\n    /* Insert the string window[strstart .. strstart+2] in the\n     * dictionary, and set hash_head to the head of the hash chain:\n     */\n    hash_head = 0/*NIL*/;\n    if (s.lookahead >= MIN_MATCH) {\n      /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n      s.head[s.ins_h] = s.strstart;\n      /***/\n    }\n\n    /* Find the longest match, discarding those <= prev_length.\n     */\n    s.prev_length = s.match_length;\n    s.prev_match = s.match_start;\n    s.match_length = MIN_MATCH - 1;\n\n    if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match &&\n        s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) {\n      /* To simplify the code, we prevent matches with the string\n       * of window index 0 (in particular we have to avoid a match\n       * of the string with itself at the start of the input file).\n       */\n      s.match_length = longest_match(s, hash_head);\n      /* longest_match() sets match_start */\n\n      if (s.match_length <= 5 &&\n         (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) {\n\n        /* If prev_match is also MIN_MATCH, match_start is garbage\n         * but we will ignore the current match anyway.\n         */\n        s.match_length = MIN_MATCH - 1;\n      }\n    }\n    /* If there was a match at the previous step and the current\n     * match is not better, output the previous match:\n     */\n    if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {\n      max_insert = s.strstart + s.lookahead - MIN_MATCH;\n      /* Do not insert strings in hash table beyond this. */\n\n      //check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n\n      /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                     s.prev_length - MIN_MATCH, bflush);***/\n      bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);\n      /* Insert in hash table all strings up to the end of the match.\n       * strstart-1 and strstart are already inserted. If there is not\n       * enough lookahead, the last two strings are not inserted in\n       * the hash table.\n       */\n      s.lookahead -= s.prev_length - 1;\n      s.prev_length -= 2;\n      do {\n        if (++s.strstart <= max_insert) {\n          /*** INSERT_STRING(s, s.strstart, hash_head); ***/\n          s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;\n          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n          s.head[s.ins_h] = s.strstart;\n          /***/\n        }\n      } while (--s.prev_length !== 0);\n      s.match_available = 0;\n      s.match_length = MIN_MATCH - 1;\n      s.strstart++;\n\n      if (bflush) {\n        /*** FLUSH_BLOCK(s, 0); ***/\n        flush_block_only(s, false);\n        if (s.strm.avail_out === 0) {\n          return BS_NEED_MORE;\n        }\n        /***/\n      }\n\n    } else if (s.match_available) {\n      /* If there was no match at the previous position, output a\n       * single literal. If there was a match but the current match\n       * is longer, truncate the previous match to a single literal.\n       */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n      /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n\n      if (bflush) {\n        /*** FLUSH_BLOCK_ONLY(s, 0) ***/\n        flush_block_only(s, false);\n        /***/\n      }\n      s.strstart++;\n      s.lookahead--;\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n    } else {\n      /* There is no previous match to compare with, wait for\n       * the next step to decide.\n       */\n      s.match_available = 1;\n      s.strstart++;\n      s.lookahead--;\n    }\n  }\n  //Assert (flush != Z_NO_FLUSH, \"no flush?\");\n  if (s.match_available) {\n    //Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n    /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);\n\n    s.match_available = 0;\n  }\n  s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n\n  return BS_BLOCK_DONE;\n}\n\n\n/* ===========================================================================\n * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n * deflate switches away from Z_RLE.)\n */\nfunction deflate_rle(s, flush) {\n  var bflush;            /* set if current block must be flushed */\n  var prev;              /* byte at distance one to match */\n  var scan, strend;      /* scan goes up to strend for length of run */\n\n  var _win = s.window;\n\n  for (;;) {\n    /* Make sure that we always have enough lookahead, except\n     * at the end of the input file. We need MAX_MATCH bytes\n     * for the longest run, plus one for the unrolled loop.\n     */\n    if (s.lookahead <= MAX_MATCH) {\n      fill_window(s);\n      if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {\n        return BS_NEED_MORE;\n      }\n      if (s.lookahead === 0) { break; } /* flush the current block */\n    }\n\n    /* See how many times the previous byte repeats */\n    s.match_length = 0;\n    if (s.lookahead >= MIN_MATCH && s.strstart > 0) {\n      scan = s.strstart - 1;\n      prev = _win[scan];\n      if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n        strend = s.strstart + MAX_MATCH;\n        do {\n          /*jshint noempty:false*/\n        } while (prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 prev === _win[++scan] && prev === _win[++scan] &&\n                 scan < strend);\n        s.match_length = MAX_MATCH - (strend - scan);\n        if (s.match_length > s.lookahead) {\n          s.match_length = s.lookahead;\n        }\n      }\n      //Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n    }\n\n    /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n    if (s.match_length >= MIN_MATCH) {\n      //check_match(s, s.strstart, s.strstart - 1, s.match_length);\n\n      /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/\n      bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);\n\n      s.lookahead -= s.match_length;\n      s.strstart += s.match_length;\n      s.match_length = 0;\n    } else {\n      /* No match, output a literal byte */\n      //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n      /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n      bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n\n      s.lookahead--;\n      s.strstart++;\n    }\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = 0;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* ===========================================================================\n * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n * (It will be regenerated if this run of deflate switches away from Huffman.)\n */\nfunction deflate_huff(s, flush) {\n  var bflush;             /* set if current block must be flushed */\n\n  for (;;) {\n    /* Make sure that we have a literal to write. */\n    if (s.lookahead === 0) {\n      fill_window(s);\n      if (s.lookahead === 0) {\n        if (flush === Z_NO_FLUSH) {\n          return BS_NEED_MORE;\n        }\n        break;      /* flush the current block */\n      }\n    }\n\n    /* Output a literal byte */\n    s.match_length = 0;\n    //Tracevv((stderr,\"%c\", s->window[s->strstart]));\n    /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n    bflush = trees._tr_tally(s, 0, s.window[s.strstart]);\n    s.lookahead--;\n    s.strstart++;\n    if (bflush) {\n      /*** FLUSH_BLOCK(s, 0); ***/\n      flush_block_only(s, false);\n      if (s.strm.avail_out === 0) {\n        return BS_NEED_MORE;\n      }\n      /***/\n    }\n  }\n  s.insert = 0;\n  if (flush === Z_FINISH) {\n    /*** FLUSH_BLOCK(s, 1); ***/\n    flush_block_only(s, true);\n    if (s.strm.avail_out === 0) {\n      return BS_FINISH_STARTED;\n    }\n    /***/\n    return BS_FINISH_DONE;\n  }\n  if (s.last_lit) {\n    /*** FLUSH_BLOCK(s, 0); ***/\n    flush_block_only(s, false);\n    if (s.strm.avail_out === 0) {\n      return BS_NEED_MORE;\n    }\n    /***/\n  }\n  return BS_BLOCK_DONE;\n}\n\n/* Values for max_lazy_match, good_match and max_chain_length, depending on\n * the desired pack level (0..9). The values given below have been tuned to\n * exclude worst case performance for pathological files. Better values may be\n * found for specific files.\n */\nfunction Config(good_length, max_lazy, nice_length, max_chain, func) {\n  this.good_length = good_length;\n  this.max_lazy = max_lazy;\n  this.nice_length = nice_length;\n  this.max_chain = max_chain;\n  this.func = func;\n}\n\nvar configuration_table;\n\nconfiguration_table = [\n  /*      good lazy nice chain */\n  new Config(0, 0, 0, 0, deflate_stored),          /* 0 store only */\n  new Config(4, 4, 8, 4, deflate_fast),            /* 1 max speed, no lazy matches */\n  new Config(4, 5, 16, 8, deflate_fast),           /* 2 */\n  new Config(4, 6, 32, 32, deflate_fast),          /* 3 */\n\n  new Config(4, 4, 16, 16, deflate_slow),          /* 4 lazy matches */\n  new Config(8, 16, 32, 32, deflate_slow),         /* 5 */\n  new Config(8, 16, 128, 128, deflate_slow),       /* 6 */\n  new Config(8, 32, 128, 256, deflate_slow),       /* 7 */\n  new Config(32, 128, 258, 1024, deflate_slow),    /* 8 */\n  new Config(32, 258, 258, 4096, deflate_slow)     /* 9 max compression */\n];\n\n\n/* ===========================================================================\n * Initialize the \"longest match\" routines for a new zlib stream\n */\nfunction lm_init(s) {\n  s.window_size = 2 * s.w_size;\n\n  /*** CLEAR_HASH(s); ***/\n  zero(s.head); // Fill with NIL (= 0);\n\n  /* Set the default configuration parameters:\n   */\n  s.max_lazy_match = configuration_table[s.level].max_lazy;\n  s.good_match = configuration_table[s.level].good_length;\n  s.nice_match = configuration_table[s.level].nice_length;\n  s.max_chain_length = configuration_table[s.level].max_chain;\n\n  s.strstart = 0;\n  s.block_start = 0;\n  s.lookahead = 0;\n  s.insert = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  s.ins_h = 0;\n}\n\n\nfunction DeflateState() {\n  this.strm = null;            /* pointer back to this zlib stream */\n  this.status = 0;            /* as the name implies */\n  this.pending_buf = null;      /* output still pending */\n  this.pending_buf_size = 0;  /* size of pending_buf */\n  this.pending_out = 0;       /* next pending byte to output to the stream */\n  this.pending = 0;           /* nb of bytes in the pending buffer */\n  this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */\n  this.gzhead = null;         /* gzip header information to write */\n  this.gzindex = 0;           /* where in extra, name, or comment */\n  this.method = Z_DEFLATED; /* can only be DEFLATED */\n  this.last_flush = -1;   /* value of flush param for previous deflate call */\n\n  this.w_size = 0;  /* LZ77 window size (32K by default) */\n  this.w_bits = 0;  /* log2(w_size)  (8..16) */\n  this.w_mask = 0;  /* w_size - 1 */\n\n  this.window = null;\n  /* Sliding window. Input bytes are read into the second half of the window,\n   * and move to the first half later to keep a dictionary of at least wSize\n   * bytes. With this organization, matches are limited to a distance of\n   * wSize-MAX_MATCH bytes, but this ensures that IO is always\n   * performed with a length multiple of the block size.\n   */\n\n  this.window_size = 0;\n  /* Actual size of window: 2*wSize, except when the user input buffer\n   * is directly used as sliding window.\n   */\n\n  this.prev = null;\n  /* Link to older string with same hash index. To limit the size of this\n   * array to 64K, this link is maintained only for the last 32K strings.\n   * An index in this array is thus a window index modulo 32K.\n   */\n\n  this.head = null;   /* Heads of the hash chains or NIL. */\n\n  this.ins_h = 0;       /* hash index of string to be inserted */\n  this.hash_size = 0;   /* number of elements in hash table */\n  this.hash_bits = 0;   /* log2(hash_size) */\n  this.hash_mask = 0;   /* hash_size-1 */\n\n  this.hash_shift = 0;\n  /* Number of bits by which ins_h must be shifted at each input\n   * step. It must be such that after MIN_MATCH steps, the oldest\n   * byte no longer takes part in the hash key, that is:\n   *   hash_shift * MIN_MATCH >= hash_bits\n   */\n\n  this.block_start = 0;\n  /* Window position at the beginning of the current output block. Gets\n   * negative when the window is moved backwards.\n   */\n\n  this.match_length = 0;      /* length of best match */\n  this.prev_match = 0;        /* previous match */\n  this.match_available = 0;   /* set if previous match exists */\n  this.strstart = 0;          /* start of string to insert */\n  this.match_start = 0;       /* start of matching string */\n  this.lookahead = 0;         /* number of valid bytes ahead in window */\n\n  this.prev_length = 0;\n  /* Length of the best match at previous step. Matches not greater than this\n   * are discarded. This is used in the lazy match evaluation.\n   */\n\n  this.max_chain_length = 0;\n  /* To speed up deflation, hash chains are never searched beyond this\n   * length.  A higher limit improves compression ratio but degrades the\n   * speed.\n   */\n\n  this.max_lazy_match = 0;\n  /* Attempt to find a better match only when the current match is strictly\n   * smaller than this value. This mechanism is used only for compression\n   * levels >= 4.\n   */\n  // That's alias to max_lazy_match, don't use directly\n  //this.max_insert_length = 0;\n  /* Insert new strings in the hash table only if the match length is not\n   * greater than this length. This saves time but degrades compression.\n   * max_insert_length is used only for compression levels <= 3.\n   */\n\n  this.level = 0;     /* compression level (1..9) */\n  this.strategy = 0;  /* favor or force Huffman coding*/\n\n  this.good_match = 0;\n  /* Use a faster search when the previous match is longer than this */\n\n  this.nice_match = 0; /* Stop searching when current match exceeds this */\n\n              /* used by trees.c: */\n\n  /* Didn't use ct_data typedef below to suppress compiler warning */\n\n  // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n  // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n  // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n\n  // Use flat array of DOUBLE size, with interleaved fata,\n  // because JS does not support effective\n  this.dyn_ltree  = new utils.Buf16(HEAP_SIZE * 2);\n  this.dyn_dtree  = new utils.Buf16((2 * D_CODES + 1) * 2);\n  this.bl_tree    = new utils.Buf16((2 * BL_CODES + 1) * 2);\n  zero(this.dyn_ltree);\n  zero(this.dyn_dtree);\n  zero(this.bl_tree);\n\n  this.l_desc   = null;         /* desc. for literal tree */\n  this.d_desc   = null;         /* desc. for distance tree */\n  this.bl_desc  = null;         /* desc. for bit length tree */\n\n  //ush bl_count[MAX_BITS+1];\n  this.bl_count = new utils.Buf16(MAX_BITS + 1);\n  /* number of codes at each bit length for an optimal tree */\n\n  //int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n  this.heap = new utils.Buf16(2 * L_CODES + 1);  /* heap used to build the Huffman trees */\n  zero(this.heap);\n\n  this.heap_len = 0;               /* number of elements in the heap */\n  this.heap_max = 0;               /* element of largest frequency */\n  /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n   * The same heap array is used to build all trees.\n   */\n\n  this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1];\n  zero(this.depth);\n  /* Depth of each subtree used as tie breaker for trees of equal frequency\n   */\n\n  this.l_buf = 0;          /* buffer index for literals or lengths */\n\n  this.lit_bufsize = 0;\n  /* Size of match buffer for literals/lengths.  There are 4 reasons for\n   * limiting lit_bufsize to 64K:\n   *   - frequencies can be kept in 16 bit counters\n   *   - if compression is not successful for the first block, all input\n   *     data is still in the window so we can still emit a stored block even\n   *     when input comes from standard input.  (This can also be done for\n   *     all blocks if lit_bufsize is not greater than 32K.)\n   *   - if compression is not successful for a file smaller than 64K, we can\n   *     even emit a stored file instead of a stored block (saving 5 bytes).\n   *     This is applicable only for zip (not gzip or zlib).\n   *   - creating new Huffman trees less frequently may not provide fast\n   *     adaptation to changes in the input data statistics. (Take for\n   *     example a binary file with poorly compressible code followed by\n   *     a highly compressible string table.) Smaller buffer sizes give\n   *     fast adaptation but have of course the overhead of transmitting\n   *     trees more frequently.\n   *   - I can't count above 4\n   */\n\n  this.last_lit = 0;      /* running index in l_buf */\n\n  this.d_buf = 0;\n  /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n   * the same number of elements. To use different lengths, an extra flag\n   * array would be necessary.\n   */\n\n  this.opt_len = 0;       /* bit length of current block with optimal trees */\n  this.static_len = 0;    /* bit length of current block with static trees */\n  this.matches = 0;       /* number of string matches in current block */\n  this.insert = 0;        /* bytes at end of window left to insert */\n\n\n  this.bi_buf = 0;\n  /* Output buffer. bits are inserted starting at the bottom (least\n   * significant bits).\n   */\n  this.bi_valid = 0;\n  /* Number of valid bits in bi_buf.  All bits above the last valid bit\n   * are always zero.\n   */\n\n  // Used for window memory init. We safely ignore it for JS. That makes\n  // sense only for pointers and memory check tools.\n  //this.high_water = 0;\n  /* High water mark offset in window for initialized bytes -- bytes above\n   * this are set to zero in order to avoid memory check warnings when\n   * longest match routines access bytes past the input.  This is then\n   * updated to the new high water mark.\n   */\n}\n\n\nfunction deflateResetKeep(strm) {\n  var s;\n\n  if (!strm || !strm.state) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.total_in = strm.total_out = 0;\n  strm.data_type = Z_UNKNOWN;\n\n  s = strm.state;\n  s.pending = 0;\n  s.pending_out = 0;\n\n  if (s.wrap < 0) {\n    s.wrap = -s.wrap;\n    /* was made negative by deflate(..., Z_FINISH); */\n  }\n  s.status = (s.wrap ? INIT_STATE : BUSY_STATE);\n  strm.adler = (s.wrap === 2) ?\n    0  // crc32(0, Z_NULL, 0)\n  :\n    1; // adler32(0, Z_NULL, 0)\n  s.last_flush = Z_NO_FLUSH;\n  trees._tr_init(s);\n  return Z_OK;\n}\n\n\nfunction deflateReset(strm) {\n  var ret = deflateResetKeep(strm);\n  if (ret === Z_OK) {\n    lm_init(strm.state);\n  }\n  return ret;\n}\n\n\nfunction deflateSetHeader(strm, head) {\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }\n  strm.state.gzhead = head;\n  return Z_OK;\n}\n\n\nfunction deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n  if (!strm) { // === Z_NULL\n    return Z_STREAM_ERROR;\n  }\n  var wrap = 1;\n\n  if (level === Z_DEFAULT_COMPRESSION) {\n    level = 6;\n  }\n\n  if (windowBits < 0) { /* suppress zlib wrapper */\n    wrap = 0;\n    windowBits = -windowBits;\n  }\n\n  else if (windowBits > 15) {\n    wrap = 2;           /* write gzip wrapper instead */\n    windowBits -= 16;\n  }\n\n\n  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED ||\n    windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||\n    strategy < 0 || strategy > Z_FIXED) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n\n  if (windowBits === 8) {\n    windowBits = 9;\n  }\n  /* until 256-byte window bug fixed */\n\n  var s = new DeflateState();\n\n  strm.state = s;\n  s.strm = strm;\n\n  s.wrap = wrap;\n  s.gzhead = null;\n  s.w_bits = windowBits;\n  s.w_size = 1 << s.w_bits;\n  s.w_mask = s.w_size - 1;\n\n  s.hash_bits = memLevel + 7;\n  s.hash_size = 1 << s.hash_bits;\n  s.hash_mask = s.hash_size - 1;\n  s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);\n\n  s.window = new utils.Buf8(s.w_size * 2);\n  s.head = new utils.Buf16(s.hash_size);\n  s.prev = new utils.Buf16(s.w_size);\n\n  // Don't need mem init magic for JS.\n  //s.high_water = 0;  /* nothing written to s->window yet */\n\n  s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */\n\n  s.pending_buf_size = s.lit_bufsize * 4;\n\n  //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n  //s->pending_buf = (uchf *) overlay;\n  s.pending_buf = new utils.Buf8(s.pending_buf_size);\n\n  // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n  //s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n  s.d_buf = 1 * s.lit_bufsize;\n\n  //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n  s.l_buf = (1 + 2) * s.lit_bufsize;\n\n  s.level = level;\n  s.strategy = strategy;\n  s.method = method;\n\n  return deflateReset(strm);\n}\n\nfunction deflateInit(strm, level) {\n  return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n}\n\n\nfunction deflate(strm, flush) {\n  var old_flush, s;\n  var beg, val; // for gzip header write only\n\n  if (!strm || !strm.state ||\n    flush > Z_BLOCK || flush < 0) {\n    return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n\n  if (!strm.output ||\n      (!strm.input && strm.avail_in !== 0) ||\n      (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);\n  }\n\n  s.strm = strm; /* just in case */\n  old_flush = s.last_flush;\n  s.last_flush = flush;\n\n  /* Write the header */\n  if (s.status === INIT_STATE) {\n\n    if (s.wrap === 2) { // GZIP header\n      strm.adler = 0;  //crc32(0L, Z_NULL, 0);\n      put_byte(s, 31);\n      put_byte(s, 139);\n      put_byte(s, 8);\n      if (!s.gzhead) { // s->gzhead == Z_NULL\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, 0);\n        put_byte(s, s.level === 9 ? 2 :\n                    (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?\n                     4 : 0));\n        put_byte(s, OS_CODE);\n        s.status = BUSY_STATE;\n      }\n      else {\n        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                    (s.gzhead.hcrc ? 2 : 0) +\n                    (!s.gzhead.extra ? 0 : 4) +\n                    (!s.gzhead.name ? 0 : 8) +\n                    (!s.gzhead.comment ? 0 : 16)\n        );\n        put_byte(s, s.gzhead.time & 0xff);\n        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n        put_byte(s, s.level === 9 ? 2 :\n                    (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?\n                     4 : 0));\n        put_byte(s, s.gzhead.os & 0xff);\n        if (s.gzhead.extra && s.gzhead.extra.length) {\n          put_byte(s, s.gzhead.extra.length & 0xff);\n          put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n        }\n        if (s.gzhead.hcrc) {\n          strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);\n        }\n        s.gzindex = 0;\n        s.status = EXTRA_STATE;\n      }\n    }\n    else // DEFLATE header\n    {\n      var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n      var level_flags = -1;\n\n      if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n        level_flags = 0;\n      } else if (s.level < 6) {\n        level_flags = 1;\n      } else if (s.level === 6) {\n        level_flags = 2;\n      } else {\n        level_flags = 3;\n      }\n      header |= (level_flags << 6);\n      if (s.strstart !== 0) { header |= PRESET_DICT; }\n      header += 31 - (header % 31);\n\n      s.status = BUSY_STATE;\n      putShortMSB(s, header);\n\n      /* Save the adler32 of the preset dictionary: */\n      if (s.strstart !== 0) {\n        putShortMSB(s, strm.adler >>> 16);\n        putShortMSB(s, strm.adler & 0xffff);\n      }\n      strm.adler = 1; // adler32(0L, Z_NULL, 0);\n    }\n  }\n\n//#ifdef GZIP\n  if (s.status === EXTRA_STATE) {\n    if (s.gzhead.extra/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n\n      while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            break;\n          }\n        }\n        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n        s.gzindex++;\n      }\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (s.gzindex === s.gzhead.extra.length) {\n        s.gzindex = 0;\n        s.status = NAME_STATE;\n      }\n    }\n    else {\n      s.status = NAME_STATE;\n    }\n  }\n  if (s.status === NAME_STATE) {\n    if (s.gzhead.name/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        }\n        // JS specific: little magic to add zero terminator to end of string\n        if (s.gzindex < s.gzhead.name.length) {\n          val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (val === 0) {\n        s.gzindex = 0;\n        s.status = COMMENT_STATE;\n      }\n    }\n    else {\n      s.status = COMMENT_STATE;\n    }\n  }\n  if (s.status === COMMENT_STATE) {\n    if (s.gzhead.comment/* != Z_NULL*/) {\n      beg = s.pending;  /* start of bytes to update crc */\n      //int val;\n\n      do {\n        if (s.pending === s.pending_buf_size) {\n          if (s.gzhead.hcrc && s.pending > beg) {\n            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n          }\n          flush_pending(strm);\n          beg = s.pending;\n          if (s.pending === s.pending_buf_size) {\n            val = 1;\n            break;\n          }\n        }\n        // JS specific: little magic to add zero terminator to end of string\n        if (s.gzindex < s.gzhead.comment.length) {\n          val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n        } else {\n          val = 0;\n        }\n        put_byte(s, val);\n      } while (val !== 0);\n\n      if (s.gzhead.hcrc && s.pending > beg) {\n        strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n      }\n      if (val === 0) {\n        s.status = HCRC_STATE;\n      }\n    }\n    else {\n      s.status = HCRC_STATE;\n    }\n  }\n  if (s.status === HCRC_STATE) {\n    if (s.gzhead.hcrc) {\n      if (s.pending + 2 > s.pending_buf_size) {\n        flush_pending(strm);\n      }\n      if (s.pending + 2 <= s.pending_buf_size) {\n        put_byte(s, strm.adler & 0xff);\n        put_byte(s, (strm.adler >> 8) & 0xff);\n        strm.adler = 0; //crc32(0L, Z_NULL, 0);\n        s.status = BUSY_STATE;\n      }\n    }\n    else {\n      s.status = BUSY_STATE;\n    }\n  }\n//#endif\n\n  /* Flush as much pending output as possible */\n  if (s.pending !== 0) {\n    flush_pending(strm);\n    if (strm.avail_out === 0) {\n      /* Since avail_out is 0, deflate will be called again with\n       * more output space, but possibly with both pending and\n       * avail_in equal to zero. There won't be anything to do,\n       * but this is not an error situation so make sure we\n       * return OK instead of BUF_ERROR at next call of deflate:\n       */\n      s.last_flush = -1;\n      return Z_OK;\n    }\n\n    /* Make sure there is something to do and avoid duplicate consecutive\n     * flushes. For repeated and useless calls with Z_FINISH, we keep\n     * returning Z_STREAM_END instead of Z_BUF_ERROR.\n     */\n  } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&\n    flush !== Z_FINISH) {\n    return err(strm, Z_BUF_ERROR);\n  }\n\n  /* User must not provide more input after the first FINISH: */\n  if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n    return err(strm, Z_BUF_ERROR);\n  }\n\n  /* Start a new block or continue the current one.\n   */\n  if (strm.avail_in !== 0 || s.lookahead !== 0 ||\n    (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n    var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) :\n      (s.strategy === Z_RLE ? deflate_rle(s, flush) :\n        configuration_table[s.level].func(s, flush));\n\n    if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n      s.status = FINISH_STATE;\n    }\n    if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n      if (strm.avail_out === 0) {\n        s.last_flush = -1;\n        /* avoid BUF_ERROR next call, see above */\n      }\n      return Z_OK;\n      /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n       * of deflate should use the same flush parameter to make sure\n       * that the flush is complete. So we don't have to output an\n       * empty block here, this will be done at next call. This also\n       * ensures that for a very small output buffer, we emit at most\n       * one empty block.\n       */\n    }\n    if (bstate === BS_BLOCK_DONE) {\n      if (flush === Z_PARTIAL_FLUSH) {\n        trees._tr_align(s);\n      }\n      else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */\n\n        trees._tr_stored_block(s, 0, 0, false);\n        /* For a full flush, this empty block will be recognized\n         * as a special marker by inflate_sync().\n         */\n        if (flush === Z_FULL_FLUSH) {\n          /*** CLEAR_HASH(s); ***/             /* forget history */\n          zero(s.head); // Fill with NIL (= 0);\n\n          if (s.lookahead === 0) {\n            s.strstart = 0;\n            s.block_start = 0;\n            s.insert = 0;\n          }\n        }\n      }\n      flush_pending(strm);\n      if (strm.avail_out === 0) {\n        s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */\n        return Z_OK;\n      }\n    }\n  }\n  //Assert(strm->avail_out > 0, \"bug2\");\n  //if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n\n  if (flush !== Z_FINISH) { return Z_OK; }\n  if (s.wrap <= 0) { return Z_STREAM_END; }\n\n  /* Write the trailer */\n  if (s.wrap === 2) {\n    put_byte(s, strm.adler & 0xff);\n    put_byte(s, (strm.adler >> 8) & 0xff);\n    put_byte(s, (strm.adler >> 16) & 0xff);\n    put_byte(s, (strm.adler >> 24) & 0xff);\n    put_byte(s, strm.total_in & 0xff);\n    put_byte(s, (strm.total_in >> 8) & 0xff);\n    put_byte(s, (strm.total_in >> 16) & 0xff);\n    put_byte(s, (strm.total_in >> 24) & 0xff);\n  }\n  else\n  {\n    putShortMSB(s, strm.adler >>> 16);\n    putShortMSB(s, strm.adler & 0xffff);\n  }\n\n  flush_pending(strm);\n  /* If avail_out is zero, the application will call deflate again\n   * to flush the rest.\n   */\n  if (s.wrap > 0) { s.wrap = -s.wrap; }\n  /* write the trailer only once! */\n  return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n}\n\nfunction deflateEnd(strm) {\n  var status;\n\n  if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {\n    return Z_STREAM_ERROR;\n  }\n\n  status = strm.state.status;\n  if (status !== INIT_STATE &&\n    status !== EXTRA_STATE &&\n    status !== NAME_STATE &&\n    status !== COMMENT_STATE &&\n    status !== HCRC_STATE &&\n    status !== BUSY_STATE &&\n    status !== FINISH_STATE\n  ) {\n    return err(strm, Z_STREAM_ERROR);\n  }\n\n  strm.state = null;\n\n  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n}\n\n\n/* =========================================================================\n * Initializes the compression dictionary from the given byte\n * sequence without producing any compressed output.\n */\nfunction deflateSetDictionary(strm, dictionary) {\n  var dictLength = dictionary.length;\n\n  var s;\n  var str, n;\n  var wrap;\n  var avail;\n  var next;\n  var input;\n  var tmpDict;\n\n  if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {\n    return Z_STREAM_ERROR;\n  }\n\n  s = strm.state;\n  wrap = s.wrap;\n\n  if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n    return Z_STREAM_ERROR;\n  }\n\n  /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n  if (wrap === 1) {\n    /* adler32(strm->adler, dictionary, dictLength); */\n    strm.adler = adler32(strm.adler, dictionary, dictLength, 0);\n  }\n\n  s.wrap = 0;   /* avoid computing Adler-32 in read_buf */\n\n  /* if dictionary would fill window, just replace the history */\n  if (dictLength >= s.w_size) {\n    if (wrap === 0) {            /* already empty otherwise */\n      /*** CLEAR_HASH(s); ***/\n      zero(s.head); // Fill with NIL (= 0);\n      s.strstart = 0;\n      s.block_start = 0;\n      s.insert = 0;\n    }\n    /* use the tail */\n    // dictionary = dictionary.slice(dictLength - s.w_size);\n    tmpDict = new utils.Buf8(s.w_size);\n    utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);\n    dictionary = tmpDict;\n    dictLength = s.w_size;\n  }\n  /* insert dictionary into window and hash */\n  avail = strm.avail_in;\n  next = strm.next_in;\n  input = strm.input;\n  strm.avail_in = dictLength;\n  strm.next_in = 0;\n  strm.input = dictionary;\n  fill_window(s);\n  while (s.lookahead >= MIN_MATCH) {\n    str = s.strstart;\n    n = s.lookahead - (MIN_MATCH - 1);\n    do {\n      /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n      s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;\n\n      s.prev[str & s.w_mask] = s.head[s.ins_h];\n\n      s.head[s.ins_h] = str;\n      str++;\n    } while (--n);\n    s.strstart = str;\n    s.lookahead = MIN_MATCH - 1;\n    fill_window(s);\n  }\n  s.strstart += s.lookahead;\n  s.block_start = s.strstart;\n  s.insert = s.lookahead;\n  s.lookahead = 0;\n  s.match_length = s.prev_length = MIN_MATCH - 1;\n  s.match_available = 0;\n  strm.next_in = next;\n  strm.input = input;\n  strm.avail_in = avail;\n  s.wrap = wrap;\n  return Z_OK;\n}\n\n\nexports.deflateInit = deflateInit;\nexports.deflateInit2 = deflateInit2;\nexports.deflateReset = deflateReset;\nexports.deflateResetKeep = deflateResetKeep;\nexports.deflateSetHeader = deflateSetHeader;\nexports.deflate = deflate;\nexports.deflateEnd = deflateEnd;\nexports.deflateSetDictionary = deflateSetDictionary;\nexports.deflateInfo = 'pako deflate (from Nodeca project)';\n\n/* Not implemented\nexports.deflateBound = deflateBound;\nexports.deflateCopy = deflateCopy;\nexports.deflateParams = deflateParams;\nexports.deflatePending = deflatePending;\nexports.deflatePrime = deflatePrime;\nexports.deflateTune = deflateTune;\n*/\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction GZheader() {\n  /* true if compressed data believed to be text */\n  this.text       = 0;\n  /* modification time */\n  this.time       = 0;\n  /* extra flags (not used when writing a gzip file) */\n  this.xflags     = 0;\n  /* operating system */\n  this.os         = 0;\n  /* pointer to extra field or Z_NULL if none */\n  this.extra      = null;\n  /* extra field length (valid if extra != Z_NULL) */\n  this.extra_len  = 0; // Actually, we don't need it in JS,\n                       // but leave for few code modifications\n\n  //\n  // Setup limits is not necessary because in js we should not preallocate memory\n  // for inflate use constant limit in 65536 bytes\n  //\n\n  /* space at extra (only when reading header) */\n  // this.extra_max  = 0;\n  /* pointer to zero-terminated file name or Z_NULL */\n  this.name       = '';\n  /* space at name (only when reading header) */\n  // this.name_max   = 0;\n  /* pointer to zero-terminated comment or Z_NULL */\n  this.comment    = '';\n  /* space at comment (only when reading header) */\n  // this.comm_max   = 0;\n  /* true if there was or will be a header crc */\n  this.hcrc       = 0;\n  /* true when done reading gzip header (not used when writing a gzip file) */\n  this.done       = false;\n}\n\nmodule.exports = GZheader;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction ZStream() {\n  /* next input byte */\n  this.input = null; // JS specific, because we have no pointers\n  this.next_in = 0;\n  /* number of bytes available at input */\n  this.avail_in = 0;\n  /* total number of input bytes read so far */\n  this.total_in = 0;\n  /* next output byte should be put there */\n  this.output = null; // JS specific, because we have no pointers\n  this.next_out = 0;\n  /* remaining free space at output */\n  this.avail_out = 0;\n  /* total number of bytes output so far */\n  this.total_out = 0;\n  /* last error message, NULL if no error */\n  this.msg = ''/*Z_NULL*/;\n  /* not visible by applications */\n  this.state = null;\n  /* best guess about the data type: binary or text */\n  this.data_type = 2/*Z_UNKNOWN*/;\n  /* adler32 value of the uncompressed data */\n  this.adler = 0;\n}\n\nmodule.exports = ZStream;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nvar utils         = require('../utils/common');\nvar adler32       = require('./adler32');\nvar crc32         = require('./crc32');\nvar inflate_fast  = require('./inffast');\nvar inflate_table = require('./inftrees');\n\nvar CODES = 0;\nvar LENS = 1;\nvar DISTS = 2;\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n/* Allowed flush values; see deflate() and inflate() below for details */\n//var Z_NO_FLUSH      = 0;\n//var Z_PARTIAL_FLUSH = 1;\n//var Z_SYNC_FLUSH    = 2;\n//var Z_FULL_FLUSH    = 3;\nvar Z_FINISH        = 4;\nvar Z_BLOCK         = 5;\nvar Z_TREES         = 6;\n\n\n/* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\nvar Z_OK            = 0;\nvar Z_STREAM_END    = 1;\nvar Z_NEED_DICT     = 2;\n//var Z_ERRNO         = -1;\nvar Z_STREAM_ERROR  = -2;\nvar Z_DATA_ERROR    = -3;\nvar Z_MEM_ERROR     = -4;\nvar Z_BUF_ERROR     = -5;\n//var Z_VERSION_ERROR = -6;\n\n/* The deflate compression method */\nvar Z_DEFLATED  = 8;\n\n\n/* STATES ====================================================================*/\n/* ===========================================================================*/\n\n\nvar    HEAD = 1;       /* i: waiting for magic header */\nvar    FLAGS = 2;      /* i: waiting for method and flags (gzip) */\nvar    TIME = 3;       /* i: waiting for modification time (gzip) */\nvar    OS = 4;         /* i: waiting for extra flags and operating system (gzip) */\nvar    EXLEN = 5;      /* i: waiting for extra length (gzip) */\nvar    EXTRA = 6;      /* i: waiting for extra bytes (gzip) */\nvar    NAME = 7;       /* i: waiting for end of file name (gzip) */\nvar    COMMENT = 8;    /* i: waiting for end of comment (gzip) */\nvar    HCRC = 9;       /* i: waiting for header crc (gzip) */\nvar    DICTID = 10;    /* i: waiting for dictionary check value */\nvar    DICT = 11;      /* waiting for inflateSetDictionary() call */\nvar        TYPE = 12;      /* i: waiting for type bits, including last-flag bit */\nvar        TYPEDO = 13;    /* i: same, but skip check to exit inflate on new block */\nvar        STORED = 14;    /* i: waiting for stored size (length and complement) */\nvar        COPY_ = 15;     /* i/o: same as COPY below, but only first time in */\nvar        COPY = 16;      /* i/o: waiting for input or output to copy stored block */\nvar        TABLE = 17;     /* i: waiting for dynamic block table lengths */\nvar        LENLENS = 18;   /* i: waiting for code length code lengths */\nvar        CODELENS = 19;  /* i: waiting for length/lit and distance code lengths */\nvar            LEN_ = 20;      /* i: same as LEN below, but only first time in */\nvar            LEN = 21;       /* i: waiting for length/lit/eob code */\nvar            LENEXT = 22;    /* i: waiting for length extra bits */\nvar            DIST = 23;      /* i: waiting for distance code */\nvar            DISTEXT = 24;   /* i: waiting for distance extra bits */\nvar            MATCH = 25;     /* o: waiting for output space to copy string */\nvar            LIT = 26;       /* o: waiting for output space to write literal */\nvar    CHECK = 27;     /* i: waiting for 32-bit check value */\nvar    LENGTH = 28;    /* i: waiting for 32-bit length (gzip) */\nvar    DONE = 29;      /* finished check, done -- remain here until reset */\nvar    BAD = 30;       /* got a data error -- remain here until reset */\nvar    MEM = 31;       /* got an inflate() memory error -- remain here until reset */\nvar    SYNC = 32;      /* looking for synchronization bytes to restart inflate() */\n\n/* ===========================================================================*/\n\n\n\nvar ENOUGH_LENS = 852;\nvar ENOUGH_DISTS = 592;\n//var ENOUGH =  (ENOUGH_LENS+ENOUGH_DISTS);\n\nvar MAX_WBITS = 15;\n/* 32K LZ77 window */\nvar DEF_WBITS = MAX_WBITS;\n\n\nfunction zswap32(q) {\n  return  (((q >>> 24) & 0xff) +\n          ((q >>> 8) & 0xff00) +\n          ((q & 0xff00) << 8) +\n          ((q & 0xff) << 24));\n}\n\n\nfunction InflateState() {\n  this.mode = 0;             /* current inflate mode */\n  this.last = false;          /* true if processing last block */\n  this.wrap = 0;              /* bit 0 true for zlib, bit 1 true for gzip */\n  this.havedict = false;      /* true if dictionary provided */\n  this.flags = 0;             /* gzip header method and flags (0 if zlib) */\n  this.dmax = 0;              /* zlib header max distance (INFLATE_STRICT) */\n  this.check = 0;             /* protected copy of check value */\n  this.total = 0;             /* protected copy of output count */\n  // TODO: may be {}\n  this.head = null;           /* where to save gzip header information */\n\n  /* sliding window */\n  this.wbits = 0;             /* log base 2 of requested window size */\n  this.wsize = 0;             /* window size or zero if not using window */\n  this.whave = 0;             /* valid bytes in the window */\n  this.wnext = 0;             /* window write index */\n  this.window = null;         /* allocated sliding window, if needed */\n\n  /* bit accumulator */\n  this.hold = 0;              /* input bit accumulator */\n  this.bits = 0;              /* number of bits in \"in\" */\n\n  /* for string and stored block copying */\n  this.length = 0;            /* literal or length of data to copy */\n  this.offset = 0;            /* distance back to copy string from */\n\n  /* for table and code decoding */\n  this.extra = 0;             /* extra bits needed */\n\n  /* fixed and dynamic code tables */\n  this.lencode = null;          /* starting table for length/literal codes */\n  this.distcode = null;         /* starting table for distance codes */\n  this.lenbits = 0;           /* index bits for lencode */\n  this.distbits = 0;          /* index bits for distcode */\n\n  /* dynamic table building */\n  this.ncode = 0;             /* number of code length code lengths */\n  this.nlen = 0;              /* number of length code lengths */\n  this.ndist = 0;             /* number of distance code lengths */\n  this.have = 0;              /* number of code lengths in lens[] */\n  this.next = null;              /* next available space in codes[] */\n\n  this.lens = new utils.Buf16(320); /* temporary storage for code lengths */\n  this.work = new utils.Buf16(288); /* work area for code table building */\n\n  /*\n   because we don't have pointers in js, we use lencode and distcode directly\n   as buffers so we don't need codes\n  */\n  //this.codes = new utils.Buf32(ENOUGH);       /* space for code tables */\n  this.lendyn = null;              /* dynamic table for length/literal codes (JS specific) */\n  this.distdyn = null;             /* dynamic table for distance codes (JS specific) */\n  this.sane = 0;                   /* if false, allow invalid distance too far */\n  this.back = 0;                   /* bits back of last unprocessed length/lit */\n  this.was = 0;                    /* initial length of match */\n}\n\nfunction inflateResetKeep(strm) {\n  var state;\n\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  state = strm.state;\n  strm.total_in = strm.total_out = state.total = 0;\n  strm.msg = ''; /*Z_NULL*/\n  if (state.wrap) {       /* to support ill-conceived Java test suite */\n    strm.adler = state.wrap & 1;\n  }\n  state.mode = HEAD;\n  state.last = 0;\n  state.havedict = 0;\n  state.dmax = 32768;\n  state.head = null/*Z_NULL*/;\n  state.hold = 0;\n  state.bits = 0;\n  //state.lencode = state.distcode = state.next = state.codes;\n  state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);\n  state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);\n\n  state.sane = 1;\n  state.back = -1;\n  //Tracev((stderr, \"inflate: reset\\n\"));\n  return Z_OK;\n}\n\nfunction inflateReset(strm) {\n  var state;\n\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  state = strm.state;\n  state.wsize = 0;\n  state.whave = 0;\n  state.wnext = 0;\n  return inflateResetKeep(strm);\n\n}\n\nfunction inflateReset2(strm, windowBits) {\n  var wrap;\n  var state;\n\n  /* get the state */\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  state = strm.state;\n\n  /* extract wrap request from windowBits parameter */\n  if (windowBits < 0) {\n    wrap = 0;\n    windowBits = -windowBits;\n  }\n  else {\n    wrap = (windowBits >> 4) + 1;\n    if (windowBits < 48) {\n      windowBits &= 15;\n    }\n  }\n\n  /* set number of window bits, free window if different */\n  if (windowBits && (windowBits < 8 || windowBits > 15)) {\n    return Z_STREAM_ERROR;\n  }\n  if (state.window !== null && state.wbits !== windowBits) {\n    state.window = null;\n  }\n\n  /* update state and reset the rest of it */\n  state.wrap = wrap;\n  state.wbits = windowBits;\n  return inflateReset(strm);\n}\n\nfunction inflateInit2(strm, windowBits) {\n  var ret;\n  var state;\n\n  if (!strm) { return Z_STREAM_ERROR; }\n  //strm.msg = Z_NULL;                 /* in case we return an error */\n\n  state = new InflateState();\n\n  //if (state === Z_NULL) return Z_MEM_ERROR;\n  //Tracev((stderr, \"inflate: allocated\\n\"));\n  strm.state = state;\n  state.window = null/*Z_NULL*/;\n  ret = inflateReset2(strm, windowBits);\n  if (ret !== Z_OK) {\n    strm.state = null/*Z_NULL*/;\n  }\n  return ret;\n}\n\nfunction inflateInit(strm) {\n  return inflateInit2(strm, DEF_WBITS);\n}\n\n\n/*\n Return state with length and distance decoding tables and index sizes set to\n fixed code decoding.  Normally this returns fixed tables from inffixed.h.\n If BUILDFIXED is defined, then instead this routine builds the tables the\n first time it's called, and returns those tables the first time and\n thereafter.  This reduces the size of the code by about 2K bytes, in\n exchange for a little execution time.  However, BUILDFIXED should not be\n used for threaded applications, since the rewriting of the tables and virgin\n may not be thread-safe.\n */\nvar virgin = true;\n\nvar lenfix, distfix; // We have no pointers in JS, so keep tables separate\n\nfunction fixedtables(state) {\n  /* build fixed huffman tables if first call (may not be thread safe) */\n  if (virgin) {\n    var sym;\n\n    lenfix = new utils.Buf32(512);\n    distfix = new utils.Buf32(32);\n\n    /* literal/length table */\n    sym = 0;\n    while (sym < 144) { state.lens[sym++] = 8; }\n    while (sym < 256) { state.lens[sym++] = 9; }\n    while (sym < 280) { state.lens[sym++] = 7; }\n    while (sym < 288) { state.lens[sym++] = 8; }\n\n    inflate_table(LENS,  state.lens, 0, 288, lenfix,   0, state.work, { bits: 9 });\n\n    /* distance table */\n    sym = 0;\n    while (sym < 32) { state.lens[sym++] = 5; }\n\n    inflate_table(DISTS, state.lens, 0, 32,   distfix, 0, state.work, { bits: 5 });\n\n    /* do this just once */\n    virgin = false;\n  }\n\n  state.lencode = lenfix;\n  state.lenbits = 9;\n  state.distcode = distfix;\n  state.distbits = 5;\n}\n\n\n/*\n Update the window with the last wsize (normally 32K) bytes written before\n returning.  If window does not exist yet, create it.  This is only called\n when a window is already in use, or when output has been written during this\n inflate call, but the end of the deflate stream has not been reached yet.\n It is also called to create a window for dictionary data when a dictionary\n is loaded.\n\n Providing output buffers larger than 32K to inflate() should provide a speed\n advantage, since only the last 32K of output is copied to the sliding window\n upon return from inflate(), and since all distances after the first 32K of\n output will fall in the output data, making match copies simpler and faster.\n The advantage may be dependent on the size of the processor's data caches.\n */\nfunction updatewindow(strm, src, end, copy) {\n  var dist;\n  var state = strm.state;\n\n  /* if it hasn't been done already, allocate space for the window */\n  if (state.window === null) {\n    state.wsize = 1 << state.wbits;\n    state.wnext = 0;\n    state.whave = 0;\n\n    state.window = new utils.Buf8(state.wsize);\n  }\n\n  /* copy state->wsize or less output bytes into the circular window */\n  if (copy >= state.wsize) {\n    utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);\n    state.wnext = 0;\n    state.whave = state.wsize;\n  }\n  else {\n    dist = state.wsize - state.wnext;\n    if (dist > copy) {\n      dist = copy;\n    }\n    //zmemcpy(state->window + state->wnext, end - copy, dist);\n    utils.arraySet(state.window, src, end - copy, dist, state.wnext);\n    copy -= dist;\n    if (copy) {\n      //zmemcpy(state->window, end - copy, copy);\n      utils.arraySet(state.window, src, end - copy, copy, 0);\n      state.wnext = copy;\n      state.whave = state.wsize;\n    }\n    else {\n      state.wnext += dist;\n      if (state.wnext === state.wsize) { state.wnext = 0; }\n      if (state.whave < state.wsize) { state.whave += dist; }\n    }\n  }\n  return 0;\n}\n\nfunction inflate(strm, flush) {\n  var state;\n  var input, output;          // input/output buffers\n  var next;                   /* next input INDEX */\n  var put;                    /* next output INDEX */\n  var have, left;             /* available input and output */\n  var hold;                   /* bit buffer */\n  var bits;                   /* bits in bit buffer */\n  var _in, _out;              /* save starting available input and output */\n  var copy;                   /* number of stored or match bytes to copy */\n  var from;                   /* where to copy match bytes from */\n  var from_source;\n  var here = 0;               /* current decoding table entry */\n  var here_bits, here_op, here_val; // paked \"here\" denormalized (JS specific)\n  //var last;                   /* parent table entry */\n  var last_bits, last_op, last_val; // paked \"last\" denormalized (JS specific)\n  var len;                    /* length to copy for repeats, bits to drop */\n  var ret;                    /* return code */\n  var hbuf = new utils.Buf8(4);    /* buffer for gzip header crc calculation */\n  var opts;\n\n  var n; // temporary var for NEED_BITS\n\n  var order = /* permutation of code lengths */\n    [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];\n\n\n  if (!strm || !strm.state || !strm.output ||\n      (!strm.input && strm.avail_in !== 0)) {\n    return Z_STREAM_ERROR;\n  }\n\n  state = strm.state;\n  if (state.mode === TYPE) { state.mode = TYPEDO; }    /* skip check */\n\n\n  //--- LOAD() ---\n  put = strm.next_out;\n  output = strm.output;\n  left = strm.avail_out;\n  next = strm.next_in;\n  input = strm.input;\n  have = strm.avail_in;\n  hold = state.hold;\n  bits = state.bits;\n  //---\n\n  _in = have;\n  _out = left;\n  ret = Z_OK;\n\n  inf_leave: // goto emulation\n  for (;;) {\n    switch (state.mode) {\n      case HEAD:\n        if (state.wrap === 0) {\n          state.mode = TYPEDO;\n          break;\n        }\n        //=== NEEDBITS(16);\n        while (bits < 16) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        if ((state.wrap & 2) && hold === 0x8b1f) {  /* gzip header */\n          state.check = 0/*crc32(0L, Z_NULL, 0)*/;\n          //=== CRC2(state.check, hold);\n          hbuf[0] = hold & 0xff;\n          hbuf[1] = (hold >>> 8) & 0xff;\n          state.check = crc32(state.check, hbuf, 2, 0);\n          //===//\n\n          //=== INITBITS();\n          hold = 0;\n          bits = 0;\n          //===//\n          state.mode = FLAGS;\n          break;\n        }\n        state.flags = 0;           /* expect zlib header */\n        if (state.head) {\n          state.head.done = false;\n        }\n        if (!(state.wrap & 1) ||   /* check if zlib header allowed */\n          (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {\n          strm.msg = 'incorrect header check';\n          state.mode = BAD;\n          break;\n        }\n        if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {\n          strm.msg = 'unknown compression method';\n          state.mode = BAD;\n          break;\n        }\n        //--- DROPBITS(4) ---//\n        hold >>>= 4;\n        bits -= 4;\n        //---//\n        len = (hold & 0x0f)/*BITS(4)*/ + 8;\n        if (state.wbits === 0) {\n          state.wbits = len;\n        }\n        else if (len > state.wbits) {\n          strm.msg = 'invalid window size';\n          state.mode = BAD;\n          break;\n        }\n        state.dmax = 1 << len;\n        //Tracev((stderr, \"inflate:   zlib header ok\\n\"));\n        strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;\n        state.mode = hold & 0x200 ? DICTID : TYPE;\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        break;\n      case FLAGS:\n        //=== NEEDBITS(16); */\n        while (bits < 16) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        state.flags = hold;\n        if ((state.flags & 0xff) !== Z_DEFLATED) {\n          strm.msg = 'unknown compression method';\n          state.mode = BAD;\n          break;\n        }\n        if (state.flags & 0xe000) {\n          strm.msg = 'unknown header flags set';\n          state.mode = BAD;\n          break;\n        }\n        if (state.head) {\n          state.head.text = ((hold >> 8) & 1);\n        }\n        if (state.flags & 0x0200) {\n          //=== CRC2(state.check, hold);\n          hbuf[0] = hold & 0xff;\n          hbuf[1] = (hold >>> 8) & 0xff;\n          state.check = crc32(state.check, hbuf, 2, 0);\n          //===//\n        }\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        state.mode = TIME;\n        /* falls through */\n      case TIME:\n        //=== NEEDBITS(32); */\n        while (bits < 32) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        if (state.head) {\n          state.head.time = hold;\n        }\n        if (state.flags & 0x0200) {\n          //=== CRC4(state.check, hold)\n          hbuf[0] = hold & 0xff;\n          hbuf[1] = (hold >>> 8) & 0xff;\n          hbuf[2] = (hold >>> 16) & 0xff;\n          hbuf[3] = (hold >>> 24) & 0xff;\n          state.check = crc32(state.check, hbuf, 4, 0);\n          //===\n        }\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        state.mode = OS;\n        /* falls through */\n      case OS:\n        //=== NEEDBITS(16); */\n        while (bits < 16) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        if (state.head) {\n          state.head.xflags = (hold & 0xff);\n          state.head.os = (hold >> 8);\n        }\n        if (state.flags & 0x0200) {\n          //=== CRC2(state.check, hold);\n          hbuf[0] = hold & 0xff;\n          hbuf[1] = (hold >>> 8) & 0xff;\n          state.check = crc32(state.check, hbuf, 2, 0);\n          //===//\n        }\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        state.mode = EXLEN;\n        /* falls through */\n      case EXLEN:\n        if (state.flags & 0x0400) {\n          //=== NEEDBITS(16); */\n          while (bits < 16) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          state.length = hold;\n          if (state.head) {\n            state.head.extra_len = hold;\n          }\n          if (state.flags & 0x0200) {\n            //=== CRC2(state.check, hold);\n            hbuf[0] = hold & 0xff;\n            hbuf[1] = (hold >>> 8) & 0xff;\n            state.check = crc32(state.check, hbuf, 2, 0);\n            //===//\n          }\n          //=== INITBITS();\n          hold = 0;\n          bits = 0;\n          //===//\n        }\n        else if (state.head) {\n          state.head.extra = null/*Z_NULL*/;\n        }\n        state.mode = EXTRA;\n        /* falls through */\n      case EXTRA:\n        if (state.flags & 0x0400) {\n          copy = state.length;\n          if (copy > have) { copy = have; }\n          if (copy) {\n            if (state.head) {\n              len = state.head.extra_len - state.length;\n              if (!state.head.extra) {\n                // Use untyped array for more convenient processing later\n                state.head.extra = new Array(state.head.extra_len);\n              }\n              utils.arraySet(\n                state.head.extra,\n                input,\n                next,\n                // extra field is limited to 65536 bytes\n                // - no need for additional size check\n                copy,\n                /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/\n                len\n              );\n              //zmemcpy(state.head.extra + len, next,\n              //        len + copy > state.head.extra_max ?\n              //        state.head.extra_max - len : copy);\n            }\n            if (state.flags & 0x0200) {\n              state.check = crc32(state.check, input, copy, next);\n            }\n            have -= copy;\n            next += copy;\n            state.length -= copy;\n          }\n          if (state.length) { break inf_leave; }\n        }\n        state.length = 0;\n        state.mode = NAME;\n        /* falls through */\n      case NAME:\n        if (state.flags & 0x0800) {\n          if (have === 0) { break inf_leave; }\n          copy = 0;\n          do {\n            // TODO: 2 or 1 bytes?\n            len = input[next + copy++];\n            /* use constant limit because in js we should not preallocate memory */\n            if (state.head && len &&\n                (state.length < 65536 /*state.head.name_max*/)) {\n              state.head.name += String.fromCharCode(len);\n            }\n          } while (len && copy < have);\n\n          if (state.flags & 0x0200) {\n            state.check = crc32(state.check, input, copy, next);\n          }\n          have -= copy;\n          next += copy;\n          if (len) { break inf_leave; }\n        }\n        else if (state.head) {\n          state.head.name = null;\n        }\n        state.length = 0;\n        state.mode = COMMENT;\n        /* falls through */\n      case COMMENT:\n        if (state.flags & 0x1000) {\n          if (have === 0) { break inf_leave; }\n          copy = 0;\n          do {\n            len = input[next + copy++];\n            /* use constant limit because in js we should not preallocate memory */\n            if (state.head && len &&\n                (state.length < 65536 /*state.head.comm_max*/)) {\n              state.head.comment += String.fromCharCode(len);\n            }\n          } while (len && copy < have);\n          if (state.flags & 0x0200) {\n            state.check = crc32(state.check, input, copy, next);\n          }\n          have -= copy;\n          next += copy;\n          if (len) { break inf_leave; }\n        }\n        else if (state.head) {\n          state.head.comment = null;\n        }\n        state.mode = HCRC;\n        /* falls through */\n      case HCRC:\n        if (state.flags & 0x0200) {\n          //=== NEEDBITS(16); */\n          while (bits < 16) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          if (hold !== (state.check & 0xffff)) {\n            strm.msg = 'header crc mismatch';\n            state.mode = BAD;\n            break;\n          }\n          //=== INITBITS();\n          hold = 0;\n          bits = 0;\n          //===//\n        }\n        if (state.head) {\n          state.head.hcrc = ((state.flags >> 9) & 1);\n          state.head.done = true;\n        }\n        strm.adler = state.check = 0;\n        state.mode = TYPE;\n        break;\n      case DICTID:\n        //=== NEEDBITS(32); */\n        while (bits < 32) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        strm.adler = state.check = zswap32(hold);\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        state.mode = DICT;\n        /* falls through */\n      case DICT:\n        if (state.havedict === 0) {\n          //--- RESTORE() ---\n          strm.next_out = put;\n          strm.avail_out = left;\n          strm.next_in = next;\n          strm.avail_in = have;\n          state.hold = hold;\n          state.bits = bits;\n          //---\n          return Z_NEED_DICT;\n        }\n        strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;\n        state.mode = TYPE;\n        /* falls through */\n      case TYPE:\n        if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }\n        /* falls through */\n      case TYPEDO:\n        if (state.last) {\n          //--- BYTEBITS() ---//\n          hold >>>= bits & 7;\n          bits -= bits & 7;\n          //---//\n          state.mode = CHECK;\n          break;\n        }\n        //=== NEEDBITS(3); */\n        while (bits < 3) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        state.last = (hold & 0x01)/*BITS(1)*/;\n        //--- DROPBITS(1) ---//\n        hold >>>= 1;\n        bits -= 1;\n        //---//\n\n        switch ((hold & 0x03)/*BITS(2)*/) {\n          case 0:                             /* stored block */\n            //Tracev((stderr, \"inflate:     stored block%s\\n\",\n            //        state.last ? \" (last)\" : \"\"));\n            state.mode = STORED;\n            break;\n          case 1:                             /* fixed block */\n            fixedtables(state);\n            //Tracev((stderr, \"inflate:     fixed codes block%s\\n\",\n            //        state.last ? \" (last)\" : \"\"));\n            state.mode = LEN_;             /* decode codes */\n            if (flush === Z_TREES) {\n              //--- DROPBITS(2) ---//\n              hold >>>= 2;\n              bits -= 2;\n              //---//\n              break inf_leave;\n            }\n            break;\n          case 2:                             /* dynamic block */\n            //Tracev((stderr, \"inflate:     dynamic codes block%s\\n\",\n            //        state.last ? \" (last)\" : \"\"));\n            state.mode = TABLE;\n            break;\n          case 3:\n            strm.msg = 'invalid block type';\n            state.mode = BAD;\n        }\n        //--- DROPBITS(2) ---//\n        hold >>>= 2;\n        bits -= 2;\n        //---//\n        break;\n      case STORED:\n        //--- BYTEBITS() ---// /* go to byte boundary */\n        hold >>>= bits & 7;\n        bits -= bits & 7;\n        //---//\n        //=== NEEDBITS(32); */\n        while (bits < 32) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {\n          strm.msg = 'invalid stored block lengths';\n          state.mode = BAD;\n          break;\n        }\n        state.length = hold & 0xffff;\n        //Tracev((stderr, \"inflate:       stored length %u\\n\",\n        //        state.length));\n        //=== INITBITS();\n        hold = 0;\n        bits = 0;\n        //===//\n        state.mode = COPY_;\n        if (flush === Z_TREES) { break inf_leave; }\n        /* falls through */\n      case COPY_:\n        state.mode = COPY;\n        /* falls through */\n      case COPY:\n        copy = state.length;\n        if (copy) {\n          if (copy > have) { copy = have; }\n          if (copy > left) { copy = left; }\n          if (copy === 0) { break inf_leave; }\n          //--- zmemcpy(put, next, copy); ---\n          utils.arraySet(output, input, next, copy, put);\n          //---//\n          have -= copy;\n          next += copy;\n          left -= copy;\n          put += copy;\n          state.length -= copy;\n          break;\n        }\n        //Tracev((stderr, \"inflate:       stored end\\n\"));\n        state.mode = TYPE;\n        break;\n      case TABLE:\n        //=== NEEDBITS(14); */\n        while (bits < 14) {\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n        }\n        //===//\n        state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;\n        //--- DROPBITS(5) ---//\n        hold >>>= 5;\n        bits -= 5;\n        //---//\n        state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;\n        //--- DROPBITS(5) ---//\n        hold >>>= 5;\n        bits -= 5;\n        //---//\n        state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;\n        //--- DROPBITS(4) ---//\n        hold >>>= 4;\n        bits -= 4;\n        //---//\n//#ifndef PKZIP_BUG_WORKAROUND\n        if (state.nlen > 286 || state.ndist > 30) {\n          strm.msg = 'too many length or distance symbols';\n          state.mode = BAD;\n          break;\n        }\n//#endif\n        //Tracev((stderr, \"inflate:       table sizes ok\\n\"));\n        state.have = 0;\n        state.mode = LENLENS;\n        /* falls through */\n      case LENLENS:\n        while (state.have < state.ncode) {\n          //=== NEEDBITS(3);\n          while (bits < 3) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);\n          //--- DROPBITS(3) ---//\n          hold >>>= 3;\n          bits -= 3;\n          //---//\n        }\n        while (state.have < 19) {\n          state.lens[order[state.have++]] = 0;\n        }\n        // We have separate tables & no pointers. 2 commented lines below not needed.\n        //state.next = state.codes;\n        //state.lencode = state.next;\n        // Switch to use dynamic table\n        state.lencode = state.lendyn;\n        state.lenbits = 7;\n\n        opts = { bits: state.lenbits };\n        ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);\n        state.lenbits = opts.bits;\n\n        if (ret) {\n          strm.msg = 'invalid code lengths set';\n          state.mode = BAD;\n          break;\n        }\n        //Tracev((stderr, \"inflate:       code lengths ok\\n\"));\n        state.have = 0;\n        state.mode = CODELENS;\n        /* falls through */\n      case CODELENS:\n        while (state.have < state.nlen + state.ndist) {\n          for (;;) {\n            here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/\n            here_bits = here >>> 24;\n            here_op = (here >>> 16) & 0xff;\n            here_val = here & 0xffff;\n\n            if ((here_bits) <= bits) { break; }\n            //--- PULLBYTE() ---//\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n            //---//\n          }\n          if (here_val < 16) {\n            //--- DROPBITS(here.bits) ---//\n            hold >>>= here_bits;\n            bits -= here_bits;\n            //---//\n            state.lens[state.have++] = here_val;\n          }\n          else {\n            if (here_val === 16) {\n              //=== NEEDBITS(here.bits + 2);\n              n = here_bits + 2;\n              while (bits < n) {\n                if (have === 0) { break inf_leave; }\n                have--;\n                hold += input[next++] << bits;\n                bits += 8;\n              }\n              //===//\n              //--- DROPBITS(here.bits) ---//\n              hold >>>= here_bits;\n              bits -= here_bits;\n              //---//\n              if (state.have === 0) {\n                strm.msg = 'invalid bit length repeat';\n                state.mode = BAD;\n                break;\n              }\n              len = state.lens[state.have - 1];\n              copy = 3 + (hold & 0x03);//BITS(2);\n              //--- DROPBITS(2) ---//\n              hold >>>= 2;\n              bits -= 2;\n              //---//\n            }\n            else if (here_val === 17) {\n              //=== NEEDBITS(here.bits + 3);\n              n = here_bits + 3;\n              while (bits < n) {\n                if (have === 0) { break inf_leave; }\n                have--;\n                hold += input[next++] << bits;\n                bits += 8;\n              }\n              //===//\n              //--- DROPBITS(here.bits) ---//\n              hold >>>= here_bits;\n              bits -= here_bits;\n              //---//\n              len = 0;\n              copy = 3 + (hold & 0x07);//BITS(3);\n              //--- DROPBITS(3) ---//\n              hold >>>= 3;\n              bits -= 3;\n              //---//\n            }\n            else {\n              //=== NEEDBITS(here.bits + 7);\n              n = here_bits + 7;\n              while (bits < n) {\n                if (have === 0) { break inf_leave; }\n                have--;\n                hold += input[next++] << bits;\n                bits += 8;\n              }\n              //===//\n              //--- DROPBITS(here.bits) ---//\n              hold >>>= here_bits;\n              bits -= here_bits;\n              //---//\n              len = 0;\n              copy = 11 + (hold & 0x7f);//BITS(7);\n              //--- DROPBITS(7) ---//\n              hold >>>= 7;\n              bits -= 7;\n              //---//\n            }\n            if (state.have + copy > state.nlen + state.ndist) {\n              strm.msg = 'invalid bit length repeat';\n              state.mode = BAD;\n              break;\n            }\n            while (copy--) {\n              state.lens[state.have++] = len;\n            }\n          }\n        }\n\n        /* handle error breaks in while */\n        if (state.mode === BAD) { break; }\n\n        /* check for end-of-block code (better have one) */\n        if (state.lens[256] === 0) {\n          strm.msg = 'invalid code -- missing end-of-block';\n          state.mode = BAD;\n          break;\n        }\n\n        /* build code tables -- note: do not change the lenbits or distbits\n           values here (9 and 6) without reading the comments in inftrees.h\n           concerning the ENOUGH constants, which depend on those values */\n        state.lenbits = 9;\n\n        opts = { bits: state.lenbits };\n        ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);\n        // We have separate tables & no pointers. 2 commented lines below not needed.\n        // state.next_index = opts.table_index;\n        state.lenbits = opts.bits;\n        // state.lencode = state.next;\n\n        if (ret) {\n          strm.msg = 'invalid literal/lengths set';\n          state.mode = BAD;\n          break;\n        }\n\n        state.distbits = 6;\n        //state.distcode.copy(state.codes);\n        // Switch to use dynamic table\n        state.distcode = state.distdyn;\n        opts = { bits: state.distbits };\n        ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);\n        // We have separate tables & no pointers. 2 commented lines below not needed.\n        // state.next_index = opts.table_index;\n        state.distbits = opts.bits;\n        // state.distcode = state.next;\n\n        if (ret) {\n          strm.msg = 'invalid distances set';\n          state.mode = BAD;\n          break;\n        }\n        //Tracev((stderr, 'inflate:       codes ok\\n'));\n        state.mode = LEN_;\n        if (flush === Z_TREES) { break inf_leave; }\n        /* falls through */\n      case LEN_:\n        state.mode = LEN;\n        /* falls through */\n      case LEN:\n        if (have >= 6 && left >= 258) {\n          //--- RESTORE() ---\n          strm.next_out = put;\n          strm.avail_out = left;\n          strm.next_in = next;\n          strm.avail_in = have;\n          state.hold = hold;\n          state.bits = bits;\n          //---\n          inflate_fast(strm, _out);\n          //--- LOAD() ---\n          put = strm.next_out;\n          output = strm.output;\n          left = strm.avail_out;\n          next = strm.next_in;\n          input = strm.input;\n          have = strm.avail_in;\n          hold = state.hold;\n          bits = state.bits;\n          //---\n\n          if (state.mode === TYPE) {\n            state.back = -1;\n          }\n          break;\n        }\n        state.back = 0;\n        for (;;) {\n          here = state.lencode[hold & ((1 << state.lenbits) - 1)];  /*BITS(state.lenbits)*/\n          here_bits = here >>> 24;\n          here_op = (here >>> 16) & 0xff;\n          here_val = here & 0xffff;\n\n          if (here_bits <= bits) { break; }\n          //--- PULLBYTE() ---//\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n          //---//\n        }\n        if (here_op && (here_op & 0xf0) === 0) {\n          last_bits = here_bits;\n          last_op = here_op;\n          last_val = here_val;\n          for (;;) {\n            here = state.lencode[last_val +\n                    ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];\n            here_bits = here >>> 24;\n            here_op = (here >>> 16) & 0xff;\n            here_val = here & 0xffff;\n\n            if ((last_bits + here_bits) <= bits) { break; }\n            //--- PULLBYTE() ---//\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n            //---//\n          }\n          //--- DROPBITS(last.bits) ---//\n          hold >>>= last_bits;\n          bits -= last_bits;\n          //---//\n          state.back += last_bits;\n        }\n        //--- DROPBITS(here.bits) ---//\n        hold >>>= here_bits;\n        bits -= here_bits;\n        //---//\n        state.back += here_bits;\n        state.length = here_val;\n        if (here_op === 0) {\n          //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n          //        \"inflate:         literal '%c'\\n\" :\n          //        \"inflate:         literal 0x%02x\\n\", here.val));\n          state.mode = LIT;\n          break;\n        }\n        if (here_op & 32) {\n          //Tracevv((stderr, \"inflate:         end of block\\n\"));\n          state.back = -1;\n          state.mode = TYPE;\n          break;\n        }\n        if (here_op & 64) {\n          strm.msg = 'invalid literal/length code';\n          state.mode = BAD;\n          break;\n        }\n        state.extra = here_op & 15;\n        state.mode = LENEXT;\n        /* falls through */\n      case LENEXT:\n        if (state.extra) {\n          //=== NEEDBITS(state.extra);\n          n = state.extra;\n          while (bits < n) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;\n          //--- DROPBITS(state.extra) ---//\n          hold >>>= state.extra;\n          bits -= state.extra;\n          //---//\n          state.back += state.extra;\n        }\n        //Tracevv((stderr, \"inflate:         length %u\\n\", state.length));\n        state.was = state.length;\n        state.mode = DIST;\n        /* falls through */\n      case DIST:\n        for (;;) {\n          here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/\n          here_bits = here >>> 24;\n          here_op = (here >>> 16) & 0xff;\n          here_val = here & 0xffff;\n\n          if ((here_bits) <= bits) { break; }\n          //--- PULLBYTE() ---//\n          if (have === 0) { break inf_leave; }\n          have--;\n          hold += input[next++] << bits;\n          bits += 8;\n          //---//\n        }\n        if ((here_op & 0xf0) === 0) {\n          last_bits = here_bits;\n          last_op = here_op;\n          last_val = here_val;\n          for (;;) {\n            here = state.distcode[last_val +\n                    ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];\n            here_bits = here >>> 24;\n            here_op = (here >>> 16) & 0xff;\n            here_val = here & 0xffff;\n\n            if ((last_bits + here_bits) <= bits) { break; }\n            //--- PULLBYTE() ---//\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n            //---//\n          }\n          //--- DROPBITS(last.bits) ---//\n          hold >>>= last_bits;\n          bits -= last_bits;\n          //---//\n          state.back += last_bits;\n        }\n        //--- DROPBITS(here.bits) ---//\n        hold >>>= here_bits;\n        bits -= here_bits;\n        //---//\n        state.back += here_bits;\n        if (here_op & 64) {\n          strm.msg = 'invalid distance code';\n          state.mode = BAD;\n          break;\n        }\n        state.offset = here_val;\n        state.extra = (here_op) & 15;\n        state.mode = DISTEXT;\n        /* falls through */\n      case DISTEXT:\n        if (state.extra) {\n          //=== NEEDBITS(state.extra);\n          n = state.extra;\n          while (bits < n) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;\n          //--- DROPBITS(state.extra) ---//\n          hold >>>= state.extra;\n          bits -= state.extra;\n          //---//\n          state.back += state.extra;\n        }\n//#ifdef INFLATE_STRICT\n        if (state.offset > state.dmax) {\n          strm.msg = 'invalid distance too far back';\n          state.mode = BAD;\n          break;\n        }\n//#endif\n        //Tracevv((stderr, \"inflate:         distance %u\\n\", state.offset));\n        state.mode = MATCH;\n        /* falls through */\n      case MATCH:\n        if (left === 0) { break inf_leave; }\n        copy = _out - left;\n        if (state.offset > copy) {         /* copy from window */\n          copy = state.offset - copy;\n          if (copy > state.whave) {\n            if (state.sane) {\n              strm.msg = 'invalid distance too far back';\n              state.mode = BAD;\n              break;\n            }\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n//          Trace((stderr, \"inflate.c too far\\n\"));\n//          copy -= state.whave;\n//          if (copy > state.length) { copy = state.length; }\n//          if (copy > left) { copy = left; }\n//          left -= copy;\n//          state.length -= copy;\n//          do {\n//            output[put++] = 0;\n//          } while (--copy);\n//          if (state.length === 0) { state.mode = LEN; }\n//          break;\n//#endif\n          }\n          if (copy > state.wnext) {\n            copy -= state.wnext;\n            from = state.wsize - copy;\n          }\n          else {\n            from = state.wnext - copy;\n          }\n          if (copy > state.length) { copy = state.length; }\n          from_source = state.window;\n        }\n        else {                              /* copy from output */\n          from_source = output;\n          from = put - state.offset;\n          copy = state.length;\n        }\n        if (copy > left) { copy = left; }\n        left -= copy;\n        state.length -= copy;\n        do {\n          output[put++] = from_source[from++];\n        } while (--copy);\n        if (state.length === 0) { state.mode = LEN; }\n        break;\n      case LIT:\n        if (left === 0) { break inf_leave; }\n        output[put++] = state.length;\n        left--;\n        state.mode = LEN;\n        break;\n      case CHECK:\n        if (state.wrap) {\n          //=== NEEDBITS(32);\n          while (bits < 32) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            // Use '|' instead of '+' to make sure that result is signed\n            hold |= input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          _out -= left;\n          strm.total_out += _out;\n          state.total += _out;\n          if (_out) {\n            strm.adler = state.check =\n                /*UPDATE(state.check, put - _out, _out);*/\n                (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));\n\n          }\n          _out = left;\n          // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too\n          if ((state.flags ? hold : zswap32(hold)) !== state.check) {\n            strm.msg = 'incorrect data check';\n            state.mode = BAD;\n            break;\n          }\n          //=== INITBITS();\n          hold = 0;\n          bits = 0;\n          //===//\n          //Tracev((stderr, \"inflate:   check matches trailer\\n\"));\n        }\n        state.mode = LENGTH;\n        /* falls through */\n      case LENGTH:\n        if (state.wrap && state.flags) {\n          //=== NEEDBITS(32);\n          while (bits < 32) {\n            if (have === 0) { break inf_leave; }\n            have--;\n            hold += input[next++] << bits;\n            bits += 8;\n          }\n          //===//\n          if (hold !== (state.total & 0xffffffff)) {\n            strm.msg = 'incorrect length check';\n            state.mode = BAD;\n            break;\n          }\n          //=== INITBITS();\n          hold = 0;\n          bits = 0;\n          //===//\n          //Tracev((stderr, \"inflate:   length matches trailer\\n\"));\n        }\n        state.mode = DONE;\n        /* falls through */\n      case DONE:\n        ret = Z_STREAM_END;\n        break inf_leave;\n      case BAD:\n        ret = Z_DATA_ERROR;\n        break inf_leave;\n      case MEM:\n        return Z_MEM_ERROR;\n      case SYNC:\n        /* falls through */\n      default:\n        return Z_STREAM_ERROR;\n    }\n  }\n\n  // inf_leave <- here is real place for \"goto inf_leave\", emulated via \"break inf_leave\"\n\n  /*\n     Return from inflate(), updating the total counts and the check value.\n     If there was no progress during the inflate() call, return a buffer\n     error.  Call updatewindow() to create and/or update the window state.\n     Note: a memory error from inflate() is non-recoverable.\n   */\n\n  //--- RESTORE() ---\n  strm.next_out = put;\n  strm.avail_out = left;\n  strm.next_in = next;\n  strm.avail_in = have;\n  state.hold = hold;\n  state.bits = bits;\n  //---\n\n  if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&\n                      (state.mode < CHECK || flush !== Z_FINISH))) {\n    if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {\n      state.mode = MEM;\n      return Z_MEM_ERROR;\n    }\n  }\n  _in -= strm.avail_in;\n  _out -= strm.avail_out;\n  strm.total_in += _in;\n  strm.total_out += _out;\n  state.total += _out;\n  if (state.wrap && _out) {\n    strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/\n      (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));\n  }\n  strm.data_type = state.bits + (state.last ? 64 : 0) +\n                    (state.mode === TYPE ? 128 : 0) +\n                    (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);\n  if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {\n    ret = Z_BUF_ERROR;\n  }\n  return ret;\n}\n\nfunction inflateEnd(strm) {\n\n  if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {\n    return Z_STREAM_ERROR;\n  }\n\n  var state = strm.state;\n  if (state.window) {\n    state.window = null;\n  }\n  strm.state = null;\n  return Z_OK;\n}\n\nfunction inflateGetHeader(strm, head) {\n  var state;\n\n  /* check state */\n  if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n  state = strm.state;\n  if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }\n\n  /* save header structure */\n  state.head = head;\n  head.done = false;\n  return Z_OK;\n}\n\nfunction inflateSetDictionary(strm, dictionary) {\n  var dictLength = dictionary.length;\n\n  var state;\n  var dictid;\n  var ret;\n\n  /* check state */\n  if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }\n  state = strm.state;\n\n  if (state.wrap !== 0 && state.mode !== DICT) {\n    return Z_STREAM_ERROR;\n  }\n\n  /* check for correct dictionary identifier */\n  if (state.mode === DICT) {\n    dictid = 1; /* adler32(0, null, 0)*/\n    /* dictid = adler32(dictid, dictionary, dictLength); */\n    dictid = adler32(dictid, dictionary, dictLength, 0);\n    if (dictid !== state.check) {\n      return Z_DATA_ERROR;\n    }\n  }\n  /* copy dictionary to window using updatewindow(), which will amend the\n   existing dictionary if appropriate */\n  ret = updatewindow(strm, dictionary, dictLength, dictLength);\n  if (ret) {\n    state.mode = MEM;\n    return Z_MEM_ERROR;\n  }\n  state.havedict = 1;\n  // Tracev((stderr, \"inflate:   dictionary set\\n\"));\n  return Z_OK;\n}\n\nexports.inflateReset = inflateReset;\nexports.inflateReset2 = inflateReset2;\nexports.inflateResetKeep = inflateResetKeep;\nexports.inflateInit = inflateInit;\nexports.inflateInit2 = inflateInit2;\nexports.inflate = inflate;\nexports.inflateEnd = inflateEnd;\nexports.inflateGetHeader = inflateGetHeader;\nexports.inflateSetDictionary = inflateSetDictionary;\nexports.inflateInfo = 'pako inflate (from Nodeca project)';\n\n/* Not implemented\nexports.inflateCopy = inflateCopy;\nexports.inflateGetDictionary = inflateGetDictionary;\nexports.inflateMark = inflateMark;\nexports.inflatePrime = inflatePrime;\nexports.inflateSync = inflateSync;\nexports.inflateSyncPoint = inflateSyncPoint;\nexports.inflateUndermine = inflateUndermine;\n*/\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n/* eslint-disable space-unary-ops */\n\nvar utils = require('../utils/common');\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n//var Z_FILTERED          = 1;\n//var Z_HUFFMAN_ONLY      = 2;\n//var Z_RLE               = 3;\nvar Z_FIXED               = 4;\n//var Z_DEFAULT_STRATEGY  = 0;\n\n/* Possible values of the data_type field (though see inflate()) */\nvar Z_BINARY              = 0;\nvar Z_TEXT                = 1;\n//var Z_ASCII             = 1; // = Z_TEXT\nvar Z_UNKNOWN             = 2;\n\n/*============================================================================*/\n\n\nfunction zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }\n\n// From zutil.h\n\nvar STORED_BLOCK = 0;\nvar STATIC_TREES = 1;\nvar DYN_TREES    = 2;\n/* The three kinds of block type */\n\nvar MIN_MATCH    = 3;\nvar MAX_MATCH    = 258;\n/* The minimum and maximum match lengths */\n\n// From deflate.h\n/* ===========================================================================\n * Internal compression state.\n */\n\nvar LENGTH_CODES  = 29;\n/* number of length codes, not counting the special END_BLOCK code */\n\nvar LITERALS      = 256;\n/* number of literal bytes 0..255 */\n\nvar L_CODES       = LITERALS + 1 + LENGTH_CODES;\n/* number of Literal or Length codes, including the END_BLOCK code */\n\nvar D_CODES       = 30;\n/* number of distance codes */\n\nvar BL_CODES      = 19;\n/* number of codes used to transfer the bit lengths */\n\nvar HEAP_SIZE     = 2 * L_CODES + 1;\n/* maximum heap size */\n\nvar MAX_BITS      = 15;\n/* All codes must not exceed MAX_BITS bits */\n\nvar Buf_size      = 16;\n/* size of bit buffer in bi_buf */\n\n\n/* ===========================================================================\n * Constants\n */\n\nvar MAX_BL_BITS = 7;\n/* Bit length codes must not exceed MAX_BL_BITS bits */\n\nvar END_BLOCK   = 256;\n/* end of block literal code */\n\nvar REP_3_6     = 16;\n/* repeat previous bit length 3-6 times (2 bits of repeat count) */\n\nvar REPZ_3_10   = 17;\n/* repeat a zero length 3-10 times  (3 bits of repeat count) */\n\nvar REPZ_11_138 = 18;\n/* repeat a zero length 11-138 times  (7 bits of repeat count) */\n\n/* eslint-disable comma-spacing,array-bracket-spacing */\nvar extra_lbits =   /* extra bits for each length code */\n  [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];\n\nvar extra_dbits =   /* extra bits for each distance code */\n  [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];\n\nvar extra_blbits =  /* extra bits for each bit length code */\n  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];\n\nvar bl_order =\n  [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];\n/* eslint-enable comma-spacing,array-bracket-spacing */\n\n/* The lengths of the bit length codes are sent in order of decreasing\n * probability, to avoid transmitting the lengths for unused bit length codes.\n */\n\n/* ===========================================================================\n * Local data. These are initialized only once.\n */\n\n// We pre-fill arrays with 0 to avoid uninitialized gaps\n\nvar DIST_CODE_LEN = 512; /* see definition of array dist_code below */\n\n// !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\nvar static_ltree  = new Array((L_CODES + 2) * 2);\nzero(static_ltree);\n/* The static literal tree. Since the bit lengths are imposed, there is no\n * need for the L_CODES extra codes used during heap construction. However\n * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n * below).\n */\n\nvar static_dtree  = new Array(D_CODES * 2);\nzero(static_dtree);\n/* The static distance tree. (Actually a trivial tree since all codes use\n * 5 bits.)\n */\n\nvar _dist_code    = new Array(DIST_CODE_LEN);\nzero(_dist_code);\n/* Distance codes. The first 256 values correspond to the distances\n * 3 .. 258, the last 256 values correspond to the top 8 bits of\n * the 15 bit distances.\n */\n\nvar _length_code  = new Array(MAX_MATCH - MIN_MATCH + 1);\nzero(_length_code);\n/* length code for each normalized match length (0 == MIN_MATCH) */\n\nvar base_length   = new Array(LENGTH_CODES);\nzero(base_length);\n/* First normalized length for each code (0 = MIN_MATCH) */\n\nvar base_dist     = new Array(D_CODES);\nzero(base_dist);\n/* First normalized distance for each code (0 = distance of 1) */\n\n\nfunction StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n\n  this.static_tree  = static_tree;  /* static tree or NULL */\n  this.extra_bits   = extra_bits;   /* extra bits for each code or NULL */\n  this.extra_base   = extra_base;   /* base index for extra_bits */\n  this.elems        = elems;        /* max number of elements in the tree */\n  this.max_length   = max_length;   /* max bit length for the codes */\n\n  // show if `static_tree` has data or dummy - needed for monomorphic objects\n  this.has_stree    = static_tree && static_tree.length;\n}\n\n\nvar static_l_desc;\nvar static_d_desc;\nvar static_bl_desc;\n\n\nfunction TreeDesc(dyn_tree, stat_desc) {\n  this.dyn_tree = dyn_tree;     /* the dynamic tree */\n  this.max_code = 0;            /* largest code with non zero frequency */\n  this.stat_desc = stat_desc;   /* the corresponding static tree */\n}\n\n\n\nfunction d_code(dist) {\n  return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n}\n\n\n/* ===========================================================================\n * Output a short LSB first on the stream.\n * IN assertion: there is enough room in pendingBuf.\n */\nfunction put_short(s, w) {\n//    put_byte(s, (uch)((w) & 0xff));\n//    put_byte(s, (uch)((ush)(w) >> 8));\n  s.pending_buf[s.pending++] = (w) & 0xff;\n  s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n}\n\n\n/* ===========================================================================\n * Send a value on a given number of bits.\n * IN assertion: length <= 16 and value fits in length bits.\n */\nfunction send_bits(s, value, length) {\n  if (s.bi_valid > (Buf_size - length)) {\n    s.bi_buf |= (value << s.bi_valid) & 0xffff;\n    put_short(s, s.bi_buf);\n    s.bi_buf = value >> (Buf_size - s.bi_valid);\n    s.bi_valid += length - Buf_size;\n  } else {\n    s.bi_buf |= (value << s.bi_valid) & 0xffff;\n    s.bi_valid += length;\n  }\n}\n\n\nfunction send_code(s, c, tree) {\n  send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);\n}\n\n\n/* ===========================================================================\n * Reverse the first len bits of a code, using straightforward code (a faster\n * method would use a table)\n * IN assertion: 1 <= len <= 15\n */\nfunction bi_reverse(code, len) {\n  var res = 0;\n  do {\n    res |= code & 1;\n    code >>>= 1;\n    res <<= 1;\n  } while (--len > 0);\n  return res >>> 1;\n}\n\n\n/* ===========================================================================\n * Flush the bit buffer, keeping at most 7 bits in it.\n */\nfunction bi_flush(s) {\n  if (s.bi_valid === 16) {\n    put_short(s, s.bi_buf);\n    s.bi_buf = 0;\n    s.bi_valid = 0;\n\n  } else if (s.bi_valid >= 8) {\n    s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n    s.bi_buf >>= 8;\n    s.bi_valid -= 8;\n  }\n}\n\n\n/* ===========================================================================\n * Compute the optimal bit lengths for a tree and update the total bit length\n * for the current block.\n * IN assertion: the fields freq and dad are set, heap[heap_max] and\n *    above are the tree nodes sorted by increasing frequency.\n * OUT assertions: the field len is set to the optimal bit length, the\n *     array bl_count contains the frequencies for each bit length.\n *     The length opt_len is updated; static_len is also updated if stree is\n *     not null.\n */\nfunction gen_bitlen(s, desc)\n//    deflate_state *s;\n//    tree_desc *desc;    /* the tree descriptor */\n{\n  var tree            = desc.dyn_tree;\n  var max_code        = desc.max_code;\n  var stree           = desc.stat_desc.static_tree;\n  var has_stree       = desc.stat_desc.has_stree;\n  var extra           = desc.stat_desc.extra_bits;\n  var base            = desc.stat_desc.extra_base;\n  var max_length      = desc.stat_desc.max_length;\n  var h;              /* heap index */\n  var n, m;           /* iterate over the tree elements */\n  var bits;           /* bit length */\n  var xbits;          /* extra bits */\n  var f;              /* frequency */\n  var overflow = 0;   /* number of elements with bit length too large */\n\n  for (bits = 0; bits <= MAX_BITS; bits++) {\n    s.bl_count[bits] = 0;\n  }\n\n  /* In a first pass, compute the optimal bit lengths (which may\n   * overflow in the case of the bit length tree).\n   */\n  tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */\n\n  for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n    n = s.heap[h];\n    bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;\n    if (bits > max_length) {\n      bits = max_length;\n      overflow++;\n    }\n    tree[n * 2 + 1]/*.Len*/ = bits;\n    /* We overwrite tree[n].Dad which is no longer needed */\n\n    if (n > max_code) { continue; } /* not a leaf node */\n\n    s.bl_count[bits]++;\n    xbits = 0;\n    if (n >= base) {\n      xbits = extra[n - base];\n    }\n    f = tree[n * 2]/*.Freq*/;\n    s.opt_len += f * (bits + xbits);\n    if (has_stree) {\n      s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);\n    }\n  }\n  if (overflow === 0) { return; }\n\n  // Trace((stderr,\"\\nbit length overflow\\n\"));\n  /* This happens for example on obj2 and pic of the Calgary corpus */\n\n  /* Find the first bit length which could increase: */\n  do {\n    bits = max_length - 1;\n    while (s.bl_count[bits] === 0) { bits--; }\n    s.bl_count[bits]--;      /* move one leaf down the tree */\n    s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */\n    s.bl_count[max_length]--;\n    /* The brother of the overflow item also moves one step up,\n     * but this does not affect bl_count[max_length]\n     */\n    overflow -= 2;\n  } while (overflow > 0);\n\n  /* Now recompute all bit lengths, scanning in increasing frequency.\n   * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n   * lengths instead of fixing only the wrong ones. This idea is taken\n   * from 'ar' written by Haruhiko Okumura.)\n   */\n  for (bits = max_length; bits !== 0; bits--) {\n    n = s.bl_count[bits];\n    while (n !== 0) {\n      m = s.heap[--h];\n      if (m > max_code) { continue; }\n      if (tree[m * 2 + 1]/*.Len*/ !== bits) {\n        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n        s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;\n        tree[m * 2 + 1]/*.Len*/ = bits;\n      }\n      n--;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Generate the codes for a given tree and bit counts (which need not be\n * optimal).\n * IN assertion: the array bl_count contains the bit length statistics for\n * the given tree and the field len is set for all tree elements.\n * OUT assertion: the field code is set for all tree elements of non\n *     zero code length.\n */\nfunction gen_codes(tree, max_code, bl_count)\n//    ct_data *tree;             /* the tree to decorate */\n//    int max_code;              /* largest code with non zero frequency */\n//    ushf *bl_count;            /* number of codes at each bit length */\n{\n  var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */\n  var code = 0;              /* running code value */\n  var bits;                  /* bit index */\n  var n;                     /* code index */\n\n  /* The distribution counts are first used to generate the code values\n   * without bit reversal.\n   */\n  for (bits = 1; bits <= MAX_BITS; bits++) {\n    next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n  }\n  /* Check that the bit counts in bl_count are consistent. The last code\n   * must be all ones.\n   */\n  //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n  //        \"inconsistent bit counts\");\n  //Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n\n  for (n = 0;  n <= max_code; n++) {\n    var len = tree[n * 2 + 1]/*.Len*/;\n    if (len === 0) { continue; }\n    /* Now reverse the bits */\n    tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);\n\n    //Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n    //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n  }\n}\n\n\n/* ===========================================================================\n * Initialize the various 'constant' tables.\n */\nfunction tr_static_init() {\n  var n;        /* iterates over tree elements */\n  var bits;     /* bit counter */\n  var length;   /* length value */\n  var code;     /* code value */\n  var dist;     /* distance index */\n  var bl_count = new Array(MAX_BITS + 1);\n  /* number of codes at each bit length for an optimal tree */\n\n  // do check in _tr_init()\n  //if (static_init_done) return;\n\n  /* For some embedded targets, global variables are not initialized: */\n/*#ifdef NO_INIT_GLOBAL_POINTERS\n  static_l_desc.static_tree = static_ltree;\n  static_l_desc.extra_bits = extra_lbits;\n  static_d_desc.static_tree = static_dtree;\n  static_d_desc.extra_bits = extra_dbits;\n  static_bl_desc.extra_bits = extra_blbits;\n#endif*/\n\n  /* Initialize the mapping length (0..255) -> length code (0..28) */\n  length = 0;\n  for (code = 0; code < LENGTH_CODES - 1; code++) {\n    base_length[code] = length;\n    for (n = 0; n < (1 << extra_lbits[code]); n++) {\n      _length_code[length++] = code;\n    }\n  }\n  //Assert (length == 256, \"tr_static_init: length != 256\");\n  /* Note that the length 255 (match length 258) can be represented\n   * in two different ways: code 284 + 5 bits or code 285, so we\n   * overwrite length_code[255] to use the best encoding:\n   */\n  _length_code[length - 1] = code;\n\n  /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n  dist = 0;\n  for (code = 0; code < 16; code++) {\n    base_dist[code] = dist;\n    for (n = 0; n < (1 << extra_dbits[code]); n++) {\n      _dist_code[dist++] = code;\n    }\n  }\n  //Assert (dist == 256, \"tr_static_init: dist != 256\");\n  dist >>= 7; /* from now on, all distances are divided by 128 */\n  for (; code < D_CODES; code++) {\n    base_dist[code] = dist << 7;\n    for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {\n      _dist_code[256 + dist++] = code;\n    }\n  }\n  //Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n\n  /* Construct the codes of the static literal tree */\n  for (bits = 0; bits <= MAX_BITS; bits++) {\n    bl_count[bits] = 0;\n  }\n\n  n = 0;\n  while (n <= 143) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 8;\n    n++;\n    bl_count[8]++;\n  }\n  while (n <= 255) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 9;\n    n++;\n    bl_count[9]++;\n  }\n  while (n <= 279) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 7;\n    n++;\n    bl_count[7]++;\n  }\n  while (n <= 287) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 8;\n    n++;\n    bl_count[8]++;\n  }\n  /* Codes 286 and 287 do not exist, but we must include them in the\n   * tree construction to get a canonical Huffman tree (longest code\n   * all ones)\n   */\n  gen_codes(static_ltree, L_CODES + 1, bl_count);\n\n  /* The static distance tree is trivial: */\n  for (n = 0; n < D_CODES; n++) {\n    static_dtree[n * 2 + 1]/*.Len*/ = 5;\n    static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);\n  }\n\n  // Now data ready and we can init static trees\n  static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);\n  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);\n\n  //static_init_done = true;\n}\n\n\n/* ===========================================================================\n * Initialize a new block.\n */\nfunction init_block(s) {\n  var n; /* iterates over tree elements */\n\n  /* Initialize the trees. */\n  for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }\n  for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }\n  for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }\n\n  s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;\n  s.opt_len = s.static_len = 0;\n  s.last_lit = s.matches = 0;\n}\n\n\n/* ===========================================================================\n * Flush the bit buffer and align the output on a byte boundary\n */\nfunction bi_windup(s)\n{\n  if (s.bi_valid > 8) {\n    put_short(s, s.bi_buf);\n  } else if (s.bi_valid > 0) {\n    //put_byte(s, (Byte)s->bi_buf);\n    s.pending_buf[s.pending++] = s.bi_buf;\n  }\n  s.bi_buf = 0;\n  s.bi_valid = 0;\n}\n\n/* ===========================================================================\n * Copy a stored block, storing first the length and its\n * one's complement if requested.\n */\nfunction copy_block(s, buf, len, header)\n//DeflateState *s;\n//charf    *buf;    /* the input data */\n//unsigned len;     /* its length */\n//int      header;  /* true if block header must be written */\n{\n  bi_windup(s);        /* align on byte boundary */\n\n  if (header) {\n    put_short(s, len);\n    put_short(s, ~len);\n  }\n//  while (len--) {\n//    put_byte(s, *buf++);\n//  }\n  utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);\n  s.pending += len;\n}\n\n/* ===========================================================================\n * Compares to subtrees, using the tree depth as tie breaker when\n * the subtrees have equal frequency. This minimizes the worst case length.\n */\nfunction smaller(tree, n, m, depth) {\n  var _n2 = n * 2;\n  var _m2 = m * 2;\n  return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||\n         (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));\n}\n\n/* ===========================================================================\n * Restore the heap property by moving down the tree starting at node k,\n * exchanging a node with the smallest of its two sons if necessary, stopping\n * when the heap property is re-established (each father smaller than its\n * two sons).\n */\nfunction pqdownheap(s, tree, k)\n//    deflate_state *s;\n//    ct_data *tree;  /* the tree to restore */\n//    int k;               /* node to move down */\n{\n  var v = s.heap[k];\n  var j = k << 1;  /* left son of k */\n  while (j <= s.heap_len) {\n    /* Set j to the smallest of the two sons: */\n    if (j < s.heap_len &&\n      smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n      j++;\n    }\n    /* Exit if v is smaller than both sons */\n    if (smaller(tree, v, s.heap[j], s.depth)) { break; }\n\n    /* Exchange v with the smallest son */\n    s.heap[k] = s.heap[j];\n    k = j;\n\n    /* And continue down the tree, setting j to the left son of k */\n    j <<= 1;\n  }\n  s.heap[k] = v;\n}\n\n\n// inlined manually\n// var SMALLEST = 1;\n\n/* ===========================================================================\n * Send the block data compressed using the given Huffman trees\n */\nfunction compress_block(s, ltree, dtree)\n//    deflate_state *s;\n//    const ct_data *ltree; /* literal tree */\n//    const ct_data *dtree; /* distance tree */\n{\n  var dist;           /* distance of matched string */\n  var lc;             /* match length or unmatched char (if dist == 0) */\n  var lx = 0;         /* running index in l_buf */\n  var code;           /* the code to send */\n  var extra;          /* number of extra bits to send */\n\n  if (s.last_lit !== 0) {\n    do {\n      dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);\n      lc = s.pending_buf[s.l_buf + lx];\n      lx++;\n\n      if (dist === 0) {\n        send_code(s, lc, ltree); /* send a literal byte */\n        //Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n      } else {\n        /* Here, lc is the match length - MIN_MATCH */\n        code = _length_code[lc];\n        send_code(s, code + LITERALS + 1, ltree); /* send the length code */\n        extra = extra_lbits[code];\n        if (extra !== 0) {\n          lc -= base_length[code];\n          send_bits(s, lc, extra);       /* send the extra length bits */\n        }\n        dist--; /* dist is now the match distance - 1 */\n        code = d_code(dist);\n        //Assert (code < D_CODES, \"bad d_code\");\n\n        send_code(s, code, dtree);       /* send the distance code */\n        extra = extra_dbits[code];\n        if (extra !== 0) {\n          dist -= base_dist[code];\n          send_bits(s, dist, extra);   /* send the extra distance bits */\n        }\n      } /* literal or match pair ? */\n\n      /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n      //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n      //       \"pendingBuf overflow\");\n\n    } while (lx < s.last_lit);\n  }\n\n  send_code(s, END_BLOCK, ltree);\n}\n\n\n/* ===========================================================================\n * Construct one Huffman tree and assigns the code bit strings and lengths.\n * Update the total bit length for the current block.\n * IN assertion: the field freq is set for all tree elements.\n * OUT assertions: the fields len and code are set to the optimal bit length\n *     and corresponding code. The length opt_len is updated; static_len is\n *     also updated if stree is not null. The field max_code is set.\n */\nfunction build_tree(s, desc)\n//    deflate_state *s;\n//    tree_desc *desc; /* the tree descriptor */\n{\n  var tree     = desc.dyn_tree;\n  var stree    = desc.stat_desc.static_tree;\n  var has_stree = desc.stat_desc.has_stree;\n  var elems    = desc.stat_desc.elems;\n  var n, m;          /* iterate over heap elements */\n  var max_code = -1; /* largest code with non zero frequency */\n  var node;          /* new node being created */\n\n  /* Construct the initial heap, with least frequent element in\n   * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n   * heap[0] is not used.\n   */\n  s.heap_len = 0;\n  s.heap_max = HEAP_SIZE;\n\n  for (n = 0; n < elems; n++) {\n    if (tree[n * 2]/*.Freq*/ !== 0) {\n      s.heap[++s.heap_len] = max_code = n;\n      s.depth[n] = 0;\n\n    } else {\n      tree[n * 2 + 1]/*.Len*/ = 0;\n    }\n  }\n\n  /* The pkzip format requires that at least one distance code exists,\n   * and that at least one bit should be sent even if there is only one\n   * possible code. So to avoid special checks later on we force at least\n   * two codes of non zero frequency.\n   */\n  while (s.heap_len < 2) {\n    node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);\n    tree[node * 2]/*.Freq*/ = 1;\n    s.depth[node] = 0;\n    s.opt_len--;\n\n    if (has_stree) {\n      s.static_len -= stree[node * 2 + 1]/*.Len*/;\n    }\n    /* node is 0 or 1 so it does not have extra bits */\n  }\n  desc.max_code = max_code;\n\n  /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n   * establish sub-heaps of increasing lengths:\n   */\n  for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }\n\n  /* Construct the Huffman tree by repeatedly combining the least two\n   * frequent nodes.\n   */\n  node = elems;              /* next internal node of the tree */\n  do {\n    //pqremove(s, tree, n);  /* n = node of least frequency */\n    /*** pqremove ***/\n    n = s.heap[1/*SMALLEST*/];\n    s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];\n    pqdownheap(s, tree, 1/*SMALLEST*/);\n    /***/\n\n    m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */\n\n    s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */\n    s.heap[--s.heap_max] = m;\n\n    /* Create a new node father of n and m */\n    tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;\n    s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n    tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;\n\n    /* and insert the new node in the heap */\n    s.heap[1/*SMALLEST*/] = node++;\n    pqdownheap(s, tree, 1/*SMALLEST*/);\n\n  } while (s.heap_len >= 2);\n\n  s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];\n\n  /* At this point, the fields freq and dad are set. We can now\n   * generate the bit lengths.\n   */\n  gen_bitlen(s, desc);\n\n  /* The field len is now set, we can generate the bit codes */\n  gen_codes(tree, max_code, s.bl_count);\n}\n\n\n/* ===========================================================================\n * Scan a literal or distance tree to determine the frequencies of the codes\n * in the bit length tree.\n */\nfunction scan_tree(s, tree, max_code)\n//    deflate_state *s;\n//    ct_data *tree;   /* the tree to be scanned */\n//    int max_code;    /* and its largest code of non zero frequency */\n{\n  var n;                     /* iterates over all tree elements */\n  var prevlen = -1;          /* last emitted length */\n  var curlen;                /* length of current code */\n\n  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */\n\n  var count = 0;             /* repeat count of the current code */\n  var max_count = 7;         /* max repeat count */\n  var min_count = 4;         /* min repeat count */\n\n  if (nextlen === 0) {\n    max_count = 138;\n    min_count = 3;\n  }\n  tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */\n\n  for (n = 0; n <= max_code; n++) {\n    curlen = nextlen;\n    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;\n\n    if (++count < max_count && curlen === nextlen) {\n      continue;\n\n    } else if (count < min_count) {\n      s.bl_tree[curlen * 2]/*.Freq*/ += count;\n\n    } else if (curlen !== 0) {\n\n      if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }\n      s.bl_tree[REP_3_6 * 2]/*.Freq*/++;\n\n    } else if (count <= 10) {\n      s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;\n\n    } else {\n      s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;\n    }\n\n    count = 0;\n    prevlen = curlen;\n\n    if (nextlen === 0) {\n      max_count = 138;\n      min_count = 3;\n\n    } else if (curlen === nextlen) {\n      max_count = 6;\n      min_count = 3;\n\n    } else {\n      max_count = 7;\n      min_count = 4;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Send a literal or distance tree in compressed form, using the codes in\n * bl_tree.\n */\nfunction send_tree(s, tree, max_code)\n//    deflate_state *s;\n//    ct_data *tree; /* the tree to be scanned */\n//    int max_code;       /* and its largest code of non zero frequency */\n{\n  var n;                     /* iterates over all tree elements */\n  var prevlen = -1;          /* last emitted length */\n  var curlen;                /* length of current code */\n\n  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */\n\n  var count = 0;             /* repeat count of the current code */\n  var max_count = 7;         /* max repeat count */\n  var min_count = 4;         /* min repeat count */\n\n  /* tree[max_code+1].Len = -1; */  /* guard already set */\n  if (nextlen === 0) {\n    max_count = 138;\n    min_count = 3;\n  }\n\n  for (n = 0; n <= max_code; n++) {\n    curlen = nextlen;\n    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;\n\n    if (++count < max_count && curlen === nextlen) {\n      continue;\n\n    } else if (count < min_count) {\n      do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);\n\n    } else if (curlen !== 0) {\n      if (curlen !== prevlen) {\n        send_code(s, curlen, s.bl_tree);\n        count--;\n      }\n      //Assert(count >= 3 && count <= 6, \" 3_6?\");\n      send_code(s, REP_3_6, s.bl_tree);\n      send_bits(s, count - 3, 2);\n\n    } else if (count <= 10) {\n      send_code(s, REPZ_3_10, s.bl_tree);\n      send_bits(s, count - 3, 3);\n\n    } else {\n      send_code(s, REPZ_11_138, s.bl_tree);\n      send_bits(s, count - 11, 7);\n    }\n\n    count = 0;\n    prevlen = curlen;\n    if (nextlen === 0) {\n      max_count = 138;\n      min_count = 3;\n\n    } else if (curlen === nextlen) {\n      max_count = 6;\n      min_count = 3;\n\n    } else {\n      max_count = 7;\n      min_count = 4;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Construct the Huffman tree for the bit lengths and return the index in\n * bl_order of the last bit length code to send.\n */\nfunction build_bl_tree(s) {\n  var max_blindex;  /* index of last bit length code of non zero freq */\n\n  /* Determine the bit length frequencies for literal and distance trees */\n  scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n  scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n\n  /* Build the bit length tree: */\n  build_tree(s, s.bl_desc);\n  /* opt_len now includes the length of the tree representations, except\n   * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n   */\n\n  /* Determine the number of bit length codes to send. The pkzip format\n   * requires that at least 4 bit length codes be sent. (appnote.txt says\n   * 3 but the actual value used is 4.)\n   */\n  for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n    if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {\n      break;\n    }\n  }\n  /* Update opt_len to include the bit length tree and counts */\n  s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;\n  //Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n  //        s->opt_len, s->static_len));\n\n  return max_blindex;\n}\n\n\n/* ===========================================================================\n * Send the header for a block using dynamic Huffman trees: the counts, the\n * lengths of the bit length codes, the literal tree and the distance tree.\n * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n */\nfunction send_all_trees(s, lcodes, dcodes, blcodes)\n//    deflate_state *s;\n//    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n{\n  var rank;                    /* index in bl_order */\n\n  //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n  //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n  //        \"too many codes\");\n  //Tracev((stderr, \"\\nbl counts: \"));\n  send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */\n  send_bits(s, dcodes - 1,   5);\n  send_bits(s, blcodes - 4,  4); /* not -3 as stated in appnote.txt */\n  for (rank = 0; rank < blcodes; rank++) {\n    //Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n    send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);\n  }\n  //Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n\n  send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */\n  //Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n\n  send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */\n  //Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n}\n\n\n/* ===========================================================================\n * Check if the data type is TEXT or BINARY, using the following algorithm:\n * - TEXT if the two conditions below are satisfied:\n *    a) There are no non-portable control characters belonging to the\n *       \"black list\" (0..6, 14..25, 28..31).\n *    b) There is at least one printable character belonging to the\n *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n * - BINARY otherwise.\n * - The following partially-portable control characters form a\n *   \"gray list\" that is ignored in this detection algorithm:\n *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n * IN assertion: the fields Freq of dyn_ltree are set.\n */\nfunction detect_data_type(s) {\n  /* black_mask is the bit mask of black-listed bytes\n   * set bits 0..6, 14..25, and 28..31\n   * 0xf3ffc07f = binary 11110011111111111100000001111111\n   */\n  var black_mask = 0xf3ffc07f;\n  var n;\n\n  /* Check for non-textual (\"black-listed\") bytes. */\n  for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n    if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {\n      return Z_BINARY;\n    }\n  }\n\n  /* Check for textual (\"white-listed\") bytes. */\n  if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||\n      s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {\n    return Z_TEXT;\n  }\n  for (n = 32; n < LITERALS; n++) {\n    if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {\n      return Z_TEXT;\n    }\n  }\n\n  /* There are no \"black-listed\" or \"white-listed\" bytes:\n   * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n   */\n  return Z_BINARY;\n}\n\n\nvar static_init_done = false;\n\n/* ===========================================================================\n * Initialize the tree data structures for a new zlib stream.\n */\nfunction _tr_init(s)\n{\n\n  if (!static_init_done) {\n    tr_static_init();\n    static_init_done = true;\n  }\n\n  s.l_desc  = new TreeDesc(s.dyn_ltree, static_l_desc);\n  s.d_desc  = new TreeDesc(s.dyn_dtree, static_d_desc);\n  s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n\n  s.bi_buf = 0;\n  s.bi_valid = 0;\n\n  /* Initialize the first block of the first file: */\n  init_block(s);\n}\n\n\n/* ===========================================================================\n * Send a stored block\n */\nfunction _tr_stored_block(s, buf, stored_len, last)\n//DeflateState *s;\n//charf *buf;       /* input block */\n//ulg stored_len;   /* length of input block */\n//int last;         /* one if this is the last block for a file */\n{\n  send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);    /* send block type */\n  copy_block(s, buf, stored_len, true); /* with header */\n}\n\n\n/* ===========================================================================\n * Send one empty static block to give enough lookahead for inflate.\n * This takes 10 bits, of which 7 may remain in the bit buffer.\n */\nfunction _tr_align(s) {\n  send_bits(s, STATIC_TREES << 1, 3);\n  send_code(s, END_BLOCK, static_ltree);\n  bi_flush(s);\n}\n\n\n/* ===========================================================================\n * Determine the best encoding for the current block: dynamic trees, static\n * trees or store, and output the encoded block to the zip file.\n */\nfunction _tr_flush_block(s, buf, stored_len, last)\n//DeflateState *s;\n//charf *buf;       /* input block, or NULL if too old */\n//ulg stored_len;   /* length of input block */\n//int last;         /* one if this is the last block for a file */\n{\n  var opt_lenb, static_lenb;  /* opt_len and static_len in bytes */\n  var max_blindex = 0;        /* index of last bit length code of non zero freq */\n\n  /* Build the Huffman trees unless a stored block is forced */\n  if (s.level > 0) {\n\n    /* Check if the file is binary or text */\n    if (s.strm.data_type === Z_UNKNOWN) {\n      s.strm.data_type = detect_data_type(s);\n    }\n\n    /* Construct the literal and distance trees */\n    build_tree(s, s.l_desc);\n    // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n    //        s->static_len));\n\n    build_tree(s, s.d_desc);\n    // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n    //        s->static_len));\n    /* At this point, opt_len and static_len are the total bit lengths of\n     * the compressed block data, excluding the tree representations.\n     */\n\n    /* Build the bit length tree for the above two trees, and get the index\n     * in bl_order of the last bit length code to send.\n     */\n    max_blindex = build_bl_tree(s);\n\n    /* Determine the best encoding. Compute the block lengths in bytes. */\n    opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n    static_lenb = (s.static_len + 3 + 7) >>> 3;\n\n    // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n    //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n    //        s->last_lit));\n\n    if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }\n\n  } else {\n    // Assert(buf != (char*)0, \"lost buf\");\n    opt_lenb = static_lenb = stored_len + 5; /* force a stored block */\n  }\n\n  if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {\n    /* 4: two words for the lengths */\n\n    /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n     * Otherwise we can't have processed more than WSIZE input bytes since\n     * the last block flush, because compression would have been\n     * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n     * transform a block into a stored block.\n     */\n    _tr_stored_block(s, buf, stored_len, last);\n\n  } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n\n    send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n    compress_block(s, static_ltree, static_dtree);\n\n  } else {\n    send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n    send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n    compress_block(s, s.dyn_ltree, s.dyn_dtree);\n  }\n  // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n  /* The above check is made mod 2^32, for files larger than 512 MB\n   * and uLong implemented on 32 bits.\n   */\n  init_block(s);\n\n  if (last) {\n    bi_windup(s);\n  }\n  // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n  //       s->compressed_len-7*last));\n}\n\n/* ===========================================================================\n * Save the match info and tally the frequency counts. Return true if\n * the current block must be flushed.\n */\nfunction _tr_tally(s, dist, lc)\n//    deflate_state *s;\n//    unsigned dist;  /* distance of matched string */\n//    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n{\n  //var out_length, in_length, dcode;\n\n  s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;\n  s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n\n  s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n  s.last_lit++;\n\n  if (dist === 0) {\n    /* lc is the unmatched char */\n    s.dyn_ltree[lc * 2]/*.Freq*/++;\n  } else {\n    s.matches++;\n    /* Here, lc is the match length - MIN_MATCH */\n    dist--;             /* dist = match distance - 1 */\n    //Assert((ush)dist < (ush)MAX_DIST(s) &&\n    //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n    //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n\n    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;\n    s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;\n  }\n\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n\n//#ifdef TRUNCATE_BLOCK\n//  /* Try to guess if it is profitable to stop the current block here */\n//  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n//    /* Compute an upper bound for the compressed length */\n//    out_length = s.last_lit*8;\n//    in_length = s.strstart - s.block_start;\n//\n//    for (dcode = 0; dcode < D_CODES; dcode++) {\n//      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n//    }\n//    out_length >>>= 3;\n//    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n//    //       s->last_lit, in_length, out_length,\n//    //       100L - out_length*100L/in_length));\n//    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n//      return true;\n//    }\n//  }\n//#endif\n\n  return (s.last_lit === s.lit_bufsize - 1);\n  /* We avoid equality with lit_bufsize because of wraparound at 64K\n   * on 16 bit machines and because stored blocks are restricted to\n   * 64K-1 bytes.\n   */\n}\n\nexports._tr_init  = _tr_init;\nexports._tr_stored_block = _tr_stored_block;\nexports._tr_flush_block  = _tr_flush_block;\nexports._tr_tally = _tr_tally;\nexports._tr_align = _tr_align;\n","// Top level file is just a mixin of submodules & constants\n'use strict';\n\nvar assign    = require('./lib/utils/common').assign;\n\nvar deflate   = require('./lib/deflate');\nvar inflate   = require('./lib/inflate');\nvar constants = require('./lib/zlib/constants');\n\nvar pako = {};\n\nassign(pako, deflate, inflate, constants);\n\nmodule.exports = pako;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n  2:      'need dictionary',     /* Z_NEED_DICT       2  */\n  1:      'stream end',          /* Z_STREAM_END      1  */\n  0:      '',                    /* Z_OK              0  */\n  '-1':   'file error',          /* Z_ERRNO         (-1) */\n  '-2':   'stream error',        /* Z_STREAM_ERROR  (-2) */\n  '-3':   'data error',          /* Z_DATA_ERROR    (-3) */\n  '-4':   'insufficient memory', /* Z_MEM_ERROR     (-4) */\n  '-5':   'buffer error',        /* Z_BUF_ERROR     (-5) */\n  '-6':   'incompatible version' /* Z_VERSION_ERROR (-6) */\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n\n  /* Allowed flush values; see deflate() and inflate() below for details */\n  Z_NO_FLUSH:         0,\n  Z_PARTIAL_FLUSH:    1,\n  Z_SYNC_FLUSH:       2,\n  Z_FULL_FLUSH:       3,\n  Z_FINISH:           4,\n  Z_BLOCK:            5,\n  Z_TREES:            6,\n\n  /* Return codes for the compression/decompression functions. Negative values\n  * are errors, positive values are used for special but normal events.\n  */\n  Z_OK:               0,\n  Z_STREAM_END:       1,\n  Z_NEED_DICT:        2,\n  Z_ERRNO:           -1,\n  Z_STREAM_ERROR:    -2,\n  Z_DATA_ERROR:      -3,\n  //Z_MEM_ERROR:     -4,\n  Z_BUF_ERROR:       -5,\n  //Z_VERSION_ERROR: -6,\n\n  /* compression levels */\n  Z_NO_COMPRESSION:         0,\n  Z_BEST_SPEED:             1,\n  Z_BEST_COMPRESSION:       9,\n  Z_DEFAULT_COMPRESSION:   -1,\n\n\n  Z_FILTERED:               1,\n  Z_HUFFMAN_ONLY:           2,\n  Z_RLE:                    3,\n  Z_FIXED:                  4,\n  Z_DEFAULT_STRATEGY:       0,\n\n  /* Possible values of the data_type field (though see inflate()) */\n  Z_BINARY:                 0,\n  Z_TEXT:                   1,\n  //Z_ASCII:                1, // = Z_TEXT (deprecated)\n  Z_UNKNOWN:                2,\n\n  /* The deflate compression method */\n  Z_DEFLATED:               8\n  //Z_NULL:                 null // Use -1 or null inline, depending on var type\n};\n","'use strict';\n\n\nvar TYPED_OK =  (typeof Uint8Array !== 'undefined') &&\n                (typeof Uint16Array !== 'undefined') &&\n                (typeof Int32Array !== 'undefined');\n\nfunction _has(obj, key) {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nexports.assign = function (obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n  while (sources.length) {\n    var source = sources.shift();\n    if (!source) { continue; }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be non-object');\n    }\n\n    for (var p in source) {\n      if (_has(source, p)) {\n        obj[p] = source[p];\n      }\n    }\n  }\n\n  return obj;\n};\n\n\n// reduce buffer size, avoiding mem copy\nexports.shrinkBuf = function (buf, size) {\n  if (buf.length === size) { return buf; }\n  if (buf.subarray) { return buf.subarray(0, size); }\n  buf.length = size;\n  return buf;\n};\n\n\nvar fnTyped = {\n  arraySet: function (dest, src, src_offs, len, dest_offs) {\n    if (src.subarray && dest.subarray) {\n      dest.set(src.subarray(src_offs, src_offs + len), dest_offs);\n      return;\n    }\n    // Fallback to ordinary array\n    for (var i = 0; i < len; i++) {\n      dest[dest_offs + i] = src[src_offs + i];\n    }\n  },\n  // Join array of chunks to single array.\n  flattenChunks: function (chunks) {\n    var i, l, len, pos, chunk, result;\n\n    // calculate data length\n    len = 0;\n    for (i = 0, l = chunks.length; i < l; i++) {\n      len += chunks[i].length;\n    }\n\n    // join chunks\n    result = new Uint8Array(len);\n    pos = 0;\n    for (i = 0, l = chunks.length; i < l; i++) {\n      chunk = chunks[i];\n      result.set(chunk, pos);\n      pos += chunk.length;\n    }\n\n    return result;\n  }\n};\n\nvar fnUntyped = {\n  arraySet: function (dest, src, src_offs, len, dest_offs) {\n    for (var i = 0; i < len; i++) {\n      dest[dest_offs + i] = src[src_offs + i];\n    }\n  },\n  // Join array of chunks to single array.\n  flattenChunks: function (chunks) {\n    return [].concat.apply([], chunks);\n  }\n};\n\n\n// Enable/Disable typed arrays use, for testing\n//\nexports.setTyped = function (on) {\n  if (on) {\n    exports.Buf8  = Uint8Array;\n    exports.Buf16 = Uint16Array;\n    exports.Buf32 = Int32Array;\n    exports.assign(exports, fnTyped);\n  } else {\n    exports.Buf8  = Array;\n    exports.Buf16 = Array;\n    exports.Buf32 = Array;\n    exports.assign(exports, fnUntyped);\n  }\n};\n\nexports.setTyped(TYPED_OK);\n","'use strict';\n\n// Note: we can't get significant speed boost here.\n// So write code to minimize size - no pregenerated tables\n// and array tools dependencies.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// Use ordinary array, since untyped makes no boost here\nfunction makeTable() {\n  var c, table = [];\n\n  for (var n = 0; n < 256; n++) {\n    c = n;\n    for (var k = 0; k < 8; k++) {\n      c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));\n    }\n    table[n] = c;\n  }\n\n  return table;\n}\n\n// Create table on load. Just 255 signed longs. Not a problem.\nvar crcTable = makeTable();\n\n\nfunction crc32(crc, buf, len, pos) {\n  var t = crcTable,\n      end = pos + len;\n\n  crc ^= -1;\n\n  for (var i = pos; i < end; i++) {\n    crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];\n  }\n\n  return (crc ^ (-1)); // >>> 0;\n}\n\n\nmodule.exports = crc32;\n","// String encode/decode helpers\n'use strict';\n\n\nvar utils = require('./common');\n\n\n// Quick check if we can use fast array to bin string conversion\n//\n// - apply(Array) can fail on Android 2.2\n// - apply(Uint8Array) can fail on iOS 5.1 Safari\n//\nvar STR_APPLY_OK = true;\nvar STR_APPLY_UIA_OK = true;\n\ntry { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }\ntry { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }\n\n\n// Table with utf8 lengths (calculated by first byte of sequence)\n// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n// because max possible codepoint is 0x10ffff\nvar _utf8len = new utils.Buf8(256);\nfor (var q = 0; q < 256; q++) {\n  _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);\n}\n_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n\n\n// convert string to array (typed, when possible)\nexports.string2buf = function (str) {\n  var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;\n\n  // count binary size\n  for (m_pos = 0; m_pos < str_len; m_pos++) {\n    c = str.charCodeAt(m_pos);\n    if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n      c2 = str.charCodeAt(m_pos + 1);\n      if ((c2 & 0xfc00) === 0xdc00) {\n        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n        m_pos++;\n      }\n    }\n    buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n  }\n\n  // allocate buffer\n  buf = new utils.Buf8(buf_len);\n\n  // convert\n  for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n    c = str.charCodeAt(m_pos);\n    if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n      c2 = str.charCodeAt(m_pos + 1);\n      if ((c2 & 0xfc00) === 0xdc00) {\n        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n        m_pos++;\n      }\n    }\n    if (c < 0x80) {\n      /* one byte */\n      buf[i++] = c;\n    } else if (c < 0x800) {\n      /* two bytes */\n      buf[i++] = 0xC0 | (c >>> 6);\n      buf[i++] = 0x80 | (c & 0x3f);\n    } else if (c < 0x10000) {\n      /* three bytes */\n      buf[i++] = 0xE0 | (c >>> 12);\n      buf[i++] = 0x80 | (c >>> 6 & 0x3f);\n      buf[i++] = 0x80 | (c & 0x3f);\n    } else {\n      /* four bytes */\n      buf[i++] = 0xf0 | (c >>> 18);\n      buf[i++] = 0x80 | (c >>> 12 & 0x3f);\n      buf[i++] = 0x80 | (c >>> 6 & 0x3f);\n      buf[i++] = 0x80 | (c & 0x3f);\n    }\n  }\n\n  return buf;\n};\n\n// Helper (used in 2 places)\nfunction buf2binstring(buf, len) {\n  // On Chrome, the arguments in a function call that are allowed is `65534`.\n  // If the length of the buffer is smaller than that, we can use this optimization,\n  // otherwise we will take a slower path.\n  if (len < 65534) {\n    if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {\n      return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));\n    }\n  }\n\n  var result = '';\n  for (var i = 0; i < len; i++) {\n    result += String.fromCharCode(buf[i]);\n  }\n  return result;\n}\n\n\n// Convert byte array to binary string\nexports.buf2binstring = function (buf) {\n  return buf2binstring(buf, buf.length);\n};\n\n\n// Convert binary string (typed, when possible)\nexports.binstring2buf = function (str) {\n  var buf = new utils.Buf8(str.length);\n  for (var i = 0, len = buf.length; i < len; i++) {\n    buf[i] = str.charCodeAt(i);\n  }\n  return buf;\n};\n\n\n// convert array to string\nexports.buf2string = function (buf, max) {\n  var i, out, c, c_len;\n  var len = max || buf.length;\n\n  // Reserve max possible length (2 words per char)\n  // NB: by unknown reasons, Array is significantly faster for\n  //     String.fromCharCode.apply than Uint16Array.\n  var utf16buf = new Array(len * 2);\n\n  for (out = 0, i = 0; i < len;) {\n    c = buf[i++];\n    // quick process ascii\n    if (c < 0x80) { utf16buf[out++] = c; continue; }\n\n    c_len = _utf8len[c];\n    // skip 5 & 6 byte codes\n    if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }\n\n    // apply mask on first byte\n    c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;\n    // join the rest\n    while (c_len > 1 && i < len) {\n      c = (c << 6) | (buf[i++] & 0x3f);\n      c_len--;\n    }\n\n    // terminated by end of string?\n    if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }\n\n    if (c < 0x10000) {\n      utf16buf[out++] = c;\n    } else {\n      c -= 0x10000;\n      utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);\n      utf16buf[out++] = 0xdc00 | (c & 0x3ff);\n    }\n  }\n\n  return buf2binstring(utf16buf, out);\n};\n\n\n// Calculate max possible position in utf8 buffer,\n// that will not break sequence. If that's not possible\n// - (very small limits) return max size as is.\n//\n// buf[] - utf8 bytes array\n// max   - length limit (mandatory);\nexports.utf8border = function (buf, max) {\n  var pos;\n\n  max = max || buf.length;\n  if (max > buf.length) { max = buf.length; }\n\n  // go back from last position, until start of sequence found\n  pos = max - 1;\n  while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }\n\n  // Very small and broken sequence,\n  // return max, because we should return something anyway.\n  if (pos < 0) { return max; }\n\n  // If we came to start of buffer - that means buffer is too small,\n  // return max too.\n  if (pos === 0) { return max; }\n\n  return (pos + _utf8len[buf[pos]] > max) ? pos : max;\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nvar utils = require('../utils/common');\n\nvar MAXBITS = 15;\nvar ENOUGH_LENS = 852;\nvar ENOUGH_DISTS = 592;\n//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nvar CODES = 0;\nvar LENS = 1;\nvar DISTS = 2;\n\nvar lbase = [ /* Length codes 257..285 base */\n  3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,\n  35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0\n];\n\nvar lext = [ /* Length codes 257..285 extra */\n  16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,\n  19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78\n];\n\nvar dbase = [ /* Distance codes 0..29 base */\n  1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,\n  257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,\n  8193, 12289, 16385, 24577, 0, 0\n];\n\nvar dext = [ /* Distance codes 0..29 extra */\n  16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,\n  23, 23, 24, 24, 25, 25, 26, 26, 27, 27,\n  28, 28, 29, 29, 64, 64\n];\n\nmodule.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)\n{\n  var bits = opts.bits;\n      //here = opts.here; /* table entry for duplication */\n\n  var len = 0;               /* a code's length in bits */\n  var sym = 0;               /* index of code symbols */\n  var min = 0, max = 0;          /* minimum and maximum code lengths */\n  var root = 0;              /* number of index bits for root table */\n  var curr = 0;              /* number of index bits for current table */\n  var drop = 0;              /* code bits to drop for sub-table */\n  var left = 0;                   /* number of prefix codes available */\n  var used = 0;              /* code entries in table used */\n  var huff = 0;              /* Huffman code */\n  var incr;              /* for incrementing code, index */\n  var fill;              /* index for replicating entries */\n  var low;               /* low bits for current root entry */\n  var mask;              /* mask for low root bits */\n  var next;             /* next available space in table */\n  var base = null;     /* base value table to use */\n  var base_index = 0;\n//  var shoextra;    /* extra bits table to use */\n  var end;                    /* use base and extra for symbol > end */\n  var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];    /* number of codes of each length */\n  var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1];     /* offsets in table for each length */\n  var extra = null;\n  var extra_index = 0;\n\n  var here_bits, here_op, here_val;\n\n  /*\n   Process a set of code lengths to create a canonical Huffman code.  The\n   code lengths are lens[0..codes-1].  Each length corresponds to the\n   symbols 0..codes-1.  The Huffman code is generated by first sorting the\n   symbols by length from short to long, and retaining the symbol order\n   for codes with equal lengths.  Then the code starts with all zero bits\n   for the first code of the shortest length, and the codes are integer\n   increments for the same length, and zeros are appended as the length\n   increases.  For the deflate format, these bits are stored backwards\n   from their more natural integer increment ordering, and so when the\n   decoding tables are built in the large loop below, the integer codes\n   are incremented backwards.\n\n   This routine assumes, but does not check, that all of the entries in\n   lens[] are in the range 0..MAXBITS.  The caller must assure this.\n   1..MAXBITS is interpreted as that code length.  zero means that that\n   symbol does not occur in this code.\n\n   The codes are sorted by computing a count of codes for each length,\n   creating from that a table of starting indices for each length in the\n   sorted table, and then entering the symbols in order in the sorted\n   table.  The sorted table is work[], with that space being provided by\n   the caller.\n\n   The length counts are used for other purposes as well, i.e. finding\n   the minimum and maximum length codes, determining if there are any\n   codes at all, checking for a valid set of lengths, and looking ahead\n   at length counts to determine sub-table sizes when building the\n   decoding tables.\n   */\n\n  /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */\n  for (len = 0; len <= MAXBITS; len++) {\n    count[len] = 0;\n  }\n  for (sym = 0; sym < codes; sym++) {\n    count[lens[lens_index + sym]]++;\n  }\n\n  /* bound code lengths, force root to be within code lengths */\n  root = bits;\n  for (max = MAXBITS; max >= 1; max--) {\n    if (count[max] !== 0) { break; }\n  }\n  if (root > max) {\n    root = max;\n  }\n  if (max === 0) {                     /* no symbols to code at all */\n    //table.op[opts.table_index] = 64;  //here.op = (var char)64;    /* invalid code marker */\n    //table.bits[opts.table_index] = 1;   //here.bits = (var char)1;\n    //table.val[opts.table_index++] = 0;   //here.val = (var short)0;\n    table[table_index++] = (1 << 24) | (64 << 16) | 0;\n\n\n    //table.op[opts.table_index] = 64;\n    //table.bits[opts.table_index] = 1;\n    //table.val[opts.table_index++] = 0;\n    table[table_index++] = (1 << 24) | (64 << 16) | 0;\n\n    opts.bits = 1;\n    return 0;     /* no symbols, but wait for decoding to report error */\n  }\n  for (min = 1; min < max; min++) {\n    if (count[min] !== 0) { break; }\n  }\n  if (root < min) {\n    root = min;\n  }\n\n  /* check for an over-subscribed or incomplete set of lengths */\n  left = 1;\n  for (len = 1; len <= MAXBITS; len++) {\n    left <<= 1;\n    left -= count[len];\n    if (left < 0) {\n      return -1;\n    }        /* over-subscribed */\n  }\n  if (left > 0 && (type === CODES || max !== 1)) {\n    return -1;                      /* incomplete set */\n  }\n\n  /* generate offsets into symbol table for each length for sorting */\n  offs[1] = 0;\n  for (len = 1; len < MAXBITS; len++) {\n    offs[len + 1] = offs[len] + count[len];\n  }\n\n  /* sort symbols by length, by symbol order within each length */\n  for (sym = 0; sym < codes; sym++) {\n    if (lens[lens_index + sym] !== 0) {\n      work[offs[lens[lens_index + sym]]++] = sym;\n    }\n  }\n\n  /*\n   Create and fill in decoding tables.  In this loop, the table being\n   filled is at next and has curr index bits.  The code being used is huff\n   with length len.  That code is converted to an index by dropping drop\n   bits off of the bottom.  For codes where len is less than drop + curr,\n   those top drop + curr - len bits are incremented through all values to\n   fill the table with replicated entries.\n\n   root is the number of index bits for the root table.  When len exceeds\n   root, sub-tables are created pointed to by the root entry with an index\n   of the low root bits of huff.  This is saved in low to check for when a\n   new sub-table should be started.  drop is zero when the root table is\n   being filled, and drop is root when sub-tables are being filled.\n\n   When a new sub-table is needed, it is necessary to look ahead in the\n   code lengths to determine what size sub-table is needed.  The length\n   counts are used for this, and so count[] is decremented as codes are\n   entered in the tables.\n\n   used keeps track of how many table entries have been allocated from the\n   provided *table space.  It is checked for LENS and DIST tables against\n   the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in\n   the initial root table size constants.  See the comments in inftrees.h\n   for more information.\n\n   sym increments through all symbols, and the loop terminates when\n   all codes of length max, i.e. all codes, have been processed.  This\n   routine permits incomplete codes, so another loop after this one fills\n   in the rest of the decoding tables with invalid code markers.\n   */\n\n  /* set up for code type */\n  // poor man optimization - use if-else instead of switch,\n  // to avoid deopts in old v8\n  if (type === CODES) {\n    base = extra = work;    /* dummy value--not used */\n    end = 19;\n\n  } else if (type === LENS) {\n    base = lbase;\n    base_index -= 257;\n    extra = lext;\n    extra_index -= 257;\n    end = 256;\n\n  } else {                    /* DISTS */\n    base = dbase;\n    extra = dext;\n    end = -1;\n  }\n\n  /* initialize opts for loop */\n  huff = 0;                   /* starting code */\n  sym = 0;                    /* starting code symbol */\n  len = min;                  /* starting code length */\n  next = table_index;              /* current table to fill in */\n  curr = root;                /* current table index bits */\n  drop = 0;                   /* current bits to drop from code for index */\n  low = -1;                   /* trigger new sub-table when len > root */\n  used = 1 << root;          /* use root table entries */\n  mask = used - 1;            /* mask for comparing low */\n\n  /* check available table space */\n  if ((type === LENS && used > ENOUGH_LENS) ||\n    (type === DISTS && used > ENOUGH_DISTS)) {\n    return 1;\n  }\n\n  /* process all codes and make table entries */\n  for (;;) {\n    /* create table entry */\n    here_bits = len - drop;\n    if (work[sym] < end) {\n      here_op = 0;\n      here_val = work[sym];\n    }\n    else if (work[sym] > end) {\n      here_op = extra[extra_index + work[sym]];\n      here_val = base[base_index + work[sym]];\n    }\n    else {\n      here_op = 32 + 64;         /* end of block */\n      here_val = 0;\n    }\n\n    /* replicate for those indices with low len bits equal to huff */\n    incr = 1 << (len - drop);\n    fill = 1 << curr;\n    min = fill;                 /* save offset to next table */\n    do {\n      fill -= incr;\n      table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;\n    } while (fill !== 0);\n\n    /* backwards increment the len-bit code huff */\n    incr = 1 << (len - 1);\n    while (huff & incr) {\n      incr >>= 1;\n    }\n    if (incr !== 0) {\n      huff &= incr - 1;\n      huff += incr;\n    } else {\n      huff = 0;\n    }\n\n    /* go to next symbol, update count, len */\n    sym++;\n    if (--count[len] === 0) {\n      if (len === max) { break; }\n      len = lens[lens_index + work[sym]];\n    }\n\n    /* create new sub-table if needed */\n    if (len > root && (huff & mask) !== low) {\n      /* if first time, transition to sub-tables */\n      if (drop === 0) {\n        drop = root;\n      }\n\n      /* increment past last table */\n      next += min;            /* here min is 1 << curr */\n\n      /* determine length of next table */\n      curr = len - drop;\n      left = 1 << curr;\n      while (curr + drop < max) {\n        left -= count[curr + drop];\n        if (left <= 0) { break; }\n        curr++;\n        left <<= 1;\n      }\n\n      /* check for enough space */\n      used += 1 << curr;\n      if ((type === LENS && used > ENOUGH_LENS) ||\n        (type === DISTS && used > ENOUGH_DISTS)) {\n        return 1;\n      }\n\n      /* point entry in root table to sub-table */\n      low = huff & mask;\n      /*table.op[low] = curr;\n      table.bits[low] = root;\n      table.val[low] = next - opts.table_index;*/\n      table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;\n    }\n  }\n\n  /* fill in remaining table entry if code is incomplete (guaranteed to have\n   at most one remaining entry, since if the code is incomplete, the\n   maximum code length that was allowed to get this far is one bit) */\n  if (huff !== 0) {\n    //table.op[next + huff] = 64;            /* invalid code marker */\n    //table.bits[next + huff] = len - drop;\n    //table.val[next + huff] = 0;\n    table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;\n  }\n\n  /* set return parameters */\n  //opts.table_index += used;\n  opts.bits = root;\n  return 0;\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import { Uuid } from './types';\n\nexport const MAGIC = new Uint8Array([66, 82, 83]); // BRS\nexport const LATEST_VERSION = 14;\nexport const MAX_INT = ~(1 << 31);\nexport const DEFAULT_UUID: Uuid = '00000000-0000-0000-0000-000000000000';\n","// this code is modified from https://github.com/uuidjs/uuid\n\nimport { Uuid } from './types';\n\n/*\nThe MIT License (MIT)\n\nCopyright (c) 2010-2020 Robert Kieffer and other contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\nconst hexTable: string[] = Array.from({ length: 256 }).map((_, i) =>\n  (i + 0x100).toString(16).substr(1)\n);\n\n// stringify uuid\nexport function uuidStringify(arr: number[]): Uuid {\n  return (\n    hexTable[arr[0]] +\n    hexTable[arr[1]] +\n    hexTable[arr[2]] +\n    hexTable[arr[3]] +\n    '-' +\n    hexTable[arr[4]] +\n    hexTable[arr[5]] +\n    '-' +\n    hexTable[arr[6]] +\n    hexTable[arr[7]] +\n    '-' +\n    hexTable[arr[8]] +\n    hexTable[arr[9]] +\n    '-' +\n    hexTable[arr[10]] +\n    hexTable[arr[11]] +\n    hexTable[arr[12]] +\n    hexTable[arr[13]] +\n    hexTable[arr[14]] +\n    hexTable[arr[15]]\n  ).toLowerCase();\n}\n\nexport function uuidParse(uuid: Uuid): Uint8Array {\n  let v;\n  const arr = new Uint8Array(16);\n\n  // Parse ########-....-....-....-............\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = (v >>> 16) & 0xff;\n  arr[2] = (v >>> 8) & 0xff;\n  arr[3] = v & 0xff;\n\n  // Parse ........-####-....-....-............\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff;\n\n  // Parse ........-....-####-....-............\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff;\n\n  // Parse ........-....-....-####-............\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff;\n\n  // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n  arr[10] = ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff;\n  arr[11] = (v / 0x100000000) & 0xff;\n  arr[12] = (v >>> 24) & 0xff;\n  arr[13] = (v >>> 16) & 0xff;\n  arr[14] = (v >>> 8) & 0xff;\n  arr[15] = v & 0xff;\n\n  return arr;\n}\n","import { deflate, inflate } from 'pako';\nimport { MAX_INT } from './constants';\nimport {\n  BRInventoryEntryPlan,\n  BRSBytes,\n  Bytes,\n  IntVector,\n  UnrealColor,\n  UnrealFloat,\n  UnrealType,\n  Uuid,\n  Vector3d,\n  WireGraphVariant,\n} from './types';\nimport { uuidParse, uuidStringify } from './uuid';\n\n/*\n  Notes:\n    - Everything is Little Endian by default because\n      UE4 uses it.\n    - I'd use Buffer.readUInt16LE if I was making this\n      nodejs only. I don't want to require('Buffer/')\n\n */\n\n// Determine if a string is ascii-only\nfunction isASCII(text: string): boolean {\n  return /^[\\x00-\\x7F]*$/.test(text);\n}\n\n// convert BGRA color to RGBA color\nexport const bgra = ([b, g, r, a]: number[]): [\n  number,\n  number,\n  number,\n  number\n] => [r, g, b, a];\n\n// Compare equality of byte arrays\nexport function isEqual<T>(arrA: Array<T>, arrB: Array<T>): boolean {\n  return arrA.length === arrB.length && arrA.every((a: T, i) => arrB[i] === a);\n}\n\nfunction isBRSBytes(data: Bytes): data is BRSBytes {\n  return (data as BRSBytes).brsOffset !== undefined;\n}\n\n// read `len` bytes and return slice while updating offset\nexport function subarray(data: Bytes, len: number, isCopy = false): Uint8Array {\n  if (!(data instanceof Uint8Array)) {\n    throw new Error(`Invalid data type in bytes reader (${typeof data})`);\n  }\n\n  let bytes: BRSBytes;\n  if (!isBRSBytes(data)) {\n    bytes = data as BRSBytes;\n    bytes.brsOffset = 0;\n  } else {\n    bytes = data;\n  }\n\n  const chunk = bytes[isCopy ? 'slice' : 'subarray'](\n    bytes.brsOffset,\n    bytes.brsOffset + len\n  );\n  bytes.brsOffset += len;\n  return chunk;\n}\n\n// break a byte array into chunks of a specified size\nexport function chunk(arr: Bytes, size: number): BRSBytes[] {\n  // relative length based on the offset of the array's data view\n  const length = arr.length - (isBRSBytes(arr) ? arr.brsOffset : 0);\n\n  // out array of chunks pre-allocated\n  const out = Array(Math.floor(length / size));\n\n  for (let i = 0; i < length / size; i++) {\n    out[i] = subarray(arr, size, true);\n  }\n\n  return out;\n}\n\n// Read a u16 from a byte array\nfunction read_u16(data: Bytes, littleEndian = true): number {\n  const [a, b] = subarray(data, 2);\n\n  return littleEndian ? (b << 8) | a : (a << 8) | b;\n}\n\n// Write a u16 into byte array\nfunction write_u16(num: number, littleEndian = true): Uint8Array {\n  const data = [num & 255, (num >> 8) & 255];\n  return new Uint8Array(!littleEndian ? data.reverse() : data);\n}\n\n// Read an i32 from a byte array\nfunction read_i32(data: Bytes, littleEndian = true): number {\n  const [a, b, c, d] = subarray(data, 4);\n  return littleEndian\n    ? (d << 24) | (c << 16) | (b << 8) | a\n    : (a << 24) | (b << 16) | (c << 8) | d;\n}\n\n// Write an i32 from a byte array\nfunction write_i32(num: number, littleEndian = true): Uint8Array {\n  const data = new Uint8Array([\n    num & 255,\n    (num >> 8) & 255,\n    (num >> 16) & 255,\n    (num >> 24) & 255,\n  ]);\n\n  return !littleEndian ? data.reverse() : data;\n}\n\n// Decompress a byte array of compressed data\nfunction read_compressed(data: Bytes): Bytes {\n  const uncompressedSize = read_i32(data);\n  const compressedSize = read_i32(data);\n\n  // Throw error for weird compression/uncompression sizes\n  if (\n    compressedSize < 0 ||\n    uncompressedSize < 0 ||\n    compressedSize >= uncompressedSize\n  ) {\n    throw new Error(\n      `Invalid compressed section size (comp: ${compressedSize}, uncomp: ${uncompressedSize})`\n    );\n  }\n\n  // No compressed data? Return those bytes\n  if (compressedSize === 0) {\n    return subarray(data, uncompressedSize);\n  } else {\n    // Decompress the data otherwise\n    const compressed = subarray(data, compressedSize);\n    return inflate(compressed);\n  }\n}\n\n// Compress a byte array into fewer bytes\nfunction write_uncompressed(...args: Uint8Array[]): Uint8Array {\n  // Concat the args to one massive array\n  const data = concat(...args);\n\n  // Build the output\n  return concat(write_i32(data.length), write_i32(0), data);\n}\n\n// Compress a byte array into fewer bytes\nfunction write_compressed(...args: Uint8Array[]): Uint8Array {\n  // Concat the args to one massive array\n  const data = concat(...args);\n\n  // Do the compression\n  const compressed = deflate(data);\n  const uncompressedSize = data.length;\n  const compressedSize = compressed.length;\n\n  if (uncompressedSize > MAX_INT) {\n    throw new Error(`uncompressedSize (${uncompressedSize}) out of range`);\n  }\n\n  if (compressedSize > MAX_INT) {\n    throw new Error(`compressedSize (${compressedSize}) out of range`);\n  }\n\n  // Determine if compression increases size\n  const badCompress = compressedSize >= uncompressedSize;\n\n  // Build the output\n  return concat(\n    write_i32(uncompressedSize),\n    write_i32(badCompress ? 0 : compressedSize),\n    badCompress ? data : compressed\n  );\n}\n\n// Read a string from a byte array\nfunction read_string(data: Bytes): string {\n  const raw_size = read_i32(data);\n  const is_ucs2 = raw_size < 0;\n  const size = is_ucs2 ? -raw_size * 2 : raw_size;\n\n  // Determine if we are using UCS-2\n  if (is_ucs2) {\n    if (size % 2 !== 0) {\n      throw new Error('Invalid UCS-2 data size');\n    }\n\n    // Create ucs2 encoded string\n    return String.fromCodePoint(\n      // Read the data in 2 byte windows\n      ...chunk(subarray(data, size), 2).map(arr => read_u16(arr)) // Convert the two bytes into u16\n    );\n  } else {\n    // Read the data, remove the \\u0000 at the end :)\n    const strData = subarray(data, size).subarray(0, -1);\n\n    // Convert into ascii\n    // console.debug('[debug] strdata', strData);\n    return String.fromCharCode.apply(null, strData);\n  }\n}\n\n// Write a string to bytes\nfunction write_string(str: string): Uint8Array {\n  if (isASCII(str)) {\n    return concat(\n      write_i32(str.length + 1), // Write string length (+ null term)\n      new Uint8Array(str.split('').map(s => s.charCodeAt(0))), // Write string as bytes\n      new Uint8Array([0]) // Null terminator\n    );\n  } else {\n    // ucs2 strings denoted by negative length\n    const len = -str.length;\n    return concat(\n      write_i32(len), // write length\n      // convert string to little endian ucs2\n      new Uint8Array(\n        str\n          .split('')\n          .flatMap(s => [s.charCodeAt(0) & 0xff, s.charCodeAt(0) >> 8])\n      )\n      // new Uint8Array([0]) // Null terminator\n    );\n  }\n}\n\n// Read uuid from 4 LE ints\nfunction read_uuid(data: Bytes): string {\n  return uuidStringify(\n    // each chunk is LE\n    chunk(subarray(data, 16), 4).flatMap(([a, b, c, d]) => [d, c, b, a])\n  );\n}\n\n// parse a uuid into 4 LE ints\nfunction write_uuid(uuid: Uuid) {\n  return concat(\n    ...chunk(uuidParse(uuid), 4).map(\n      ([a, b, c, d]) => new Uint8Array([d, c, b, a])\n    )\n  );\n}\n\n// Read an array of things given a fn\nfunction read_array<T>(data: Bytes, fn: (_: Bytes) => T): T[] {\n  const length = read_i32(data);\n  const arr = Array(length);\n  for (let i = 0; i < length; i++) {\n    arr[i] = fn(data);\n  }\n  return arr;\n}\n\n// iterate an array of things given a fn\nfunction read_each(data: Bytes, fn: (_: Bytes) => void) {\n  const length = read_i32(data);\n  for (let i = 0; i < length; i++) {\n    fn(data);\n  }\n}\n\n// Write an array of things to bytes\nfunction write_array<T>(arr: T[], fn: (_: T) => Uint8Array) {\n  return concat(write_i32(arr.length), ...arr.map(o => fn(o)));\n}\n\n// Tool for reading byte arrays 1 bit at a time\nexport class BitReader {\n  buffer: Uint8Array;\n  pos: number = 0;\n\n  constructor(data: Uint8Array) {\n    this.buffer = data;\n  }\n\n  empty(): boolean {\n    return this.pos >= this.buffer.length * 8;\n  }\n\n  // Read one bit as a boolean\n  bit(): boolean {\n    const bit = (this.buffer[this.pos >> 3] & (1 << (this.pos & 0b111))) !== 0;\n    this.pos++;\n    return bit;\n  }\n\n  // Align the pos to the nearest byte\n  align() {\n    this.pos = (this.pos + 7) & ~7;\n  }\n\n  // read an int up to max\n  int(max: number): number {\n    let value = 0;\n    let mask = 1;\n\n    while (value + mask < max && mask !== 0) {\n      if (this.bit()) {\n        value |= mask;\n      }\n      mask <<= 1;\n    }\n\n    return value;\n  }\n\n  // read a packet in from bits\n  uint_packed(): number {\n    let value = 0;\n    for (let i = 0; i < 5; i++) {\n      const next = this.bit();\n\n      let part = 0;\n      for (let shift = 0; shift < 7; shift++) {\n        part |= (this.bit() ? 1 : 0) << shift;\n      }\n      value |= part << (7 * i);\n      if (!next) {\n        break;\n      }\n    }\n\n    return value;\n  }\n\n  // an item in a read_positive_int_vector array\n  int_packed(): number {\n    const value = this.uint_packed();\n    return (value >> 1) * ((value & 1) !== 0 ? 1 : -1);\n  }\n\n  // read some bits\n  bits(num: number): number[] {\n    const arr: number[] = [];\n    for (let bit = 0; bit < num; bit++) {\n      const shift = bit & 7;\n      arr[bit >> 3] =\n        (arr[bit >> 3] & ~(1 << shift)) | ((this.bit() ? 1 : 0) << shift);\n    }\n    return arr;\n  }\n\n  // Read some bytes\n  bytes(num: number): Uint8Array {\n    return new Uint8Array(this.bytesArr(num));\n  }\n\n  // read some bytes but not as a Uint8Array\n  bytesArr(num: number): number[] {\n    return this.bits(num * 8);\n  }\n\n  // read an array\n  array<T>(fn: (_: BitReader) => T): T[] {\n    const length = read_i32(this.bytes(4));\n    const arr = Array(length);\n    for (let i = 0; i < length; i++) {\n      arr[i] = fn(this);\n    }\n    return arr;\n  }\n\n  // for each\n  each(fn: (data: BitReader) => void) {\n    const length = read_i32(this.bytes(4));\n    for (let i = 0; i < length; i++) {\n      fn(this);\n    }\n  }\n\n  // read a string\n  string(): string {\n    const lenBytes = this.bytesArr(4);\n    let len = read_i32(new Uint8Array(lenBytes));\n    if (len < 0) len = -len * 2;\n    return read_string(new Uint8Array(lenBytes.concat(this.bytesArr(len))));\n  }\n\n  // read a 32-bit float\n  float(): number {\n    const view = new DataView(new ArrayBuffer(4));\n\n    // Write the ints to it\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a float; note that by doing this, we're implicitly\n    // converting it from a 32-bit float into JavaScript's native 64-bit double\n    return view.getFloat32(0);\n  }\n\n  integer(): number {\n    const view = new DataView(new ArrayBuffer(4));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a signed 32-bit integer\n    return view.getInt32(0);\n  }\n\n  int64(): number {\n    const view = new DataView(new ArrayBuffer(8));\n\n    // Read it 2 bytes at a time\n    view.setUint16(6, read_u16(this.bytes(2)));\n    view.setUint16(4, read_u16(this.bytes(2)));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a signed 64-bit integer\n    const num = view.getBigInt64(0);\n    if (num <= 1n << 64n) {\n      return Number(num);\n    }\n    throw new Error(\n      `Cannot read 64-bit integer ${num} as a JavaScript number...`\n    );\n  }\n\n  // read a 64-bit double\n  double(): number {\n    const view = new DataView(new ArrayBuffer(8));\n\n    // Read it 2 bytes at a time\n    view.setUint16(6, read_u16(this.bytes(2)));\n    view.setUint16(4, read_u16(this.bytes(2)));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a double\n    return view.getFloat64(0);\n  }\n\n  wireGraphVariant(): WireGraphVariant {\n    const type = this.bytes(1)[0];\n    switch (type) {\n      case 0: // number\n        return { number: this.double() };\n      case 1: // integer\n        return { integer: this.int64() };\n      case 2: // bool\n        return { bool: this.bytes(1)[0] !== 0 };\n      case 3: // exec\n        return { exec: true };\n      case 4: // object\n        return { object: true };\n      default:\n        throw new Error(`Unknown wire graph variant type ${type}`);\n    }\n  }\n\n  // read unreal types\n  unreal(type: string): UnrealType {\n    switch (type) {\n      case 'String':\n      case 'Class':\n      case 'Object':\n        return this.string();\n      case 'Boolean':\n        return !!read_i32(this.bytes(4));\n      case 'Integer':\n        return this.integer();\n      case 'Integer64':\n        return this.int64();\n      case 'Float':\n        return this.float();\n      case 'Double':\n        return this.double();\n      case 'Color':\n        return bgra(this.bytesArr(4)) as UnrealColor;\n      case 'Byte':\n        return this.bytes(1)[0];\n      case 'Rotator':\n      case 'Rotator3d':\n        return [this.float(), this.float(), this.float()];\n      case 'Vector3d':\n        return [this.float(), this.float(), this.float()] as Vector3d;\n      case 'IntVector':\n        return [this.integer(), this.integer(), this.integer()] as IntVector;\n      case 'BRInventoryEntryPlan':\n        return this.string() as BRInventoryEntryPlan;\n      case 'WireGraphVariant':\n        return this.wireGraphVariant();\n      case 'WireGraphPrimMathVariant':\n        return this.wireGraphVariant();\n    }\n    throw new Error('Unknown unreal type ' + type);\n  }\n}\n\nexport class BitWriter {\n  buffer: number[] = [];\n  cur: number = 0;\n  bitNum: number = 0;\n\n  // Write a boolean as a bit\n  bit(val: boolean) {\n    this.cur |= (val ? 1 : 0) << this.bitNum;\n    this.bitNum++;\n    if (this.bitNum >= 8) {\n      this.align();\n    }\n  }\n\n  // Write `len` bits from `src` bytes\n  bits(src: number[] | Uint8Array, len: number) {\n    for (let bit = 0; bit < len; bit++) {\n      this.bit((src[bit >> 3] & (1 << (bit & 7))) !== 0);\n    }\n  }\n\n  // Write multiple bytes\n  bytes(src: number[] | Uint8Array) {\n    this.bits(src, 8 * src.length);\n  }\n\n  // Push the current bit into the buffer\n  align() {\n    if (this.bitNum > 0) {\n      this.buffer.push(this.cur);\n      this.cur = 0;\n      this.bitNum = 0;\n    }\n  }\n\n  // Write an int up to the potential max size\n  int(value: number, max: number) {\n    if (max < 2) {\n      throw new Error(\n        `Invalid input (BitWriter) -- max (${max}) must be at least 2`\n      );\n    }\n\n    if (value >= max) {\n      throw new Error(\n        `Invalid input (BitWriter) -- value (${value}) is larger than max (${max})`\n      );\n    }\n\n    let new_val = 0;\n    let mask = 1;\n\n    while (new_val + mask < max && mask !== 0) {\n      this.bit((value & mask) !== 0);\n      if ((value & mask) !== 0) {\n        new_val |= mask;\n      }\n\n      mask <<= 1;\n    }\n  }\n\n  // Write a packed unsigned int\n  uint_packed(value: number) {\n    do {\n      const src = value & 0b1111111;\n      value >>= 7;\n      this.bit(value !== 0);\n      this.bits([src], 7);\n    } while (value !== 0);\n  }\n\n  // Write a packed integer\n  int_packed(value: number) {\n    this.uint_packed((Math.abs(value) << 1) | (value >= 0 ? 1 : 0));\n  }\n\n  // Return built buffer\n  finish(): Uint8Array {\n    this.align();\n    return new Uint8Array(this.buffer);\n  }\n\n  // Return built buffer (and include length)\n  finishSection() {\n    this.align();\n    return concat(write_i32(this.buffer.length), new Uint8Array(this.buffer));\n  }\n\n  // write a string\n  string(str: string) {\n    this.bytes(write_string(str));\n  }\n\n  float(num: UnrealFloat) {\n    // create a float array\n    const floatArr = new Float32Array(1);\n    // assign the number\n    floatArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(floatArr.buffer);\n    this.bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);\n  }\n\n  integer(num: number) {\n    // create an int array\n    const intArr = new Int32Array(1);\n    // assign the number\n    intArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(intArr.buffer);\n    this.bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);\n  }\n\n  int64(num: number | bigint | string) {\n    // write this as a 64-bit integer using a dataview\n    const view = new DataView(new ArrayBuffer(8));\n    view.setBigInt64(0, typeof num === 'bigint' ? num : BigInt(num), true);\n    this.bytes(new Uint8Array(view.buffer));\n  }\n\n  double(num: number) {\n    // create a double array\n    const doubleArr = new Float64Array(1);\n    // assign the number\n    doubleArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(doubleArr.buffer);\n    this.bytes([\n      bytes[0],\n      bytes[1],\n      bytes[2],\n      bytes[3],\n      bytes[4],\n      bytes[5],\n      bytes[6],\n      bytes[7],\n    ]);\n  }\n\n  wireGraphVariant(variant: WireGraphVariant) {\n    if ('number' in variant) {\n      this.bytes([0]); // type 0\n      this.double(variant.number);\n    } else if ('integer' in variant) {\n      this.bytes([1]); // type 1\n      this.int64(variant.integer);\n    } else if ('bool' in variant) {\n      this.bytes([2, variant.bool ? 1 : 0]); // type 2\n    } else if ('exec' in variant) {\n      this.bytes([3]); // type 3\n      // no data for exec\n    } else if ('object' in variant) {\n      this.bytes([4]); // type 4\n      // no data for object\n    } else {\n      throw new Error(\n        `Unknown wire graph variant type ${JSON.stringify(variant)}`\n      );\n    }\n  }\n\n  // run a function with `this` as a BitReader\n  self(fn: (this: BitWriter) => void) {\n    fn.bind(this)();\n    return this;\n  }\n\n  // write an array\n  array<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {\n    this.bytes(write_i32(arr.length));\n    arr.forEach(fn.bind(this));\n    return this;\n  }\n\n  // write things from an array\n  each<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {\n    arr.forEach(fn.bind(this));\n    return this;\n  }\n\n  // write unreal types\n  unreal(type: string, value: UnrealType) {\n    switch (type) {\n      case 'Class':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type Class, did not receive string (${value})`\n          );\n        }\n        this.string(value);\n        return;\n      case 'String':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type String, did not receive string (${value})`\n          );\n        }\n        this.string(value);\n        return;\n      case 'Object':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type Object, did not receive string (${value})`\n          );\n        }\n        this.string(value);\n        return;\n      case 'Boolean':\n        if (typeof value !== 'boolean') {\n          throw new Error(\n            `writing unreal type Boolean, did not receive boolean (${value})`\n          );\n        }\n        this.bytes(write_i32(value ? 1 : 0));\n        return;\n      case 'Float':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Float, did not receive float (${value})`\n          );\n        }\n        this.float(value);\n        return;\n      case 'Byte':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Byte, did not receive Byte (${value})`\n          );\n        }\n        this.bytes([value & 255]);\n        return;\n      case 'Color':\n        if (!Array.isArray(value) || value.length !== 4) {\n          throw new Error(\n            `writing unreal type Color, did not receive Array (${value})`\n          );\n        }\n        this.bytes(bgra(value));\n        return;\n      case 'Rotator':\n      case 'Rotator3d':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type Rotator, did not receive Array (${value})`\n          );\n        }\n\n        this.float(value[0]);\n        this.float(value[1]);\n        this.float(value[2]);\n        return;\n      case 'Vector3d':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type Vector3d, did not receive Array (${value})`\n          );\n        }\n\n        this.float(value[0]);\n        this.float(value[1]);\n        this.float(value[2]);\n        return;\n      case 'IntVector':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type IntVector, did not receive Array (${value})`\n          );\n        }\n        this.integer(value[0]);\n        this.integer(value[1]);\n        this.integer(value[2]);\n        return;\n      case 'Integer':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Integer, did not receive integer (${value})`\n          );\n        }\n        this.integer(value);\n        return;\n      case 'Integer64':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Integer64, did not receive integer (${value})`\n          );\n        }\n        this.int64(value);\n        return;\n      case 'Double':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Double, did not receive double (${value})`\n          );\n        }\n        this.double(value);\n        return;\n      case 'WireGraphVariant':\n        if (typeof value !== 'object') {\n          throw new Error(\n            `writing unreal type WireGraphVariant, did not receive object (${value})`\n          );\n        }\n        this.wireGraphVariant(value as WireGraphVariant);\n        return;\n      case 'WireGraphPrimMathVariant':\n        if (typeof value !== 'object') {\n          throw new Error(\n            `writing unreal type WireGraphPrimMathVariant, did not receive object (${value})`\n          );\n        }\n        this.wireGraphVariant(value as WireGraphVariant);\n        return;\n      case 'BRInventoryEntryPlan':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type BRInventoryEntryPlan, did not receive string (${value})`\n          );\n        }\n        this.string(value);\n        return;\n    }\n    throw new Error('Unknown unreal type ' + type);\n  }\n}\n\n// concat uint8arrays together\nexport function concat(...arrays: Uint8Array[]): Uint8Array {\n  const buffLen = arrays.reduce((sum, value) => sum + value.length, 0);\n  const buff = new Uint8Array(buffLen);\n\n  // for each array - copy it over buff\n  // next array is copied right after the previous one\n  let length = 0;\n  for (const array of arrays) {\n    buff.set(array, length);\n    length += array.length;\n  }\n\n  return buff;\n}\n\nexport const read = {\n  bytes: subarray,\n  u16: read_u16,\n  i32: read_i32,\n  compressed: read_compressed,\n  string: read_string,\n  uuid: read_uuid,\n  array: read_array,\n  each: read_each,\n  bits: (data: Bytes) => new BitReader(data),\n};\n\nexport const write = {\n  u16: write_u16,\n  i32: write_i32,\n  compressed: write_compressed,\n  uncompressed: write_uncompressed,\n  string: write_string,\n  uuid: write_uuid,\n  array: write_array,\n  bits: () => new BitWriter(),\n};\n","import { DEFAULT_UUID, LATEST_VERSION, MAGIC, MAX_INT } from './constants';\nimport {\n  Brick,\n  DefinedComponents,\n  Owner,\n  WriteOptions,\n  WriteSaveObject,\n} from './types';\nimport { concat, isEqual, write } from './utils';\n\nconst EMPTY_ARR = new Uint8Array([]);\n\nexport const DEFAULT_COMPONENTS: DefinedComponents = {\n  BCD_SpotLight: {\n    version: 1,\n    properties: {\n      Rotation: 'Rotator',\n      InnerConeAngle: 'Float',\n      OuterConeAngle: 'Float',\n      Brightness: 'Float',\n      Radius: 'Float',\n      Color: 'Color',\n      bUseBrickColor: 'Boolean',\n      bCastShadows: 'Boolean',\n    },\n  },\n  BCD_PointLight: {\n    version: 1,\n    properties: {\n      bMatchBrickShape: 'Boolean',\n      Brightness: 'Float',\n      Radius: 'Float',\n      Color: 'Color',\n      bUseBrickColor: 'Boolean',\n      bCastShadows: 'Boolean',\n    },\n  },\n  BCD_ItemSpawn: {\n    version: 1,\n    properties: {\n      PickupClass: 'Class',\n      bPickupEnabled: 'Boolean',\n      bPickupRespawnOnMinigameReset: 'Boolean',\n      PickupMinigameResetRespawnDelay: 'Float',\n      bPickupAutoDisableOnPickup: 'Boolean',\n      PickupRespawnTime: 'Float',\n      PickupOffsetDirection: 'Byte',\n      PickupOffsetDistance: 'Float',\n      PickupRotation: 'Rotator',\n      PickupScale: 'Float',\n      bPickupAnimationEnabled: 'Boolean',\n      PickupAnimationAxis: 'Byte',\n      bPickupAnimationAxisLocal: 'Boolean',\n      PickupSpinSpeed: 'Float',\n      PickupBobSpeed: 'Float',\n      PickupBobHeight: 'Float',\n      PickupAnimationPhase: 'Float',\n    },\n  },\n  BCD_Interact: {\n    version: 1,\n    properties: {\n      bPlayInteractSound: 'Boolean',\n      Message: 'String',\n      ConsoleTag: 'String',\n    },\n  },\n  BCD_AudioEmitter: {\n    version: 1,\n    properties: {\n      AudioDescriptor: 'Object',\n      VolumeMultiplier: 'Float',\n      PitchMultiplier: 'Float',\n      InnerRadius: 'Float',\n      MaxDistance: 'Float',\n      bSpatialization: 'Boolean',\n    },\n  },\n  Component_Internal_Rerouter: {\n    version: 1,\n    properties: {},\n  },\n  BrickComponentType_Internal_ReadBrickGrid: {\n    version: 1,\n    properties: {},\n  },\n  BrickComponentType_WireGraphPseudo_BufferSeconds: {\n    version: 1,\n    properties: {\n      SecondsToWait: 'Float',\n      ZeroSecondsToWait: 'Float',\n      CurrentTime: 'Float',\n      Input: 'WireGraphVariant',\n      Output: 'WireGraphVariant',\n      Buffered: 'WireGraphVariant',\n      Queued: 'WireGraphVariant',\n      bHasQueued: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraphPseudo_BufferTicks: {\n    version: 1,\n    properties: {\n      TicksToWait: 'Integer',\n      ZeroTicksToWait: 'Integer',\n      CurrentTicks: 'Integer',\n      Input: 'WireGraphVariant',\n      Output: 'WireGraphVariant',\n      Buffered: 'WireGraphVariant',\n      Queued: 'WireGraphVariant',\n      bHasQueued: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraphPseudo_Const: {\n    version: 1,\n    properties: {\n      Value: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseAND: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNAND: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNOT: {\n    version: 1,\n    properties: {\n      Input: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseShiftRight: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseXOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_Ceil: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphVariant',\n      InputB: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareGreater: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareLess: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareLessOrEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareNotEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphVariant',\n      InputB: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_Floor: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalAND: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNAND: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNOT: {\n    version: 1,\n    properties: {\n      bInput: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalXOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathAdd: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathBlend: {\n    version: 1,\n\n    properties: {\n      Blend: 'Double',\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathDivide: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathModulo: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathModuloFloored: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathMultiply: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathSubtract: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponent_WireGraph_Expr_EdgeDetector: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n      bPulseOnRisingEdge: 'Boolean',\n      bPulseOnFallingEdge: 'Boolean',\n    },\n  },\n};\n\nexport default function writeBrs(\n  save: WriteSaveObject,\n  options: WriteOptions = {}\n) {\n  if (typeof save !== 'object') {\n    throw new Error('Expected save to be an object');\n  }\n\n  if (!Array.isArray(save.bricks) || save.bricks.length === 0) {\n    throw new Error('Expected save to have bricks field');\n  }\n\n  if (save.bricks.length > MAX_INT) {\n    throw new Error('Brick count out of range');\n  }\n\n  // compression is disabled by default\n  const compress = options.compress ? write.compressed : write.uncompressed;\n\n  // Convert from BGRA to RGBA\n  const rgba = ([r, g, b, a]: number[]) => new Uint8Array([b, g, r, a]);\n\n  // stored brick indices from components on the bricks\n  const componentBrickOwnership: { [component_name: string]: number[] } = {};\n\n  const numColors = Math.max(save.colors?.length ?? 0, 2);\n  const numAssets = Math.max(save.brick_assets?.length ?? 0, 2);\n  const numMats = Math.max(save.materials?.length ?? 0, 2);\n  const numPhysMats = Math.max(save.physical_materials?.length ?? 0, 2);\n\n  if (save.preview && !Array.isArray(save.preview))\n    throw new Error('Expected preview to be an array');\n\n  let componentMap: Record<string, number> = {};\n  let componentCount = 0;\n\n  const buff = concat(\n    // Write magic bytes\n    MAGIC,\n    write.u16(LATEST_VERSION),\n    write.i32(save.game_version ?? 0),\n\n    // Header 1\n    compress(\n      write.string(save.map ?? 'Unknown'),\n      write.string(save.author?.name ?? 'Unknown'),\n      write.string(save.description ?? ''),\n      write.uuid(save.author?.id ?? DEFAULT_UUID),\n      concat(\n        write.string(save.host?.name ?? 'Unknown'),\n        write.uuid(save.host?.id ?? DEFAULT_UUID)\n      ),\n      new Uint8Array(\n        save.save_time &&\n        (Array.isArray(save.save_time) ||\n          save.save_time instanceof Uint8Array) &&\n        save.save_time.length === 8\n          ? save.save_time\n          : [0, 0, 0, 0, 0, 0, 0, 0]\n      ),\n      write.i32(save.bricks.length)\n    ),\n\n    // Header 2\n    compress(\n      write.array(save.mods ?? [], write.string),\n      write.array(save.brick_assets ?? ['PB_DefaultBrick'], write.string),\n      write.array(save.colors ?? [], rgba),\n      write.array(save.materials ?? ['BMC_Plastic'], write.string),\n      write.array(\n        save.brick_owners ?? [],\n        ({\n          id = DEFAULT_UUID,\n          name = 'Unknown',\n          display_name = 'Unknown',\n          bricks = 0,\n        }: Partial<Owner>) =>\n          concat(\n            write.uuid(id),\n            write.string(name),\n            write.string(display_name),\n            write.i32(bricks)\n          )\n      ),\n      write.array(save.physical_materials ?? ['BPMC_Default'], write.string)\n    ),\n\n    // write the save preview if it exists\n    concat(\n      new Uint8Array([save.preview ? 1 : 0]),\n      save.preview ? write.i32(save.preview.length) : EMPTY_ARR, // <- Sorry @Uxie https://i.imgur.com/hSRxdbf.png\n      save.preview ?? EMPTY_ARR\n    ),\n\n    // Bricks\n    compress(\n      write\n        .bits()\n        .each(save.bricks, function (brick: Brick, i) {\n          if (typeof brick !== 'object')\n            throw new Error(`Expected save.bricks[${i}] to be an object`);\n\n          if (!Array.isArray(brick.size) || brick.size.length !== 3)\n            throw new Error(\n              `Expected save.bricks[${i}].size to be an array of length 3`\n            );\n\n          if (!Array.isArray(brick.position) || brick.position.length !== 3)\n            throw new Error(\n              `Expected save.bricks[${i}].position to be an array of length 3`\n            );\n\n          this.align();\n          this.int(brick.asset_name_index ?? 0, numAssets);\n\n          const isNonProcedural =\n            brick.size === null || isEqual(brick.size, [0, 0, 0]);\n          this.bit(!isNonProcedural);\n          if (!isNonProcedural) {\n            brick.size.map(s => this.uint_packed(s >= 0 ? s : 1));\n          }\n          brick.position.map(s => this.int_packed(s));\n          this.int(((brick.direction ?? 4) << 2) | (brick.rotation ?? 0), 24);\n\n          if (typeof brick.collision === 'boolean') {\n            this.bit(brick.collision);\n            this.bit(brick.collision);\n            this.bit(brick.collision);\n            this.bit(true);\n            this.bit(brick.collision);\n          } else {\n            this.bit(brick.collision?.player ?? true);\n            this.bit(brick.collision?.weapon ?? true);\n            this.bit(brick.collision?.interaction ?? true);\n            this.bit(brick.collision?.tool ?? true);\n            this.bit(brick.collision?.physics ?? true);\n          }\n\n          this.bit(brick.visibility ?? true);\n          this.int(brick.material_index ?? 0, numMats);\n          this.int(brick.physical_index ?? 0, numPhysMats);\n          this.int(brick.material_intensity ?? 5, 11);\n\n          if (typeof brick.color === 'number') {\n            this.bit(false);\n            this.int(brick.color, numColors);\n          } else {\n            this.bit(true);\n            if (\n              brick.color &&\n              (!Array.isArray(brick.color) || brick.color.length < 3)\n            )\n              throw new Error(\n                `Expected save.bricks[${i}].color to be an array of at least length 3`\n              );\n            this.bytes(\n              new Uint8Array(brick.color?.slice(0, 3) ?? [255, 255, 255])\n            );\n          }\n\n          this.uint_packed(brick.owner_index >= 0 ? brick.owner_index : 0);\n\n          // add all the brick indices to the components list\n          for (const key in brick.components ?? {}) {\n            componentBrickOwnership[key] ??= [];\n            componentBrickOwnership[key].push(i);\n          }\n        })\n        .finish()\n    ),\n\n    // write components section\n    compress(\n      write.array(\n        Object.keys(save.components ?? DEFAULT_COMPONENTS).filter(\n          name => componentBrickOwnership[name]\n        ),\n        name =>\n          concat(\n            write.string(name),\n            write\n              .bits()\n              .self(function () {\n                const component =\n                  save.components?.[name] ?? DEFAULT_COMPONENTS[name];\n                const brick_indices = componentBrickOwnership[name];\n                const properties = Object.entries(component.properties);\n\n                if (!(name in componentMap)) {\n                  componentMap[name] = componentCount;\n                  componentCount++;\n                }\n\n                // write version\n                this.bytes(write.i32(component.version));\n\n                // write bricks;\n                this.array(brick_indices, i => {\n                  this.int(i, Math.max(save.bricks.length, 2));\n                });\n\n                // write properties\n                this.array(properties, ([name, type]) => {\n                  this.string(name);\n                  this.string(type);\n                });\n\n                // read brick indices\n                for (const i of brick_indices) {\n                  for (const [prop, type] of properties) {\n                    if (!(prop in (save.bricks[i].components?.[name] ?? {}))) {\n                      throw new Error(\n                        `Expected save.bricks[${i}].components[${name}] to have property '${prop}' of type '${type}'`\n                      );\n                    }\n                    this.unreal(type, save.bricks[i].components[name][prop]);\n                  }\n                }\n                this.align();\n              })\n              .finishSection()\n          )\n      )\n    ),\n\n    compress(\n      write\n        .bits()\n        .self(function () {\n          const intMax = 4294967295;\n          if (\n            !save.wires ||\n            !Array.isArray(save.wires) ||\n            save.wires.length === 0\n          ) {\n            // if no wires, write\n            this.int(0, intMax); // u32 max\n            return;\n          }\n\n          this.int(save.wires.length, intMax);\n          for (const wire of save.wires) {\n            if (typeof wire !== 'object')\n              throw new Error('Expected save.wires to be an array of objects');\n\n            if (\n              !(\n                wire.source &&\n                typeof wire.source === 'object' &&\n                typeof wire.source.brick_index === 'number' &&\n                typeof wire.source.component === 'string' &&\n                typeof wire.source.port === 'string'\n              )\n            ) {\n              throw new Error(\n                'Expected save.wires[i].source to be an object with brick_index, component, and port properties'\n              );\n            }\n\n            if (\n              !(\n                wire.target &&\n                typeof wire.target === 'object' &&\n                typeof wire.target.brick_index === 'number' &&\n                typeof wire.target.component === 'string' &&\n                typeof wire.target.port === 'string'\n              )\n            ) {\n              throw new Error(\n                'Expected save.wires[i].target to be an object with brick_index, component, and port properties'\n              );\n            }\n\n            if (!(wire.source.component in componentMap))\n              throw new Error(\n                `Unknown component '${wire.source.component}' in wire source`\n              );\n            if (!(wire.target.component in componentMap))\n              throw new Error(\n                `Unknown component '${wire.target.component}' in wire target`\n              );\n\n            this.int(wire.source.brick_index, save.bricks.length);\n            this.int(componentMap[wire.source.component], componentCount);\n            this.string(wire.source.port);\n\n            this.int(wire.target.brick_index, save.bricks.length);\n            this.int(componentMap[wire.target.component], componentCount);\n            this.string(wire.target.port);\n\n            this.bit(false); // \"skip prev bit that was in use lmao\"\n            this.align();\n          }\n        })\n        .finish()\n    )\n  );\n  return buff;\n}\n","export interface BRSBytes extends Uint8Array {\n  brsOffset: number;\n}\n\ntype Modify<T, R> = Omit<T, keyof R> & R;\n\nexport type Bytes = Uint8Array | BRSBytes;\nexport type Uuid = string;\n\nexport type UnrealClass = string;\nexport type UnrealObject = string;\nexport type UnrealBoolean = boolean;\nexport type UnrealFloat = number;\nexport type UnrealInteger = number;\nexport type UnrealInteger64 = number;\nexport type UnrealColor = [number, number, number, number];\nexport type UnrealByte = number;\nexport type UnrealRotator = [number, number, number];\nexport type Vector3d = Vector;\nexport type IntVector = Vector;\nexport type UnrealString = string;\nexport type WireGraphVariant =\n  | { number: number }\n  | { integer: number }\n  | { bool: boolean }\n  | { exec: true }\n  | { object: true };\nexport type BRInventoryEntryPlan = string;\nexport type UnrealType =\n  | UnrealClass\n  | UnrealObject\n  | UnrealBoolean\n  | UnrealFloat\n  | UnrealColor\n  | UnrealByte\n  | UnrealRotator\n  | UnrealString\n  | WireGraphVariant\n  | UnrealInteger64\n  | Vector3d\n  | IntVector\n  | BRInventoryEntryPlan;\n\ntype UnrealTypeFromString<T> = T extends 'Class'\n  ? UnrealClass\n  : T extends 'Object'\n  ? UnrealObject\n  : T extends 'Boolean'\n  ? UnrealBoolean\n  : T extends 'Float'\n  ? UnrealFloat\n  : T extends 'Color'\n  ? UnrealColor\n  : T extends 'Byte'\n  ? UnrealByte\n  : T extends 'Rotator'\n  ? UnrealRotator\n  : T extends 'Rotator3d'\n  ? UnrealRotator\n  : T extends 'Vector3d'\n  ? Vector3d\n  : T extends 'IntVector'\n  ? IntVector\n  : T extends 'String'\n  ? UnrealString\n  : T extends 'BRInventoryEntryPlan'\n  ? BRInventoryEntryPlan\n  : T extends 'WireGraphVariant'\n  ? WireGraphVariant\n  : T extends 'WireGraphPrimMathVariant'\n  ? WireGraphVariant\n  : T extends 'Integer'\n  ? UnrealInteger\n  : T extends 'Integer64'\n  ? UnrealInteger64\n  : UnrealType;\n\nexport interface User {\n  id: Uuid;\n  name: string;\n}\n\nexport interface LegacyOwner extends User {\n  bricks: number;\n}\n\nexport interface Owner extends LegacyOwner {\n  display_name: string;\n}\n\nexport enum Direction {\n  XPositive,\n  XNegative,\n  YPositive,\n  YNegative,\n  ZPositive,\n  ZNegative,\n}\n\nexport enum Rotation {\n  Deg0,\n  Deg90,\n  Deg180,\n  Deg270,\n}\n\nexport type ColorRgb = [number, number, number];\n\nexport interface Collision {\n  player: boolean;\n  weapon: boolean;\n  interaction: boolean;\n  tool: boolean;\n  physics: boolean;\n}\n\nexport interface AppliedComponent {\n  [property: string]: UnrealType;\n}\n\nexport interface UnknownComponents {\n  [component_name: string]: {\n    version: number;\n    brick_indices?: number[];\n    properties: { [property: string]: string };\n  };\n}\n\nexport type KnownComponents = {\n  BCD_SpotLight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator';\n      InnerConeAngle: 'Float';\n      OuterConeAngle: 'Float';\n      Brightness: 'Float';\n      Radius: 'Float';\n      Color: 'Color';\n      bUseBrickColor: 'Boolean';\n      bCastShadows: 'Boolean';\n    };\n  };\n  BCD_PointLight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bMatchBrickShape: 'Boolean';\n      Brightness: 'Float';\n      Radius: 'Float';\n      Color: 'Color';\n      bUseBrickColor: 'Boolean';\n      bCastShadows: 'Boolean';\n    };\n  };\n  BCD_ItemSpawn: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PickupClass: 'Class';\n      bPickupEnabled: 'Boolean';\n      bPickupRespawnOnMinigameReset: 'Boolean';\n      PickupMinigameResetRespawnDelay: 'Float';\n      bPickupAutoDisableOnPickup: 'Boolean';\n      PickupRespawnTime: 'Float';\n      PickupOffsetDirection: 'Byte';\n      PickupOffsetDistance: 'Float';\n      PickupRotation: 'Rotator';\n      PickupScale: 'Float';\n      bPickupAnimationEnabled: 'Boolean';\n      PickupAnimationAxis: 'Byte';\n      bPickupAnimationAxisLocal: 'Boolean';\n      PickupSpinSpeed: 'Float';\n      PickupBobSpeed: 'Float';\n      PickupBobHeight: 'Float';\n      PickupAnimationPhase: 'Float';\n    };\n  };\n  BCD_Interact: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bPlayInteractSound: 'Boolean';\n      Message: 'String';\n      ConsoleTag: 'String';\n    };\n  };\n  BCD_AudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n    };\n  };\n  Component_AudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n      FocusAzimuth: 'Float';\n      NonFocusAzimuth: 'Float';\n      NonFocusVolumeAttenuation: 'Float';\n    };\n  };\n  Component_BotSpawn: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RespawnTime: 'Float';\n      CorpseTimeout: 'Float';\n      GunSkill: 'Float';\n      Agression: 'Float';\n      ReactionTime: 'Float';\n      MovementRandomness: 'Float';\n      Jumpyness: 'Float';\n      MovementAmount: 'Float';\n      AttackMovementAmount: 'Float';\n      AggroRange: 'Float';\n      bCanJump: 'Boolean';\n      bBackVision: 'Boolean';\n      bVisionRaycasting: 'Boolean';\n      bCanTargetPlayers: 'Boolean';\n      bCanTargetBots: 'Boolean';\n      MoveTarget: 'Vector3d';\n      BotWeapon: 'Class';\n    };\n  };\n  Component_CheckPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bRotatePlayerGravityOnSpawn: 'Boolean';\n    };\n  };\n  Component_Damage: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Message: 'String';\n      ConsoleTag: 'String';\n    };\n  };\n  Component_GoalPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_InputSplitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_OneShotAudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n      bEnableRepeat: 'Boolean';\n      RepeatTime: 'Float';\n      RepeatVariance: 'Float';\n    };\n  };\n  Component_SpawnPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bRotatePlayerGravityOnSpawn: 'Boolean';\n      bEnable: 'Boolean';\n    };\n  };\n  Component_Target: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      OnTime: 'Float';\n    };\n  };\n  Component_Internal_AnimatedButton: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PressSound: 'Object';\n      ReleaseSound: 'Object';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_AnimatedSwitch: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      InteractSound: 'Object';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_AttachedZone: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      ZoneStartDistance: 'Integer';\n      ZoneEndDistance: 'Integer';\n      bIsBuildingZone: 'Boolean';\n      bIsLooseZone: 'Boolean';\n      bIsShareZone: 'Boolean';\n    };\n  };\n  Component_Internal_Bearing: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Joint_Wheel: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      DriveSpeed: 'Float';\n      DrivePower: 'Float';\n      bSteerEnabled: 'Boolean';\n      Steer: 'Float';\n      SteerLimitDegree: 'Float';\n      SteerPower: 'Float';\n      bSuspensionEnabled: 'Boolean';\n      SuspensionStiffness: 'Float';\n      SuspensionDamping: 'Float';\n      JointDistance: 'Integer';\n      bDriveWhenNotAttachedToEngine: 'Boolean';\n      bCanBrake: 'Boolean';\n      bAllowEngineSteerCorrect: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Motor: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      Speed: 'Float';\n      Power: 'Float';\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_MotorSlider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      Speed: 'Float';\n      Power: 'Float';\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Rerouter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_Internal_Seat: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bIsOccupied: 'Boolean';\n      ExitOffset: 'IntVector';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_Servo: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      TargetAngle: 'Float';\n      Power: 'Float';\n      ActiveDamping: 'Float';\n      ForceLimit: 'Float';\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_ServoSlider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      TargetPosition: 'Float';\n      Power: 'Float';\n      TopSpeed: 'Float';\n      Exponent: 'Float';\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Slider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Socket: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_Internal_WeightBrick: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Mass: 'Float';\n      MassSize: 'IntVector';\n      MassOffset: 'IntVector';\n    };\n  };\n  Component_Internal_WheelEngine: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      bEnableManualControl: 'Boolean';\n      ManualInput_Drive: 'Float';\n      ManualInput_Steer: 'Float';\n      bManualInput_Brake: 'Boolean';\n      CustomMass: 'Float';\n      CustomMassVerticalOffset: 'Float';\n      DriveInterpSpeed: 'Float';\n      DriveSpeed: 'Float';\n      DriveAcceleratingPowerMultiplier: 'Float';\n      DriveBrakingPowerMultiplier: 'Float';\n      DriveDampingMultiplier: 'Float';\n      SteerPowerMultiplier: 'Float';\n      SteerInterpSpeed: 'Float';\n      SteerLimitDegree: 'Float';\n      CenterOfSteering: 'Float';\n      bTankSteering: 'Boolean';\n      TankSteerSpeedMultiplier: 'Float';\n      WaterDriveForce: 'Float';\n      WaterSteeringForce: 'Float';\n      AudioDescriptor: 'Object';\n    };\n  };\n  Component_WireGraph_PlayAudioAt: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n    };\n  };\n  Component_WireGraph_SetInventoryEntry: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Slot: 'Integer';\n      EntryPlan: 'BRInventoryEntryPlan';\n    };\n  };\n  BrickComponentType_Internal_CharacterZoneEvent_Entered: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_CharacterZoneEvent_Left: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ReadBrickGrid: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_TeleportDestination: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ZoneEvent_BrickChanged: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ZoneEvent_BrickRemoved: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraphPseudo_BufferSeconds: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      SecondsToWait: 'Float';\n      ZeroSecondsToWait: 'Float';\n      CurrentTime: 'Float';\n      Input: 'WireGraphVariant';\n      Output: 'WireGraphVariant';\n      Buffered: 'WireGraphVariant';\n      Queued: 'WireGraphVariant';\n      bHasQueued: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraphPseudo_BufferTicks: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      TicksToWait: 'Integer';\n      ZeroTicksToWait: 'Integer';\n      CurrentTicks: 'Integer';\n      Input: 'WireGraphVariant';\n      Output: 'WireGraphVariant';\n      Buffered: 'WireGraphVariant';\n      Queued: 'WireGraphVariant';\n      bHasQueued: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraphPseudo_Var: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Branch: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Character_SetTempPermission: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PermissionTagStr: 'String';\n      bPermissionEnable: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Character_ShowHint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      HintTitle: 'String';\n      HintText: 'String';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_AddLocationRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_AddVelocity: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_RelativeTeleport: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetGravityDirection: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetLocation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetLocationRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetVelocity: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_Teleport: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Union: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Var_Get: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Var_Increment: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Var_Set: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNOT: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseShiftRight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseXOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_Ceil: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphVariant';\n      InputB: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareGreater: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareLess: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareLessOrEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareNotEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphVariant';\n      InputB: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_Floor: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNOT: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInput: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalXOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathAdd: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathBlend: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Blend: 'Double';\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathDivide: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathModulo: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathModuloFloored: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathMultiply: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathSubtract: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Fake_Gamemode_RoundEndEvent: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RoundNumber: 'Integer';\n    };\n  };\n  BrickComponentType_WireGraph_Fake_Gamemode_RoundStartEvent: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RoundNumber: 'Integer';\n    };\n  };\n  BrickComponent_WireGraph_Expr_EdgeDetector: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n      bPulseOnRisingEdge: 'Boolean';\n      bPulseOnFallingEdge: 'Boolean';\n    };\n  };\n};\n\nexport interface DefinedComponents\n  extends UnknownComponents,\n    Partial<KnownComponents> {}\n\nexport type Components<C extends DefinedComponents> = {\n  [T in keyof C]: {\n    [V in keyof C[T]['properties']]: UnrealTypeFromString<\n      C[T]['properties'][V]\n    >;\n  };\n} & { [component_name: string]: AppliedComponent };\n\nexport type Vector = [number, number, number];\n\nexport type WirePort = {\n  brick_index: number;\n  component: string;\n  port: string;\n};\n\nexport type Wire = {\n  source: WirePort;\n  target: WirePort;\n};\n\nexport interface BrickV1 {\n  asset_name_index: number;\n  size: Vector;\n  position: Vector;\n  direction: Direction;\n  rotation: Rotation;\n  collision: boolean;\n  visibility: boolean;\n  color: UnrealColor | number;\n}\n\nexport interface BrickV2 extends BrickV1 {\n  material_index: number;\n}\n\nexport interface BrickV3 extends BrickV2 {\n  owner_index: number;\n}\n\nexport interface BrickV8 extends BrickV3 {\n  components: Components<DefinedComponents>;\n}\n\nexport type BrickV9 = Modify<\n  BrickV8,\n  {\n    physical_index: number;\n    material_intensity: number;\n    color: ColorRgb | number;\n  }\n>;\n\nexport type BrickV10 = Modify<\n  BrickV9,\n  {\n    collision: Collision;\n  }\n>;\n\nexport interface BrsV1 {\n  version: 1;\n  map: string;\n  author: User;\n  description: string;\n  brick_count: number;\n  mods: string[];\n  brick_assets: string[];\n  colors: UnrealColor[];\n  bricks: BrickV1[];\n}\n\nexport type BrsV2 = Modify<\n  BrsV1,\n  {\n    version: 2;\n    materials: string[];\n    bricks: BrickV2[];\n  }\n>;\n\nexport type BrsV3 = Modify<\n  BrsV2,\n  {\n    version: 3;\n    brick_owners: User[];\n    bricks: BrickV3[];\n  }\n>;\n\nexport type BrsV4 = Modify<\n  BrsV3,\n  {\n    version: 4;\n    save_time: Uint8Array;\n  }\n>;\n\n// not sure what part of 8 makes up 5-7 but nobody should have any saves in those versions\n\nexport type BrsV8 = Modify<\n  BrsV4,\n  {\n    version: 8;\n    host: User;\n    brick_owners: LegacyOwner[];\n    preview?: Bytes;\n    game_version: number;\n    bricks: BrickV8[];\n    components: DefinedComponents;\n  }\n>;\n\nexport type BrsV9 = Modify<\n  BrsV8,\n  {\n    version: 9;\n    physical_materials: string[];\n    bricks: BrickV9[];\n  }\n>;\n\nexport type BrsV10 = Modify<\n  BrsV9,\n  {\n    version: 10;\n    bricks: BrickV10[];\n  }\n>;\n\nexport type BrsV14 = Modify<\n  BrsV10,\n  {\n    version: 14;\n    wires: Wire[];\n  }\n>;\n\n// a save read from a file\nexport type ReadSaveObject =\n  | BrsV1\n  | BrsV2\n  | BrsV3\n  | BrsV4\n  | BrsV8\n  | BrsV9\n  | BrsV10\n  | BrsV14;\n\n// a brick a user provides\nexport interface Brick {\n  asset_name_index?: number;\n  size: Vector;\n  position: Vector;\n  direction?: Direction;\n  rotation?: Rotation;\n  collision?: boolean | Partial<Collision>;\n  visibility?: boolean;\n  material_index?: number;\n  physical_index?: number;\n  material_intensity?: number;\n  color?: ColorRgb | number | UnrealColor | number[];\n  owner_index?: number;\n  components?: Components<DefinedComponents>;\n}\n\n// save a user can write\nexport interface WriteSaveObject {\n  game_version?: number;\n  map?: string;\n  description?: string;\n  author?: Partial<User>;\n  host?: Partial<User>;\n  mods?: string[];\n  brick_assets?: string[];\n  colors?: UnrealColor[];\n  materials?: string[];\n  brick_owners?: Partial<Owner>[];\n  physical_materials?: string[];\n  preview?: Bytes;\n  bricks: Brick[];\n  save_time?: ArrayLike<number>;\n  components?: DefinedComponents;\n  wires?: Wire[];\n}\n\nexport interface ReadOptions {\n  bricks?: boolean;\n  preview?: boolean;\n}\n\nexport interface WriteOptions {\n  compress?: boolean;\n}\n","import read from './read';\nimport write from './write';\nimport * as utils from './utils';\nimport * as constants from './constants';\nimport * as types from './types';\nexport * from './types';\n\n// https://i.imgur.com/cv1fDWs.png\nconst brs = { read, write, utils, constants, types };\nexport { read, write, utils, constants, types };\nexport default brs;\n\nif (typeof window !== 'undefined') {\n  (window as any).BRS = brs;\n}\n","import { MAGIC } from './constants';\nimport readBrsV1 from './read.v1';\nimport readBrsV10 from './read.v10';\nimport readBrsV14 from './read.v14';\nimport readBrsV2 from './read.v2';\nimport readBrsV3 from './read.v3';\nimport readBrsV4 from './read.v4';\nimport readBrsV8 from './read.v8';\nimport readBrsV9 from './read.v9';\nimport { BRSBytes, ReadOptions, ReadSaveObject } from './types';\nimport { read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrs(\n  rawBytes: Uint8Array,\n  options: ReadOptions = {}\n): ReadSaveObject {\n  if (typeof options !== 'object') throw new Error('Invalid options');\n\n  // default enable brick reading\n  if (typeof options.bricks !== 'boolean') options.bricks = true;\n\n  // default disable preview (a5 only)\n  if (typeof options.preview !== 'boolean') options.preview = false;\n\n  // Determine if the first 3 bytes are equal to the Brickadia save magic bytes\n  if (\n    rawBytes[0] !== MAGIC[0] ||\n    rawBytes[1] !== MAGIC[1] ||\n    rawBytes[2] !== MAGIC[2]\n  ) {\n    throw new Error('Invalid starting bytes');\n  }\n\n  const brsData = rawBytes as BRSBytes;\n  brsData.brsOffset = 3;\n\n  // Determine if the file version supported\n  const version = read.u16(brsData);\n  switch (version) {\n    case 1:\n      return readBrsV1(brsData, options);\n    case 2:\n      return readBrsV2(brsData, options);\n    case 3:\n      return readBrsV3(brsData, options);\n    case 4:\n      return readBrsV4(brsData, options);\n    case 8:\n      return readBrsV8(brsData, options);\n    case 9:\n      return readBrsV9(brsData, options);\n    case 10:\n      return readBrsV10(brsData, options);\n    case 14:\n      return readBrsV14(brsData, options);\n    default:\n      throw new Error('Unsupported version ' + version);\n  }\n}\n","import {\n  BrickV1,\n  BRSBytes,\n  BrsV1,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV1(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV1 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n\n  // Read in bricks\n  let bricks: BrickV1[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        collision,\n        position,\n        direction,\n        rotation,\n        visibility,\n        color,\n      };\n    }\n  }\n\n  return {\n    version: 1,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  BrickV2,\n  BRSBytes,\n  BrsV2,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV2(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV2 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  // Read in bricks\n  let bricks: BrickV2[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n      };\n    }\n  }\n\n  return {\n    version: 2,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  BrickV3,\n  BRSBytes,\n  BrsV3,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV3(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV3 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners: User[] = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n  }));\n\n  // Read in bricks\n  let bricks: BrickV3[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n      };\n    }\n  }\n\n  return {\n    version: 3,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  BrickV3,\n  BRSBytes,\n  BrsV4,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV4(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV4 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n  }));\n\n  // Read in bricks\n  let bricks: BrickV3[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n      };\n    }\n  }\n\n  return {\n    version: 4,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    bricks,\n    brick_count,\n    save_time,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV8,\n  BRSBytes,\n  BrsV8,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV8(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV8 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV8[] = [];\n  const components: BrsV8['components'] = {};\n\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 8,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV9,\n  BRSBytes,\n  BrsV9,\n  ColorRgb,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV9(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV9 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV9[] = [];\n  const components: BrsV9['components'] = {};\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color: color as ColorRgb | number,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 9,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV10,\n  BRSBytes,\n  BrsV10,\n  Collision,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV10(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV10 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV10[] = [];\n  const components: BrsV10['components'] = {};\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision: Collision = {\n        player: brickBits.bit(),\n        weapon: brickBits.bit(),\n        interaction: brickBits.bit(),\n        tool: brickBits.bit(),\n        physics: false, // v10 does not have physics collision\n      };\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision: collision as Collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 10,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV10,\n  BRSBytes,\n  BrsV14,\n  Collision,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n  Wire,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV14(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV14 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    display_name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV10[] = [];\n  const components: BrsV14['components'] = {};\n  const wires: Wire[] = [];\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision: Collision = {\n        player: brickBits.bit(),\n        weapon: brickBits.bit(),\n        interaction: brickBits.bit(),\n        tool: brickBits.bit(),\n        physics: brickBits.bit(),\n      };\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision: collision as Collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const wiresData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n    const componentIndex: string[] = [];\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      if (!(name in components)) {\n        componentIndex.push(name);\n      }\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n\n    const numComponents = Math.max(componentIndex.length, 2);\n\n    {\n      const bits = read.bits(wiresData);\n\n      const numWires = bits.int(4294967295); // u32 max\n      for (let i = 0; i < numWires; i++) {\n        const srcBrick = bits.int(numBricks);\n        const srcComponentIndex = bits.int(numComponents);\n        const srcPort = bits.string();\n\n        const dstBrick = bits.int(numBricks);\n        const dstComponentIndex = bits.int(numComponents);\n        const dstPort = bits.string();\n\n        bits.bit(); // \"skip prev bit that was in use lmao\"\n        bits.align();\n\n        wires.push({\n          source: {\n            brick_index: srcBrick,\n            component: componentIndex[srcComponentIndex],\n            port: srcPort,\n          },\n          target: {\n            brick_index: dstBrick,\n            component: componentIndex[dstComponentIndex],\n            port: dstPort,\n          },\n        });\n      }\n    }\n  }\n\n  return {\n    version: 14,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n    wires,\n  };\n}\n"],"names":["zlib_inflate","utils","strings","c","msg","ZStream","GZheader","toString","Object","prototype","Inflate","options","this","assign","chunkSize","windowBits","to","opt","raw","err","ended","chunks","strm","avail_out","status","inflateInit2","Z_OK","Error","header","inflateGetHeader","dictionary","string2buf","call","Uint8Array","inflateSetDictionary","inflate","input","inflator","push","result","data","mode","_mode","next_out_utf8","tail","utf8str","allowBufError","Z_FINISH","Z_NO_FLUSH","binstring2buf","next_in","avail_in","length","output","Buf8","next_out","Z_NEED_DICT","Z_BUF_ERROR","Z_STREAM_END","onEnd","Z_SYNC_FLUSH","utf8border","buf2string","arraySet","onData","shrinkBuf","inflateEnd","chunk","join","flattenChunks","exports","inflateRaw","ungzip","module","adler","buf","len","pos","s1","s2","n","start","state","_in","last","_out","beg","end","dmax","wsize","whave","wnext","s_window","hold","bits","lcode","dcode","lmask","dmask","here","op","dist","from","from_source","window","lencode","distcode","lenbits","distbits","top","dolen","sane","zlib_deflate","Deflate","level","method","memLevel","strategy","gzip","deflateInit2","deflateSetHeader","dict","deflateSetDictionary","_dict_set","deflate","deflator","buf2binstring","deflateEnd","deflateRaw","configuration_table","trees","adler32","crc32","Z_STREAM_ERROR","MAX_MATCH","MIN_LOOKAHEAD","HCRC_STATE","BUSY_STATE","FINISH_STATE","errorCode","rank","f","zero","flush_pending","s","pending","pending_buf","pending_out","total_out","flush_block_only","_tr_flush_block","block_start","strstart","put_byte","b","putShortMSB","read_buf","size","wrap","total_in","longest_match","cur_match","match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","limit","w_size","_win","wmask","w_mask","prev","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","p","m","more","str","_w_size","window_size","hash_size","head","insert","ins_h","hash_shift","hash_mask","deflate_fast","flush","hash_head","bflush","match_length","_tr_tally","max_lazy_match","MIN_MATCH","last_lit","deflate_slow","max_insert","prev_match","match_available","Config","good_length","max_lazy","nice_length","max_chain","func","DeflateState","pending_buf_size","gzhead","gzindex","last_flush","w_bits","hash_bits","dyn_ltree","Buf16","HEAP_SIZE","dyn_dtree","bl_tree","l_desc","d_desc","bl_desc","bl_count","MAX_BITS","heap","heap_len","heap_max","depth","l_buf","lit_bufsize","d_buf","opt_len","static_len","matches","bi_buf","bi_valid","deflateResetKeep","data_type","_tr_init","deflateReset","ret","max_block_size","max_start","deflateInit","old_flush","val","text","hcrc","extra","name","comment","time","os","charCodeAt","bstate","deflate_huff","deflate_rle","_tr_align","_tr_stored_block","avail","next","tmpDict","dictLength","deflateInfo","xflags","extra_len","done","inflate_fast","inflate_table","TYPE","BAD","zswap32","q","InflateState","havedict","flags","check","total","wbits","offset","ncode","nlen","ndist","have","lens","work","lendyn","distdyn","back","was","inflateResetKeep","Buf32","inflateReset","inflateReset2","lenfix","distfix","virgin","fixedtables","sym","updatewindow","src","copy","inflateInit","put","left","here_bits","here_op","here_val","last_bits","last_op","last_val","opts","hbuf","order","inf_leave","Array","String","fromCharCode","inflateInfo","extra_lbits","extra_dbits","extra_blbits","bl_order","static_ltree","static_dtree","D_CODES","_dist_code","_length_code","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","put_short","w","send_bits","value","send_code","tree","bi_reverse","code","res","gen_codes","next_code","init_block","LITERALS","END_BLOCK","bi_windup","smaller","_n2","_m2","pqdownheap","k","v","j","compress_block","ltree","dtree","lc","lx","build_tree","desc","node","stree","h","xbits","base","overflow","gen_bitlen","scan_tree","curlen","prevlen","nextlen","count","max_count","min_count","REP_3_6","REPZ_3_10","REPZ_11_138","send_tree","static_init_done","stored_len","copy_block","LENGTH_CODES","L_CODES","tr_static_init","opt_lenb","static_lenb","max_blindex","black_mask","detect_data_type","BL_CODES","build_bl_tree","lcodes","dcodes","blcodes","send_all_trees","STATIC_TREES","bi_flush","pako","Z_PARTIAL_FLUSH","Z_FULL_FLUSH","Z_BLOCK","Z_TREES","Z_ERRNO","Z_DATA_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_BINARY","Z_TEXT","Z_UNKNOWN","Z_DEFLATED","TYPED_OK","Uint16Array","Int32Array","_has","obj","key","hasOwnProperty","sources","slice","arguments","source","shift","TypeError","subarray","fnTyped","dest","src_offs","dest_offs","set","i","l","fnUntyped","concat","apply","setTyped","on","crcTable","table","makeTable","crc","t","STR_APPLY_OK","STR_APPLY_UIA_OK","__","_utf8len","c2","m_pos","str_len","buf_len","max","out","c_len","utf16buf","lbase","lext","dbase","dext","type","lens_index","codes","table_index","incr","fill","low","mask","min","root","curr","drop","used","huff","base_index","MAXBITS","offs","extra_index","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","o","defineProperty","enumerable","get","prop","r","Symbol","toStringTag","MAGIC","LATEST_VERSION","MAX_INT","DEFAULT_UUID","hexTable","map","_","substr","bgra","g","a","isEqual","arrA","arrB","every","isBRSBytes","brsOffset","isCopy","bytes","arr","Math","floor","read_u16","littleEndian","read_i32","write_i32","num","reverse","read_string","raw_size","is_ucs2","fromCodePoint","strData","write_string","test","split","flatMap","BitReader","constructor","buffer","empty","bit","align","int","uint_packed","part","int_packed","bytesArr","array","fn","each","string","lenBytes","float","view","DataView","ArrayBuffer","setUint16","getFloat32","integer","getInt32","int64","getBigInt64","Number","double","getFloat64","wireGraphVariant","number","bool","exec","object","unreal","BitWriter","cur","bitNum","new_val","abs","finish","finishSection","floatArr","Float32Array","Int8Array","intArr","setBigInt64","BigInt","doubleArr","Float64Array","variant","JSON","stringify","self","bind","forEach","isArray","arrays","buffLen","reduce","sum","buff","read","u16","i32","compressed","uncompressedSize","compressedSize","uuid","toLowerCase","write","args","badCompress","uncompressed","parseInt","uuidParse","EMPTY_ARR","DEFAULT_COMPONENTS","BCD_SpotLight","version","properties","Rotation","InnerConeAngle","OuterConeAngle","Brightness","Radius","Color","bUseBrickColor","bCastShadows","BCD_PointLight","bMatchBrickShape","BCD_ItemSpawn","PickupClass","bPickupEnabled","bPickupRespawnOnMinigameReset","PickupMinigameResetRespawnDelay","bPickupAutoDisableOnPickup","PickupRespawnTime","PickupOffsetDirection","PickupOffsetDistance","PickupRotation","PickupScale","bPickupAnimationEnabled","PickupAnimationAxis","bPickupAnimationAxisLocal","PickupSpinSpeed","PickupBobSpeed","PickupBobHeight","PickupAnimationPhase","BCD_Interact","bPlayInteractSound","Message","ConsoleTag","BCD_AudioEmitter","AudioDescriptor","VolumeMultiplier","PitchMultiplier","InnerRadius","MaxDistance","bSpatialization","Component_Internal_Rerouter","BrickComponentType_Internal_ReadBrickGrid","BrickComponentType_WireGraphPseudo_BufferSeconds","SecondsToWait","ZeroSecondsToWait","CurrentTime","Input","Output","Buffered","Queued","bHasQueued","BrickComponentType_WireGraphPseudo_BufferTicks","TicksToWait","ZeroTicksToWait","CurrentTicks","BrickComponentType_WireGraphPseudo_Const","Value","BrickComponentType_WireGraph_Expr_BitwiseAND","InputA","InputB","BrickComponentType_WireGraph_Expr_BitwiseNAND","BrickComponentType_WireGraph_Expr_BitwiseNOR","BrickComponentType_WireGraph_Expr_BitwiseNOT","BrickComponentType_WireGraph_Expr_BitwiseOR","BrickComponentType_WireGraph_Expr_BitwiseShiftLeft","BrickComponentType_WireGraph_Expr_BitwiseShiftRight","BrickComponentType_WireGraph_Expr_BitwiseXOR","BrickComponentType_WireGraph_Expr_Ceil","BrickComponentType_WireGraph_Expr_CompareEqual","BrickComponentType_WireGraph_Expr_CompareGreater","BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual","BrickComponentType_WireGraph_Expr_CompareLess","BrickComponentType_WireGraph_Expr_CompareLessOrEqual","BrickComponentType_WireGraph_Expr_CompareNotEqual","BrickComponentType_WireGraph_Expr_Floor","BrickComponentType_WireGraph_Expr_LogicalAND","bInputA","bInputB","BrickComponentType_WireGraph_Expr_LogicalNAND","BrickComponentType_WireGraph_Expr_LogicalNOR","BrickComponentType_WireGraph_Expr_LogicalNOT","bInput","BrickComponentType_WireGraph_Expr_LogicalOR","BrickComponentType_WireGraph_Expr_LogicalXOR","BrickComponentType_WireGraph_Expr_MathAdd","BrickComponentType_WireGraph_Expr_MathBlend","Blend","BrickComponentType_WireGraph_Expr_MathDivide","BrickComponentType_WireGraph_Expr_MathModulo","BrickComponentType_WireGraph_Expr_MathModuloFloored","BrickComponentType_WireGraph_Expr_MathMultiply","BrickComponentType_WireGraph_Expr_MathSubtract","BrickComponent_WireGraph_Expr_EdgeDetector","bPulseOnRisingEdge","bPulseOnFallingEdge","Direction","brs","rawBytes","bricks","preview","brsData","header1Data","header2Data","author_name","description","author_id","brick_count","mods","brick_assets","colors","numAssets","brickData","brickBits","asset_name_index","position","orientation","direction","rotation","collision","visibility","color","author","id","readBrsV1","materials","material_index","readBrsV2","brick_owners","owner_index","readBrsV3","save_time","readBrsV4","game_version","host","components","numMats","componentData","numBricks","brick_indices","props","fromEntries","readBrsV8","physical_materials","numPhysMats","physical_index","material_intensity","readBrsV9","player","weapon","interaction","tool","physics","readBrsV10","display_name","wires","wiresData","componentIndex","numComponents","numWires","srcBrick","srcComponentIndex","srcPort","dstBrick","dstComponentIndex","dstPort","brick_index","component","port","target","readBrsV14","save","compress","componentBrickOwnership","numColors","componentMap","componentCount","brick","isNonProcedural","keys","filter","entries","intMax","wire","constants","types","BRS"],"sourceRoot":""}
+{"version":3,"file":"dist.js","names":["err","u8","u8"],"sources":["../src/brs/constants.ts","../node_modules/pako/dist/pako.mjs","../src/uuid.ts","../src/brs/utils.ts","../src/brs/read.v1.ts","../src/brs/read.v10.ts","../src/brs/read.v14.ts","../src/brs/read.v2.ts","../src/brs/read.v3.ts","../src/brs/read.v4.ts","../src/brs/read.v8.ts","../src/brs/read.v9.ts","../src/brs/read.ts","../src/brs/write.ts","../src/brs/types.ts","../src/brdb/bits.ts","../node_modules/@noble/hashes/utils.js","../node_modules/@noble/hashes/_md.js","../node_modules/@noble/hashes/_u64.js","../node_modules/@noble/hashes/_blake.js","../node_modules/@noble/hashes/blake2.js","../node_modules/@noble/hashes/blake3.js","../node_modules/fzstd/esm/index.mjs","../src/brdb/bytes.ts","../src/brdb/brz.ts","../src/brdb/catalog.ts","../src/brdb/componentDb.ts","../src/brdb/guid.ts","../src/brdb/pending.ts","../src/brdb/msgpack.ts","../src/brdb/schemaText.ts","../src/brdb/schemas.ts","../src/brdb/schema.ts","../src/brdb/world.ts","../src/brdb/reader.ts","../src/brdb/brdb.ts","../src/brdb/index.ts","../src/index.ts"],"sourcesContent":["import { Uuid } from './types';\n\nexport const MAGIC = new Uint8Array([66, 82, 83]); // BRS\nexport const LATEST_VERSION = 14;\nexport const MAX_INT = ~(1 << 31);\nexport const DEFAULT_UUID: Uuid = '00000000-0000-0000-0000-000000000000';\n","//#region src/zlib/trees.mjs\nvar Z_FIXED = 4;\nvar Z_BINARY = 0;\nvar Z_TEXT = 1;\nvar Z_UNKNOWN = 2;\nfunction zero$1(buf) {\n\tlet len = buf.length;\n\twhile (--len >= 0) buf[len] = 0;\n}\nvar STORED_BLOCK = 0;\nvar STATIC_TREES = 1;\nvar DYN_TREES = 2;\nvar LENGTH_CODES = 29;\nvar LITERALS = 256;\nvar L_CODES = 286;\nvar D_CODES = 30;\nvar BL_CODES = 19;\nvar HEAP_SIZE$1 = 573;\nvar MAX_BITS = 15;\nvar Buf_size = 16;\nvar MAX_BL_BITS = 7;\nvar END_BLOCK = 256;\nvar REP_3_6 = 16;\nvar REPZ_3_10 = 17;\nvar REPZ_11_138 = 18;\nvar extra_lbits = new Uint8Array([\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t1,\n\t1,\n\t1,\n\t1,\n\t2,\n\t2,\n\t2,\n\t2,\n\t3,\n\t3,\n\t3,\n\t3,\n\t4,\n\t4,\n\t4,\n\t4,\n\t5,\n\t5,\n\t5,\n\t5,\n\t0\n]);\nvar extra_dbits = new Uint8Array([\n\t0,\n\t0,\n\t0,\n\t0,\n\t1,\n\t1,\n\t2,\n\t2,\n\t3,\n\t3,\n\t4,\n\t4,\n\t5,\n\t5,\n\t6,\n\t6,\n\t7,\n\t7,\n\t8,\n\t8,\n\t9,\n\t9,\n\t10,\n\t10,\n\t11,\n\t11,\n\t12,\n\t12,\n\t13,\n\t13\n]);\nvar extra_blbits = new Uint8Array([\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t0,\n\t2,\n\t3,\n\t7\n]);\nvar bl_order = new Uint8Array([\n\t16,\n\t17,\n\t18,\n\t0,\n\t8,\n\t7,\n\t9,\n\t6,\n\t10,\n\t5,\n\t11,\n\t4,\n\t12,\n\t3,\n\t13,\n\t2,\n\t14,\n\t1,\n\t15\n]);\nvar DIST_CODE_LEN = 512;\nvar static_ltree = new Array(288 * 2);\nzero$1(static_ltree);\nvar static_dtree = new Array(D_CODES * 2);\nzero$1(static_dtree);\nvar _dist_code = new Array(DIST_CODE_LEN);\nzero$1(_dist_code);\nvar _length_code = new Array(256);\nzero$1(_length_code);\nvar base_length = new Array(LENGTH_CODES);\nzero$1(base_length);\nvar base_dist = new Array(D_CODES);\nzero$1(base_dist);\nvar StaticTreeDesc = class {\n\tconstructor(static_tree, extra_bits, extra_base, elems, max_length) {\n\t\tthis.static_tree = static_tree;\n\t\tthis.extra_bits = extra_bits;\n\t\tthis.extra_base = extra_base;\n\t\tthis.elems = elems;\n\t\tthis.max_length = max_length;\n\t\tthis.has_stree = static_tree && static_tree.length;\n\t}\n};\nvar static_l_desc;\nvar static_d_desc;\nvar static_bl_desc;\nvar TreeDesc = class {\n\tconstructor(dyn_tree, stat_desc) {\n\t\tthis.dyn_tree = dyn_tree;\n\t\tthis.max_code = 0;\n\t\tthis.stat_desc = stat_desc;\n\t}\n};\nvar d_code = (dist) => {\n\treturn dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n};\nvar put_short = (s, w) => {\n\ts.pending_buf[s.pending++] = w & 255;\n\ts.pending_buf[s.pending++] = w >>> 8 & 255;\n};\nvar send_bits = (s, value, length) => {\n\tif (s.bi_valid > Buf_size - length) {\n\t\ts.bi_buf |= value << s.bi_valid & 65535;\n\t\tput_short(s, s.bi_buf);\n\t\ts.bi_buf = value >> Buf_size - s.bi_valid;\n\t\ts.bi_valid += length - Buf_size;\n\t} else {\n\t\ts.bi_buf |= value << s.bi_valid & 65535;\n\t\ts.bi_valid += length;\n\t}\n};\nvar send_code = (s, c, tree) => {\n\tsend_bits(s, tree[c * 2], tree[c * 2 + 1]);\n};\nvar bi_reverse = (code, len) => {\n\tlet res = 0;\n\tdo {\n\t\tres |= code & 1;\n\t\tcode >>>= 1;\n\t\tres <<= 1;\n\t} while (--len > 0);\n\treturn res >>> 1;\n};\nvar bi_flush = (s) => {\n\tif (s.bi_valid === 16) {\n\t\tput_short(s, s.bi_buf);\n\t\ts.bi_buf = 0;\n\t\ts.bi_valid = 0;\n\t} else if (s.bi_valid >= 8) {\n\t\ts.pending_buf[s.pending++] = s.bi_buf & 255;\n\t\ts.bi_buf >>= 8;\n\t\ts.bi_valid -= 8;\n\t}\n};\nvar gen_bitlen = (s, desc) => {\n\tconst tree = desc.dyn_tree;\n\tconst max_code = desc.max_code;\n\tconst stree = desc.stat_desc.static_tree;\n\tconst has_stree = desc.stat_desc.has_stree;\n\tconst extra = desc.stat_desc.extra_bits;\n\tconst base = desc.stat_desc.extra_base;\n\tconst max_length = desc.stat_desc.max_length;\n\tlet h;\n\tlet n, m;\n\tlet bits;\n\tlet xbits;\n\tlet f;\n\tlet overflow = 0;\n\tfor (bits = 0; bits <= MAX_BITS; bits++) s.bl_count[bits] = 0;\n\ttree[s.heap[s.heap_max] * 2 + 1] = 0;\n\tfor (h = s.heap_max + 1; h < HEAP_SIZE$1; h++) {\n\t\tn = s.heap[h];\n\t\tbits = tree[tree[n * 2 + 1] * 2 + 1] + 1;\n\t\tif (bits > max_length) {\n\t\t\tbits = max_length;\n\t\t\toverflow++;\n\t\t}\n\t\ttree[n * 2 + 1] = bits;\n\t\tif (n > max_code) continue;\n\t\ts.bl_count[bits]++;\n\t\txbits = 0;\n\t\tif (n >= base) xbits = extra[n - base];\n\t\tf = tree[n * 2];\n\t\ts.opt_len += f * (bits + xbits);\n\t\tif (has_stree) s.static_len += f * (stree[n * 2 + 1] + xbits);\n\t}\n\tif (overflow === 0) return;\n\tdo {\n\t\tbits = max_length - 1;\n\t\twhile (s.bl_count[bits] === 0) bits--;\n\t\ts.bl_count[bits]--;\n\t\ts.bl_count[bits + 1] += 2;\n\t\ts.bl_count[max_length]--;\n\t\toverflow -= 2;\n\t} while (overflow > 0);\n\tfor (bits = max_length; bits !== 0; bits--) {\n\t\tn = s.bl_count[bits];\n\t\twhile (n !== 0) {\n\t\t\tm = s.heap[--h];\n\t\t\tif (m > max_code) continue;\n\t\t\tif (tree[m * 2 + 1] !== bits) {\n\t\t\t\ts.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];\n\t\t\t\ttree[m * 2 + 1] = bits;\n\t\t\t}\n\t\t\tn--;\n\t\t}\n\t}\n};\nvar gen_codes = (tree, max_code, bl_count) => {\n\tconst next_code = new Array(16);\n\tlet code = 0;\n\tlet bits;\n\tlet n;\n\tfor (bits = 1; bits <= MAX_BITS; bits++) {\n\t\tcode = code + bl_count[bits - 1] << 1;\n\t\tnext_code[bits] = code;\n\t}\n\tfor (n = 0; n <= max_code; n++) {\n\t\tlet len = tree[n * 2 + 1];\n\t\tif (len === 0) continue;\n\t\ttree[n * 2] = bi_reverse(next_code[len]++, len);\n\t}\n};\nvar tr_static_init = () => {\n\tlet n;\n\tlet bits;\n\tlet length;\n\tlet code;\n\tlet dist;\n\tconst bl_count = new Array(16);\n\tlength = 0;\n\tfor (code = 0; code < LENGTH_CODES - 1; code++) {\n\t\tbase_length[code] = length;\n\t\tfor (n = 0; n < 1 << extra_lbits[code]; n++) _length_code[length++] = code;\n\t}\n\t_length_code[length - 1] = code;\n\tdist = 0;\n\tfor (code = 0; code < 16; code++) {\n\t\tbase_dist[code] = dist;\n\t\tfor (n = 0; n < 1 << extra_dbits[code]; n++) _dist_code[dist++] = code;\n\t}\n\tdist >>= 7;\n\tfor (; code < D_CODES; code++) {\n\t\tbase_dist[code] = dist << 7;\n\t\tfor (n = 0; n < 1 << extra_dbits[code] - 7; n++) _dist_code[256 + dist++] = code;\n\t}\n\tfor (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;\n\tn = 0;\n\twhile (n <= 143) {\n\t\tstatic_ltree[n * 2 + 1] = 8;\n\t\tn++;\n\t\tbl_count[8]++;\n\t}\n\twhile (n <= 255) {\n\t\tstatic_ltree[n * 2 + 1] = 9;\n\t\tn++;\n\t\tbl_count[9]++;\n\t}\n\twhile (n <= 279) {\n\t\tstatic_ltree[n * 2 + 1] = 7;\n\t\tn++;\n\t\tbl_count[7]++;\n\t}\n\twhile (n <= 287) {\n\t\tstatic_ltree[n * 2 + 1] = 8;\n\t\tn++;\n\t\tbl_count[8]++;\n\t}\n\tgen_codes(static_ltree, 287, bl_count);\n\tfor (n = 0; n < D_CODES; n++) {\n\t\tstatic_dtree[n * 2 + 1] = 5;\n\t\tstatic_dtree[n * 2] = bi_reverse(n, 5);\n\t}\n\tstatic_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, 257, L_CODES, MAX_BITS);\n\tstatic_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);\n\tstatic_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);\n};\nvar init_block = (s) => {\n\tlet n;\n\tfor (n = 0; n < L_CODES; n++) s.dyn_ltree[n * 2] = 0;\n\tfor (n = 0; n < D_CODES; n++) s.dyn_dtree[n * 2] = 0;\n\tfor (n = 0; n < BL_CODES; n++) s.bl_tree[n * 2] = 0;\n\ts.dyn_ltree[END_BLOCK * 2] = 1;\n\ts.opt_len = s.static_len = 0;\n\ts.sym_next = s.matches = 0;\n};\nvar bi_windup = (s) => {\n\tif (s.bi_valid > 8) put_short(s, s.bi_buf);\n\telse if (s.bi_valid > 0) s.pending_buf[s.pending++] = s.bi_buf;\n\ts.bi_buf = 0;\n\ts.bi_valid = 0;\n};\nvar smaller = (tree, n, m, depth) => {\n\tconst _n2 = n * 2;\n\tconst _m2 = m * 2;\n\treturn tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];\n};\nvar pqdownheap = (s, tree, k) => {\n\tconst v = s.heap[k];\n\tlet j = k << 1;\n\twhile (j <= s.heap_len) {\n\t\tif (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) j++;\n\t\tif (smaller(tree, v, s.heap[j], s.depth)) break;\n\t\ts.heap[k] = s.heap[j];\n\t\tk = j;\n\t\tj <<= 1;\n\t}\n\ts.heap[k] = v;\n};\nvar compress_block = (s, ltree, dtree) => {\n\tlet dist;\n\tlet lc;\n\tlet sx = 0;\n\tlet code;\n\tlet extra;\n\tif (s.sym_next !== 0) do {\n\t\tdist = s.pending_buf[s.sym_buf + sx++] & 255;\n\t\tdist += (s.pending_buf[s.sym_buf + sx++] & 255) << 8;\n\t\tlc = s.pending_buf[s.sym_buf + sx++];\n\t\tif (dist === 0) send_code(s, lc, ltree);\n\t\telse {\n\t\t\tcode = _length_code[lc];\n\t\t\tsend_code(s, code + LITERALS + 1, ltree);\n\t\t\textra = extra_lbits[code];\n\t\t\tif (extra !== 0) {\n\t\t\t\tlc -= base_length[code];\n\t\t\t\tsend_bits(s, lc, extra);\n\t\t\t}\n\t\t\tdist--;\n\t\t\tcode = d_code(dist);\n\t\t\tsend_code(s, code, dtree);\n\t\t\textra = extra_dbits[code];\n\t\t\tif (extra !== 0) {\n\t\t\t\tdist -= base_dist[code];\n\t\t\t\tsend_bits(s, dist, extra);\n\t\t\t}\n\t\t}\n\t} while (sx < s.sym_next);\n\tsend_code(s, END_BLOCK, ltree);\n};\nvar build_tree = (s, desc) => {\n\tconst tree = desc.dyn_tree;\n\tconst stree = desc.stat_desc.static_tree;\n\tconst has_stree = desc.stat_desc.has_stree;\n\tconst elems = desc.stat_desc.elems;\n\tlet n, m;\n\tlet max_code = -1;\n\tlet node;\n\ts.heap_len = 0;\n\ts.heap_max = HEAP_SIZE$1;\n\tfor (n = 0; n < elems; n++) if (tree[n * 2] !== 0) {\n\t\ts.heap[++s.heap_len] = max_code = n;\n\t\ts.depth[n] = 0;\n\t} else tree[n * 2 + 1] = 0;\n\twhile (s.heap_len < 2) {\n\t\tnode = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;\n\t\ttree[node * 2] = 1;\n\t\ts.depth[node] = 0;\n\t\ts.opt_len--;\n\t\tif (has_stree) s.static_len -= stree[node * 2 + 1];\n\t}\n\tdesc.max_code = max_code;\n\tfor (n = s.heap_len >> 1; n >= 1; n--) pqdownheap(s, tree, n);\n\tnode = elems;\n\tdo {\n\t\t/*** pqremove ***/\n\t\tn = s.heap[1];\n\t\ts.heap[1] = s.heap[s.heap_len--];\n\t\tpqdownheap(s, tree, 1);\n\t\tm = s.heap[1];\n\t\ts.heap[--s.heap_max] = n;\n\t\ts.heap[--s.heap_max] = m;\n\t\ttree[node * 2] = tree[n * 2] + tree[m * 2];\n\t\ts.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n\t\ttree[n * 2 + 1] = tree[m * 2 + 1] = node;\n\t\ts.heap[1] = node++;\n\t\tpqdownheap(s, tree, 1);\n\t} while (s.heap_len >= 2);\n\ts.heap[--s.heap_max] = s.heap[1];\n\tgen_bitlen(s, desc);\n\tgen_codes(tree, max_code, s.bl_count);\n};\nvar scan_tree = (s, tree, max_code) => {\n\tlet n;\n\tlet prevlen = -1;\n\tlet curlen;\n\tlet nextlen = tree[1];\n\tlet count = 0;\n\tlet max_count = 7;\n\tlet min_count = 4;\n\tif (nextlen === 0) {\n\t\tmax_count = 138;\n\t\tmin_count = 3;\n\t}\n\ttree[(max_code + 1) * 2 + 1] = 65535;\n\tfor (n = 0; n <= max_code; n++) {\n\t\tcurlen = nextlen;\n\t\tnextlen = tree[(n + 1) * 2 + 1];\n\t\tif (++count < max_count && curlen === nextlen) continue;\n\t\telse if (count < min_count) s.bl_tree[curlen * 2] += count;\n\t\telse if (curlen !== 0) {\n\t\t\tif (curlen !== prevlen) s.bl_tree[curlen * 2]++;\n\t\t\ts.bl_tree[REP_3_6 * 2]++;\n\t\t} else if (count <= 10) s.bl_tree[REPZ_3_10 * 2]++;\n\t\telse s.bl_tree[REPZ_11_138 * 2]++;\n\t\tcount = 0;\n\t\tprevlen = curlen;\n\t\tif (nextlen === 0) {\n\t\t\tmax_count = 138;\n\t\t\tmin_count = 3;\n\t\t} else if (curlen === nextlen) {\n\t\t\tmax_count = 6;\n\t\t\tmin_count = 3;\n\t\t} else {\n\t\t\tmax_count = 7;\n\t\t\tmin_count = 4;\n\t\t}\n\t}\n};\nvar send_tree = (s, tree, max_code) => {\n\tlet n;\n\tlet prevlen = -1;\n\tlet curlen;\n\tlet nextlen = tree[1];\n\tlet count = 0;\n\tlet max_count = 7;\n\tlet min_count = 4;\n\tif (nextlen === 0) {\n\t\tmax_count = 138;\n\t\tmin_count = 3;\n\t}\n\tfor (n = 0; n <= max_code; n++) {\n\t\tcurlen = nextlen;\n\t\tnextlen = tree[(n + 1) * 2 + 1];\n\t\tif (++count < max_count && curlen === nextlen) continue;\n\t\telse if (count < min_count) do\n\t\t\tsend_code(s, curlen, s.bl_tree);\n\t\twhile (--count !== 0);\n\t\telse if (curlen !== 0) {\n\t\t\tif (curlen !== prevlen) {\n\t\t\t\tsend_code(s, curlen, s.bl_tree);\n\t\t\t\tcount--;\n\t\t\t}\n\t\t\tsend_code(s, REP_3_6, s.bl_tree);\n\t\t\tsend_bits(s, count - 3, 2);\n\t\t} else if (count <= 10) {\n\t\t\tsend_code(s, REPZ_3_10, s.bl_tree);\n\t\t\tsend_bits(s, count - 3, 3);\n\t\t} else {\n\t\t\tsend_code(s, REPZ_11_138, s.bl_tree);\n\t\t\tsend_bits(s, count - 11, 7);\n\t\t}\n\t\tcount = 0;\n\t\tprevlen = curlen;\n\t\tif (nextlen === 0) {\n\t\t\tmax_count = 138;\n\t\t\tmin_count = 3;\n\t\t} else if (curlen === nextlen) {\n\t\t\tmax_count = 6;\n\t\t\tmin_count = 3;\n\t\t} else {\n\t\t\tmax_count = 7;\n\t\t\tmin_count = 4;\n\t\t}\n\t}\n};\nvar build_bl_tree = (s) => {\n\tlet max_blindex;\n\tscan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n\tscan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n\tbuild_tree(s, s.bl_desc);\n\tfor (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) break;\n\ts.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;\n\treturn max_blindex;\n};\nvar send_all_trees = (s, lcodes, dcodes, blcodes) => {\n\tlet rank;\n\tsend_bits(s, lcodes - 257, 5);\n\tsend_bits(s, dcodes - 1, 5);\n\tsend_bits(s, blcodes - 4, 4);\n\tfor (rank = 0; rank < blcodes; rank++) send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);\n\tsend_tree(s, s.dyn_ltree, lcodes - 1);\n\tsend_tree(s, s.dyn_dtree, dcodes - 1);\n};\nvar detect_data_type = (s) => {\n\tlet block_mask = 4093624447;\n\tlet n;\n\tfor (n = 0; n <= 31; n++, block_mask >>>= 1) if (block_mask & 1 && s.dyn_ltree[n * 2] !== 0) return Z_BINARY;\n\tif (s.dyn_ltree[18] !== 0 || s.dyn_ltree[20] !== 0 || s.dyn_ltree[26] !== 0) return Z_TEXT;\n\tfor (n = 32; n < LITERALS; n++) if (s.dyn_ltree[n * 2] !== 0) return Z_TEXT;\n\treturn Z_BINARY;\n};\nvar static_init_done = false;\nvar _tr_init = (s) => {\n\tif (!static_init_done) {\n\t\ttr_static_init();\n\t\tstatic_init_done = true;\n\t}\n\ts.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);\n\ts.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);\n\ts.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n\ts.bi_buf = 0;\n\ts.bi_valid = 0;\n\tinit_block(s);\n};\nvar _tr_stored_block = (s, buf, stored_len, last) => {\n\tsend_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);\n\tbi_windup(s);\n\tput_short(s, stored_len);\n\tput_short(s, ~stored_len);\n\tif (stored_len) s.pending_buf.set(s.window.subarray(buf, buf + stored_len), s.pending);\n\ts.pending += stored_len;\n};\nvar _tr_align = (s) => {\n\tsend_bits(s, STATIC_TREES << 1, 3);\n\tsend_code(s, END_BLOCK, static_ltree);\n\tbi_flush(s);\n};\nvar _tr_flush_block = (s, buf, stored_len, last) => {\n\tlet opt_lenb, static_lenb;\n\tlet max_blindex = 0;\n\tif (s.level > 0) {\n\t\tif (s.strm.data_type === Z_UNKNOWN) s.strm.data_type = detect_data_type(s);\n\t\tbuild_tree(s, s.l_desc);\n\t\tbuild_tree(s, s.d_desc);\n\t\tmax_blindex = build_bl_tree(s);\n\t\topt_lenb = s.opt_len + 3 + 7 >>> 3;\n\t\tstatic_lenb = s.static_len + 3 + 7 >>> 3;\n\t\tif (static_lenb <= opt_lenb) opt_lenb = static_lenb;\n\t} else opt_lenb = static_lenb = stored_len + 5;\n\tif (stored_len + 4 <= opt_lenb && buf !== -1) _tr_stored_block(s, buf, stored_len, last);\n\telse if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n\t\tsend_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n\t\tcompress_block(s, static_ltree, static_dtree);\n\t} else {\n\t\tsend_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n\t\tsend_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n\t\tcompress_block(s, s.dyn_ltree, s.dyn_dtree);\n\t}\n\tinit_block(s);\n\tif (last) bi_windup(s);\n};\nvar _tr_tally = (s, dist, lc) => {\n\ts.pending_buf[s.sym_buf + s.sym_next++] = dist;\n\ts.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8;\n\ts.pending_buf[s.sym_buf + s.sym_next++] = lc;\n\tif (dist === 0) s.dyn_ltree[lc * 2]++;\n\telse {\n\t\ts.matches++;\n\t\tdist--;\n\t\ts.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;\n\t\ts.dyn_dtree[d_code(dist) * 2]++;\n\t}\n\treturn s.sym_next === s.sym_end;\n};\n//#endregion\n//#region src/zlib/adler32.mjs\nvar adler32 = (adler, buf, len, pos) => {\n\tlet s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;\n\twhile (len !== 0) {\n\t\tn = len > 2e3 ? 2e3 : len;\n\t\tlen -= n;\n\t\tdo {\n\t\t\ts1 = s1 + buf[pos++] | 0;\n\t\t\ts2 = s2 + s1 | 0;\n\t\t} while (--n);\n\t\ts1 %= 65521;\n\t\ts2 %= 65521;\n\t}\n\treturn s1 | s2 << 16 | 0;\n};\n//#endregion\n//#region src/zlib/crc32.mjs\nvar makeTable = () => {\n\tlet c, table = [];\n\tfor (var n = 0; n < 256; n++) {\n\t\tc = n;\n\t\tfor (var k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;\n\t\ttable[n] = c;\n\t}\n\treturn table;\n};\nvar crcTable = new Uint32Array(makeTable());\nvar crc32 = (crc, buf, len, pos) => {\n\tconst t = crcTable;\n\tconst end = pos + len;\n\tcrc ^= -1;\n\tfor (let i = pos; i < end; i++) crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];\n\treturn crc ^ -1;\n};\n//#endregion\n//#region src/zlib/messages.mjs\nvar messages_default = {\n\t2: \"need dictionary\",\n\t1: \"stream end\",\n\t0: \"\",\n\t\"-1\": \"file error\",\n\t\"-2\": \"stream error\",\n\t\"-3\": \"data error\",\n\t\"-4\": \"insufficient memory\",\n\t\"-5\": \"buffer error\",\n\t\"-6\": \"incompatible version\"\n};\n//#endregion\n//#region src/zlib/constants.mjs\nvar Z_NO_FLUSH = 0;\nvar Z_PARTIAL_FLUSH = 1;\nvar Z_SYNC_FLUSH = 2;\nvar Z_FULL_FLUSH = 3;\nvar Z_FINISH = 4;\nvar Z_BLOCK = 5;\nvar Z_TREES = 6;\nvar Z_OK = 0;\nvar Z_STREAM_END = 1;\nvar Z_NEED_DICT = 2;\nvar Z_ERRNO = -1;\nvar Z_STREAM_ERROR = -2;\nvar Z_DATA_ERROR = -3;\nvar Z_MEM_ERROR = -4;\nvar Z_BUF_ERROR = -5;\n//#endregion\n//#region src/zlib/deflate.mjs\nvar MAX_MEM_LEVEL = 9;\nvar MAX_WBITS = 15;\nvar DEF_MEM_LEVEL = 8;\nvar HEAP_SIZE = 573;\nvar MIN_MATCH = 3;\nvar MAX_MATCH = 258;\nvar MIN_LOOKAHEAD = 262;\nvar PRESET_DICT = 32;\nvar INIT_STATE = 42;\nvar GZIP_STATE = 57;\nvar EXTRA_STATE = 69;\nvar NAME_STATE = 73;\nvar COMMENT_STATE = 91;\nvar HCRC_STATE = 103;\nvar BUSY_STATE = 113;\nvar FINISH_STATE = 666;\nvar BS_NEED_MORE = 1;\nvar BS_BLOCK_DONE = 2;\nvar BS_FINISH_STARTED = 3;\nvar BS_FINISH_DONE = 4;\nvar OS_CODE = 3;\nvar err = (strm, errorCode) => {\n\tstrm.msg = messages_default[errorCode];\n\treturn errorCode;\n};\nvar rank = (f) => {\n\treturn f * 2 - (f > 4 ? 9 : 0);\n};\nvar zero = (buf) => {\n\tlet len = buf.length;\n\twhile (--len >= 0) buf[len] = 0;\n};\nvar slide_hash = (s) => {\n\tlet n, m;\n\tlet p;\n\tlet wsize = s.w_size;\n\tn = s.hash_size;\n\tp = n;\n\tdo {\n\t\tm = s.head[--p];\n\t\ts.head[p] = m >= wsize ? m - wsize : 0;\n\t} while (--n);\n\tn = wsize;\n\tp = n;\n\tdo {\n\t\tm = s.prev[--p];\n\t\ts.prev[p] = m >= wsize ? m - wsize : 0;\n\t} while (--n);\n};\nvar HASH = (s, prev, data) => (prev << s.hash_shift ^ data) & s.hash_mask;\nvar INSERT_STRING = (s, str) => {\n\tlet h;\n\tif (s.legacy_hash) h = s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);\n\telse {\n\t\tconst w = s.window;\n\t\tconst value = w[str] | w[str + 1] << 8 | w[str + 2] << 16 | w[str + 3] << 24;\n\t\th = s.ins_h = Math.imul(value, 66521) + 66521 >>> 16 & s.hash_mask;\n\t}\n\tconst hash_head = s.prev[str & s.w_mask] = s.head[h];\n\ts.head[h] = str;\n\treturn hash_head;\n};\nvar flush_pending = (strm) => {\n\tconst s = strm.state;\n\tlet len = s.pending;\n\tif (len > strm.avail_out) len = strm.avail_out;\n\tif (len === 0) return;\n\tstrm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);\n\tstrm.next_out += len;\n\ts.pending_out += len;\n\tstrm.total_out += len;\n\tstrm.avail_out -= len;\n\ts.pending -= len;\n\tif (s.pending === 0) s.pending_out = 0;\n};\nvar flush_block_only = (s, last) => {\n\t_tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n\ts.block_start = s.strstart;\n\tflush_pending(s.strm);\n};\nvar put_byte = (s, b) => {\n\ts.pending_buf[s.pending++] = b;\n};\nvar putShortMSB = (s, b) => {\n\ts.pending_buf[s.pending++] = b >>> 8 & 255;\n\ts.pending_buf[s.pending++] = b & 255;\n};\nvar read_buf = (strm, buf, start, size) => {\n\tlet len = strm.avail_in;\n\tif (len > size) len = size;\n\tif (len === 0) return 0;\n\tstrm.avail_in -= len;\n\tbuf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);\n\tif (strm.state.wrap === 1) strm.adler = adler32(strm.adler, buf, len, start);\n\telse if (strm.state.wrap === 2) strm.adler = crc32(strm.adler, buf, len, start);\n\tstrm.next_in += len;\n\tstrm.total_in += len;\n\treturn len;\n};\nvar longest_match = (s, cur_match) => {\n\tlet chain_length = s.max_chain_length;\n\tlet scan = s.strstart;\n\tlet match;\n\tlet len;\n\tlet best_len = s.prev_length;\n\tlet nice_match = s.nice_match;\n\tconst limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;\n\tconst _win = s.window;\n\tconst wmask = s.w_mask;\n\tconst prev = s.prev;\n\tconst strend = s.strstart + MAX_MATCH;\n\tlet scan_end1 = _win[scan + best_len - 1];\n\tlet scan_end = _win[scan + best_len];\n\tif (s.prev_length >= s.good_match) chain_length >>= 2;\n\tif (nice_match > s.lookahead) nice_match = s.lookahead;\n\tdo {\n\t\tmatch = cur_match;\n\t\tif (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) continue;\n\t\tscan += 2;\n\t\tmatch++;\n\t\tdo\t\t;\nwhile (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);\n\t\tlen = MAX_MATCH - (strend - scan);\n\t\tscan = strend - MAX_MATCH;\n\t\tif (len > best_len) {\n\t\t\ts.match_start = cur_match;\n\t\t\tbest_len = len;\n\t\t\tif (len >= nice_match) break;\n\t\t\tscan_end1 = _win[scan + best_len - 1];\n\t\t\tscan_end = _win[scan + best_len];\n\t\t}\n\t} while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n\tif (best_len <= s.lookahead) return best_len;\n\treturn s.lookahead;\n};\nvar fill_window = (s) => {\n\tconst _w_size = s.w_size;\n\tlet n, more, str;\n\tdo {\n\t\tmore = s.window_size - s.lookahead - s.strstart;\n\t\tif (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n\t\t\ts.window.set(s.window.subarray(_w_size, _w_size + _w_size - more), 0);\n\t\t\ts.match_start -= _w_size;\n\t\t\ts.strstart -= _w_size;\n\t\t\ts.block_start -= _w_size;\n\t\t\tif (s.insert > s.strstart) s.insert = s.strstart;\n\t\t\tslide_hash(s);\n\t\t\tmore += _w_size;\n\t\t}\n\t\tif (s.strm.avail_in === 0) break;\n\t\tn = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n\t\ts.lookahead += n;\n\t\tif (!s.legacy_hash) {\n\t\t\tif (s.lookahead + s.insert > MIN_MATCH) {\n\t\t\t\tstr = s.strstart - s.insert;\n\t\t\t\twhile (s.insert) {\n\t\t\t\t\tINSERT_STRING(s, str);\n\t\t\t\t\tstr++;\n\t\t\t\t\ts.insert--;\n\t\t\t\t\tif (s.lookahead + s.insert <= MIN_MATCH) break;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (s.lookahead + s.insert >= MIN_MATCH) {\n\t\t\tstr = s.strstart - s.insert;\n\t\t\ts.ins_h = s.window[str];\n\t\t\ts.ins_h = HASH(s, s.ins_h, s.window[str + 1]);\n\t\t\twhile (s.insert) {\n\t\t\t\tINSERT_STRING(s, str);\n\t\t\t\tstr++;\n\t\t\t\ts.insert--;\n\t\t\t\tif (s.lookahead + s.insert < MIN_MATCH) break;\n\t\t\t}\n\t\t}\n\t} while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n};\nvar deflate_stored = (s, flush) => {\n\tlet min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5;\n\tlet len, left, have, last = 0;\n\tlet used = s.strm.avail_in;\n\tdo {\n\t\tlen = 65535;\n\t\thave = s.bi_valid + 42 >> 3;\n\t\tif (s.strm.avail_out < have) break;\n\t\thave = s.strm.avail_out - have;\n\t\tleft = s.strstart - s.block_start;\n\t\tif (len > left + s.strm.avail_in) len = left + s.strm.avail_in;\n\t\tif (len > have) len = have;\n\t\tif (len < min_block && (len === 0 && flush !== 4 || flush === 0 || len !== left + s.strm.avail_in)) break;\n\t\tlast = flush === 4 && len === left + s.strm.avail_in ? 1 : 0;\n\t\t_tr_stored_block(s, 0, 0, last);\n\t\ts.pending_buf[s.pending - 4] = len;\n\t\ts.pending_buf[s.pending - 3] = len >> 8;\n\t\ts.pending_buf[s.pending - 2] = ~len;\n\t\ts.pending_buf[s.pending - 1] = ~len >> 8;\n\t\tflush_pending(s.strm);\n\t\tif (left) {\n\t\t\tif (left > len) left = len;\n\t\t\ts.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out);\n\t\t\ts.strm.next_out += left;\n\t\t\ts.strm.avail_out -= left;\n\t\t\ts.strm.total_out += left;\n\t\t\ts.block_start += left;\n\t\t\tlen -= left;\n\t\t}\n\t\tif (len) {\n\t\t\tread_buf(s.strm, s.strm.output, s.strm.next_out, len);\n\t\t\ts.strm.next_out += len;\n\t\t\ts.strm.avail_out -= len;\n\t\t\ts.strm.total_out += len;\n\t\t}\n\t} while (last === 0);\n\tused -= s.strm.avail_in;\n\tif (used) {\n\t\tif (used >= s.w_size) {\n\t\t\ts.matches = 2;\n\t\t\ts.window.set(s.strm.input.subarray(s.strm.next_in - s.w_size, s.strm.next_in), 0);\n\t\t\ts.strstart = s.w_size;\n\t\t\ts.insert = s.strstart;\n\t\t} else {\n\t\t\tif (s.window_size - s.strstart <= used) {\n\t\t\t\ts.strstart -= s.w_size;\n\t\t\t\ts.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);\n\t\t\t\tif (s.matches < 2) s.matches++;\n\t\t\t\tif (s.insert > s.strstart) s.insert = s.strstart;\n\t\t\t}\n\t\t\ts.window.set(s.strm.input.subarray(s.strm.next_in - used, s.strm.next_in), s.strstart);\n\t\t\ts.strstart += used;\n\t\t\ts.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;\n\t\t}\n\t\ts.block_start = s.strstart;\n\t}\n\tif (s.high_water < s.strstart) s.high_water = s.strstart;\n\tif (last) return BS_FINISH_DONE;\n\tif (flush !== 0 && flush !== 4 && s.strm.avail_in === 0 && s.strstart === s.block_start) return BS_BLOCK_DONE;\n\thave = s.window_size - s.strstart;\n\tif (s.strm.avail_in > have && s.block_start >= s.w_size) {\n\t\ts.block_start -= s.w_size;\n\t\ts.strstart -= s.w_size;\n\t\ts.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);\n\t\tif (s.matches < 2) s.matches++;\n\t\thave += s.w_size;\n\t\tif (s.insert > s.strstart) s.insert = s.strstart;\n\t}\n\tif (have > s.strm.avail_in) have = s.strm.avail_in;\n\tif (have) {\n\t\tread_buf(s.strm, s.window, s.strstart, have);\n\t\ts.strstart += have;\n\t\ts.insert += have > s.w_size - s.insert ? s.w_size - s.insert : have;\n\t}\n\tif (s.high_water < s.strstart) s.high_water = s.strstart;\n\thave = s.bi_valid + 42 >> 3;\n\thave = s.pending_buf_size - have > 65535 ? 65535 : s.pending_buf_size - have;\n\tmin_block = have > s.w_size ? s.w_size : have;\n\tleft = s.strstart - s.block_start;\n\tif (left >= min_block || (left || flush === 4) && flush !== 0 && s.strm.avail_in === 0 && left <= have) {\n\t\tlen = left > have ? have : left;\n\t\tlast = flush === 4 && s.strm.avail_in === 0 && len === left ? 1 : 0;\n\t\t_tr_stored_block(s, s.block_start, len, last);\n\t\ts.block_start += len;\n\t\tflush_pending(s.strm);\n\t}\n\treturn last ? BS_FINISH_STARTED : BS_NEED_MORE;\n};\nvar deflate_fast = (s, flush) => {\n\tlet hash_head;\n\tlet bflush;\n\tfor (;;) {\n\t\tif (s.lookahead < MIN_LOOKAHEAD) {\n\t\t\tfill_window(s);\n\t\t\tif (s.lookahead < MIN_LOOKAHEAD && flush === 0) return BS_NEED_MORE;\n\t\t\tif (s.lookahead === 0) break;\n\t\t}\n\t\thash_head = 0;\n\t\tif (s.lookahead >= MIN_MATCH) hash_head = INSERT_STRING(s, s.strstart);\n\t\tif (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) s.match_length = longest_match(s, hash_head);\n\t\tif (s.match_length >= MIN_MATCH) {\n\t\t\t/*** _tr_tally_dist(s, s.strstart - s.match_start,\n\t\t\ts.match_length - MIN_MATCH, bflush); ***/\n\t\t\tbflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);\n\t\t\ts.lookahead -= s.match_length;\n\t\t\tif (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) {\n\t\t\t\ts.match_length--;\n\t\t\t\tdo {\n\t\t\t\t\ts.strstart++;\n\t\t\t\t\thash_head = INSERT_STRING(s, s.strstart);\n\t\t\t\t} while (--s.match_length !== 0);\n\t\t\t\ts.strstart++;\n\t\t\t} else {\n\t\t\t\ts.strstart += s.match_length;\n\t\t\t\ts.match_length = 0;\n\t\t\t\tif (s.legacy_hash) {\n\t\t\t\t\ts.ins_h = s.window[s.strstart];\n\t\t\t\t\ts.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n\t\t\tbflush = _tr_tally(s, 0, s.window[s.strstart]);\n\t\t\ts.lookahead--;\n\t\t\ts.strstart++;\n\t\t}\n\t\tif (bflush) {\n\t\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\t\tflush_block_only(s, false);\n\t\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t\t}\n\t}\n\ts.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n\tif (flush === 4) {\n\t\t/*** FLUSH_BLOCK(s, 1); ***/\n\t\tflush_block_only(s, true);\n\t\tif (s.strm.avail_out === 0) return BS_FINISH_STARTED;\n\t\treturn BS_FINISH_DONE;\n\t}\n\tif (s.sym_next) {\n\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\tflush_block_only(s, false);\n\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t}\n\treturn BS_BLOCK_DONE;\n};\nvar deflate_slow = (s, flush) => {\n\tlet hash_head;\n\tlet bflush;\n\tlet max_insert;\n\tfor (;;) {\n\t\tif (s.lookahead < MIN_LOOKAHEAD) {\n\t\t\tfill_window(s);\n\t\t\tif (s.lookahead < MIN_LOOKAHEAD && flush === 0) return BS_NEED_MORE;\n\t\t\tif (s.lookahead === 0) break;\n\t\t}\n\t\thash_head = 0;\n\t\tif (s.lookahead >= MIN_MATCH) hash_head = INSERT_STRING(s, s.strstart);\n\t\ts.prev_length = s.match_length;\n\t\ts.prev_match = s.match_start;\n\t\ts.match_length = MIN_MATCH - 1;\n\t\tif (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n\t\t\ts.match_length = longest_match(s, hash_head);\n\t\t\tif (s.match_length <= 5 && (s.strategy === 1 || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) s.match_length = MIN_MATCH - 1;\n\t\t}\n\t\tif (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {\n\t\t\tmax_insert = s.strstart + s.lookahead - MIN_MATCH;\n\t\t\t/***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n\t\t\ts.prev_length - MIN_MATCH, bflush);***/\n\t\t\tbflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);\n\t\t\ts.lookahead -= s.prev_length - 1;\n\t\t\ts.prev_length -= 2;\n\t\t\tdo\n\t\t\t\tif (++s.strstart <= max_insert) hash_head = INSERT_STRING(s, s.strstart);\n\t\t\twhile (--s.prev_length !== 0);\n\t\t\ts.match_available = 0;\n\t\t\ts.match_length = MIN_MATCH - 1;\n\t\t\ts.strstart++;\n\t\t\tif (bflush) {\n\t\t\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\t\t\tflush_block_only(s, false);\n\t\t\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t\t\t}\n\t\t} else if (s.match_available) {\n\t\t\t/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n\t\t\tbflush = _tr_tally(s, 0, s.window[s.strstart - 1]);\n\t\t\tif (bflush)\n /*** FLUSH_BLOCK_ONLY(s, 0) ***/\n\t\t\tflush_block_only(s, false);\n\t\t\ts.strstart++;\n\t\t\ts.lookahead--;\n\t\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t\t} else {\n\t\t\ts.match_available = 1;\n\t\t\ts.strstart++;\n\t\t\ts.lookahead--;\n\t\t}\n\t}\n\tif (s.match_available) {\n\t\t/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/\n\t\tbflush = _tr_tally(s, 0, s.window[s.strstart - 1]);\n\t\ts.match_available = 0;\n\t}\n\ts.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;\n\tif (flush === 4) {\n\t\t/*** FLUSH_BLOCK(s, 1); ***/\n\t\tflush_block_only(s, true);\n\t\tif (s.strm.avail_out === 0) return BS_FINISH_STARTED;\n\t\treturn BS_FINISH_DONE;\n\t}\n\tif (s.sym_next) {\n\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\tflush_block_only(s, false);\n\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t}\n\treturn BS_BLOCK_DONE;\n};\nvar deflate_rle = (s, flush) => {\n\tlet bflush;\n\tlet prev;\n\tlet scan, strend;\n\tconst _win = s.window;\n\tfor (;;) {\n\t\tif (s.lookahead <= MAX_MATCH) {\n\t\t\tfill_window(s);\n\t\t\tif (s.lookahead <= MAX_MATCH && flush === 0) return BS_NEED_MORE;\n\t\t\tif (s.lookahead === 0) break;\n\t\t}\n\t\ts.match_length = 0;\n\t\tif (s.lookahead >= MIN_MATCH && s.strstart > 0) {\n\t\t\tscan = s.strstart - 1;\n\t\t\tprev = _win[scan];\n\t\t\tif (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n\t\t\t\tstrend = s.strstart + MAX_MATCH;\n\t\t\t\tdo\t\t\t\t;\nwhile (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);\n\t\t\t\ts.match_length = MAX_MATCH - (strend - scan);\n\t\t\t\tif (s.match_length > s.lookahead) s.match_length = s.lookahead;\n\t\t\t}\n\t\t}\n\t\tif (s.match_length >= MIN_MATCH) {\n\t\t\t/*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/\n\t\t\tbflush = _tr_tally(s, 1, s.match_length - MIN_MATCH);\n\t\t\ts.lookahead -= s.match_length;\n\t\t\ts.strstart += s.match_length;\n\t\t\ts.match_length = 0;\n\t\t} else {\n\t\t\t/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n\t\t\tbflush = _tr_tally(s, 0, s.window[s.strstart]);\n\t\t\ts.lookahead--;\n\t\t\ts.strstart++;\n\t\t}\n\t\tif (bflush) {\n\t\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\t\tflush_block_only(s, false);\n\t\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t\t}\n\t}\n\ts.insert = 0;\n\tif (flush === 4) {\n\t\t/*** FLUSH_BLOCK(s, 1); ***/\n\t\tflush_block_only(s, true);\n\t\tif (s.strm.avail_out === 0) return BS_FINISH_STARTED;\n\t\treturn BS_FINISH_DONE;\n\t}\n\tif (s.sym_next) {\n\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\tflush_block_only(s, false);\n\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t}\n\treturn BS_BLOCK_DONE;\n};\nvar deflate_huff = (s, flush) => {\n\tlet bflush;\n\tfor (;;) {\n\t\tif (s.lookahead === 0) {\n\t\t\tfill_window(s);\n\t\t\tif (s.lookahead === 0) {\n\t\t\t\tif (flush === 0) return BS_NEED_MORE;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\ts.match_length = 0;\n\t\t/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/\n\t\tbflush = _tr_tally(s, 0, s.window[s.strstart]);\n\t\ts.lookahead--;\n\t\ts.strstart++;\n\t\tif (bflush) {\n\t\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\t\tflush_block_only(s, false);\n\t\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t\t}\n\t}\n\ts.insert = 0;\n\tif (flush === 4) {\n\t\t/*** FLUSH_BLOCK(s, 1); ***/\n\t\tflush_block_only(s, true);\n\t\tif (s.strm.avail_out === 0) return BS_FINISH_STARTED;\n\t\treturn BS_FINISH_DONE;\n\t}\n\tif (s.sym_next) {\n\t\t/*** FLUSH_BLOCK(s, 0); ***/\n\t\tflush_block_only(s, false);\n\t\tif (s.strm.avail_out === 0) return BS_NEED_MORE;\n\t}\n\treturn BS_BLOCK_DONE;\n};\nvar Config = class {\n\tconstructor(good_length, max_lazy, nice_length, max_chain, func) {\n\t\tthis.good_length = good_length;\n\t\tthis.max_lazy = max_lazy;\n\t\tthis.nice_length = nice_length;\n\t\tthis.max_chain = max_chain;\n\t\tthis.func = func;\n\t}\n};\nvar configuration_table = [\n\tnew Config(0, 0, 0, 0, deflate_stored),\n\tnew Config(4, 4, 8, 4, deflate_fast),\n\tnew Config(4, 5, 16, 8, deflate_fast),\n\tnew Config(4, 6, 32, 32, deflate_fast),\n\tnew Config(4, 4, 16, 16, deflate_slow),\n\tnew Config(8, 16, 32, 32, deflate_slow),\n\tnew Config(8, 16, 128, 128, deflate_slow),\n\tnew Config(8, 32, 128, 256, deflate_slow),\n\tnew Config(32, 128, 258, 1024, deflate_slow),\n\tnew Config(32, 258, 258, 4096, deflate_slow)\n];\nvar lm_init = (s) => {\n\ts.window_size = 2 * s.w_size;\n\t/*** CLEAR_HASH(s); ***/\n\tzero(s.head);\n\ts.max_lazy_match = configuration_table[s.level].max_lazy;\n\ts.good_match = configuration_table[s.level].good_length;\n\ts.nice_match = configuration_table[s.level].nice_length;\n\ts.max_chain_length = configuration_table[s.level].max_chain;\n\ts.strstart = 0;\n\ts.block_start = 0;\n\ts.lookahead = 0;\n\ts.insert = 0;\n\ts.match_length = s.prev_length = MIN_MATCH - 1;\n\ts.match_available = 0;\n\ts.ins_h = 0;\n};\nvar DeflateState = class {\n\tconstructor() {\n\t\tthis.strm = null;\n\t\tthis.status = 0;\n\t\tthis.pending_buf = null;\n\t\tthis.pending_buf_size = 0;\n\t\tthis.pending_out = 0;\n\t\tthis.pending = 0;\n\t\tthis.wrap = 0;\n\t\tthis.gzhead = null;\n\t\tthis.gzindex = 0;\n\t\tthis.method = 8;\n\t\tthis.last_flush = -1;\n\t\tthis.w_size = 0;\n\t\tthis.w_bits = 0;\n\t\tthis.w_mask = 0;\n\t\tthis.window = null;\n\t\tthis.window_size = 0;\n\t\tthis.prev = null;\n\t\tthis.head = null;\n\t\tthis.ins_h = 0;\n\t\tthis.legacy_hash = 0;\n\t\tthis.hash_size = 0;\n\t\tthis.hash_bits = 0;\n\t\tthis.hash_mask = 0;\n\t\tthis.hash_shift = 0;\n\t\tthis.block_start = 0;\n\t\tthis.match_length = 0;\n\t\tthis.prev_match = 0;\n\t\tthis.match_available = 0;\n\t\tthis.strstart = 0;\n\t\tthis.match_start = 0;\n\t\tthis.lookahead = 0;\n\t\tthis.prev_length = 0;\n\t\tthis.max_chain_length = 0;\n\t\tthis.max_lazy_match = 0;\n\t\tthis.level = 0;\n\t\tthis.strategy = 0;\n\t\tthis.good_match = 0;\n\t\tthis.nice_match = 0;\n\t\tthis.dyn_ltree = new Uint16Array(HEAP_SIZE * 2);\n\t\tthis.dyn_dtree = /* @__PURE__ */ new Uint16Array(122);\n\t\tthis.bl_tree = /* @__PURE__ */ new Uint16Array(78);\n\t\tzero(this.dyn_ltree);\n\t\tzero(this.dyn_dtree);\n\t\tzero(this.bl_tree);\n\t\tthis.l_desc = null;\n\t\tthis.d_desc = null;\n\t\tthis.bl_desc = null;\n\t\tthis.bl_count = /* @__PURE__ */ new Uint16Array(16);\n\t\tthis.heap = /* @__PURE__ */ new Uint16Array(573);\n\t\tzero(this.heap);\n\t\tthis.heap_len = 0;\n\t\tthis.heap_max = 0;\n\t\tthis.depth = /* @__PURE__ */ new Uint16Array(573);\n\t\tzero(this.depth);\n\t\tthis.sym_buf = 0;\n\t\tthis.lit_bufsize = 0;\n\t\tthis.sym_next = 0;\n\t\tthis.sym_end = 0;\n\t\tthis.opt_len = 0;\n\t\tthis.static_len = 0;\n\t\tthis.matches = 0;\n\t\tthis.insert = 0;\n\t\tthis.bi_buf = 0;\n\t\tthis.bi_valid = 0;\n\t}\n};\nvar deflateStateCheck = (strm) => {\n\tif (!strm) return 1;\n\tconst s = strm.state;\n\tif (!s || s.strm !== strm || s.status !== INIT_STATE && s.status !== GZIP_STATE && s.status !== EXTRA_STATE && s.status !== NAME_STATE && s.status !== COMMENT_STATE && s.status !== HCRC_STATE && s.status !== BUSY_STATE && s.status !== FINISH_STATE) return 1;\n\treturn 0;\n};\nvar deflateResetKeep = (strm) => {\n\tif (deflateStateCheck(strm)) return err(strm, -2);\n\tstrm.total_in = strm.total_out = 0;\n\tstrm.data_type = 2;\n\tconst s = strm.state;\n\ts.pending = 0;\n\ts.pending_out = 0;\n\tif (s.wrap < 0) s.wrap = -s.wrap;\n\ts.status = s.wrap === 2 ? GZIP_STATE : s.wrap ? INIT_STATE : BUSY_STATE;\n\tstrm.adler = s.wrap === 2 ? 0 : 1;\n\ts.last_flush = -2;\n\t_tr_init(s);\n\treturn 0;\n};\nvar deflateReset = (strm) => {\n\tconst ret = deflateResetKeep(strm);\n\tif (ret === 0) lm_init(strm.state);\n\treturn ret;\n};\nvar deflateSetHeader = (strm, head) => {\n\tif (deflateStateCheck(strm) || strm.state.wrap !== 2) return -2;\n\tstrm.state.gzhead = head;\n\treturn 0;\n};\nvar deflateInit2 = (strm, level, method, windowBits, memLevel, strategy, legacyHash) => {\n\tif (!strm) return -2;\n\tlet wrap = 1;\n\tif (level === -1) level = 6;\n\tif (windowBits < 0) {\n\t\twrap = 0;\n\t\twindowBits = -windowBits;\n\t} else if (windowBits > 15) {\n\t\twrap = 2;\n\t\twindowBits -= 16;\n\t}\n\tif (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== 8 || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > 4 || windowBits === 8 && wrap !== 1) return err(strm, -2);\n\tif (windowBits === 8) windowBits = 9;\n\tconst s = new DeflateState();\n\tstrm.state = s;\n\ts.strm = strm;\n\ts.status = INIT_STATE;\n\ts.wrap = wrap;\n\ts.gzhead = null;\n\ts.w_bits = windowBits;\n\ts.w_size = 1 << s.w_bits;\n\ts.w_mask = s.w_size - 1;\n\ts.legacy_hash = legacyHash ? 1 : 0;\n\ts.hash_bits = memLevel + 7;\n\tif (!s.legacy_hash && s.hash_bits < 15) s.hash_bits = 15;\n\ts.hash_size = 1 << s.hash_bits;\n\ts.hash_mask = s.hash_size - 1;\n\ts.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);\n\ts.window = new Uint8Array(s.w_size * 2);\n\ts.head = new Uint16Array(s.hash_size);\n\ts.prev = new Uint16Array(s.w_size);\n\ts.lit_bufsize = 1 << memLevel + 6;\n\ts.pending_buf_size = s.lit_bufsize * 4;\n\ts.pending_buf = new Uint8Array(s.pending_buf_size);\n\ts.sym_buf = s.lit_bufsize;\n\ts.sym_end = (s.lit_bufsize - 1) * 3;\n\ts.level = level;\n\ts.strategy = strategy;\n\ts.method = method;\n\treturn deflateReset(strm);\n};\nvar deflateInit = (strm, level) => {\n\treturn deflateInit2(strm, level, 8, MAX_WBITS, DEF_MEM_LEVEL, 0);\n};\nvar deflate$1 = (strm, flush) => {\n\tif (deflateStateCheck(strm) || flush > 5 || flush < 0) return strm ? err(strm, -2) : -2;\n\tconst s = strm.state;\n\tif (!strm.output || strm.avail_in !== 0 && !strm.input || s.status === FINISH_STATE && flush !== 4) return err(strm, strm.avail_out === 0 ? -5 : -2);\n\tconst old_flush = s.last_flush;\n\ts.last_flush = flush;\n\tif (s.pending !== 0) {\n\t\tflush_pending(strm);\n\t\tif (strm.avail_out === 0) {\n\t\t\ts.last_flush = -1;\n\t\t\treturn 0;\n\t\t}\n\t} else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== 4) return err(strm, -5);\n\tif (s.status === FINISH_STATE && strm.avail_in !== 0) return err(strm, -5);\n\tif (s.status === INIT_STATE && s.wrap === 0) s.status = BUSY_STATE;\n\tif (s.status === INIT_STATE) {\n\t\tlet header = 8 + (s.w_bits - 8 << 4) << 8;\n\t\tlet level_flags = -1;\n\t\tif (s.strategy >= 2 || s.level < 2) level_flags = 0;\n\t\telse if (s.level < 6) level_flags = 1;\n\t\telse if (s.level === 6) level_flags = 2;\n\t\telse level_flags = 3;\n\t\theader |= level_flags << 6;\n\t\tif (s.strstart !== 0) header |= PRESET_DICT;\n\t\theader += 31 - header % 31;\n\t\tputShortMSB(s, header);\n\t\tif (s.strstart !== 0) {\n\t\t\tputShortMSB(s, strm.adler >>> 16);\n\t\t\tputShortMSB(s, strm.adler & 65535);\n\t\t}\n\t\tstrm.adler = 1;\n\t\ts.status = BUSY_STATE;\n\t\tflush_pending(strm);\n\t\tif (s.pending !== 0) {\n\t\t\ts.last_flush = -1;\n\t\t\treturn 0;\n\t\t}\n\t}\n\tif (s.status === GZIP_STATE) {\n\t\tstrm.adler = 0;\n\t\tput_byte(s, 31);\n\t\tput_byte(s, 139);\n\t\tput_byte(s, 8);\n\t\tif (!s.gzhead) {\n\t\t\tput_byte(s, 0);\n\t\t\tput_byte(s, 0);\n\t\t\tput_byte(s, 0);\n\t\t\tput_byte(s, 0);\n\t\t\tput_byte(s, 0);\n\t\t\tput_byte(s, s.level === 9 ? 2 : s.strategy >= 2 || s.level < 2 ? 4 : 0);\n\t\t\tput_byte(s, OS_CODE);\n\t\t\ts.status = BUSY_STATE;\n\t\t\tflush_pending(strm);\n\t\t\tif (s.pending !== 0) {\n\t\t\t\ts.last_flush = -1;\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t} else {\n\t\t\tput_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16));\n\t\t\tput_byte(s, s.gzhead.time & 255);\n\t\t\tput_byte(s, s.gzhead.time >> 8 & 255);\n\t\t\tput_byte(s, s.gzhead.time >> 16 & 255);\n\t\t\tput_byte(s, s.gzhead.time >> 24 & 255);\n\t\t\tput_byte(s, s.level === 9 ? 2 : s.strategy >= 2 || s.level < 2 ? 4 : 0);\n\t\t\tput_byte(s, s.gzhead.os & 255);\n\t\t\tif (s.gzhead.extra && s.gzhead.extra.length) {\n\t\t\t\tput_byte(s, s.gzhead.extra.length & 255);\n\t\t\t\tput_byte(s, s.gzhead.extra.length >> 8 & 255);\n\t\t\t}\n\t\t\tif (s.gzhead.hcrc) strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);\n\t\t\ts.gzindex = 0;\n\t\t\ts.status = EXTRA_STATE;\n\t\t}\n\t}\n\tif (s.status === EXTRA_STATE) {\n\t\tif (s.gzhead.extra) {\n\t\t\tlet beg = s.pending;\n\t\t\tlet left = (s.gzhead.extra.length & 65535) - s.gzindex;\n\t\t\twhile (s.pending + left > s.pending_buf_size) {\n\t\t\t\tlet copy = s.pending_buf_size - s.pending;\n\t\t\t\ts.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);\n\t\t\t\ts.pending = s.pending_buf_size;\n\t\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t\t\ts.gzindex += copy;\n\t\t\t\tflush_pending(strm);\n\t\t\t\tif (s.pending !== 0) {\n\t\t\t\t\ts.last_flush = -1;\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\t\t\t\tbeg = 0;\n\t\t\t\tleft -= copy;\n\t\t\t}\n\t\t\tlet gzhead_extra = new Uint8Array(s.gzhead.extra);\n\t\t\ts.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending);\n\t\t\ts.pending += left;\n\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t\ts.gzindex = 0;\n\t\t}\n\t\ts.status = NAME_STATE;\n\t}\n\tif (s.status === NAME_STATE) {\n\t\tif (s.gzhead.name) {\n\t\t\tlet beg = s.pending;\n\t\t\tlet val;\n\t\t\tdo {\n\t\t\t\tif (s.pending === s.pending_buf_size) {\n\t\t\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t\t\t\tflush_pending(strm);\n\t\t\t\t\tif (s.pending !== 0) {\n\t\t\t\t\t\ts.last_flush = -1;\n\t\t\t\t\t\treturn 0;\n\t\t\t\t\t}\n\t\t\t\t\tbeg = 0;\n\t\t\t\t}\n\t\t\t\tif (s.gzindex < s.gzhead.name.length) val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;\n\t\t\t\telse val = 0;\n\t\t\t\tput_byte(s, val);\n\t\t\t} while (val !== 0);\n\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t\ts.gzindex = 0;\n\t\t}\n\t\ts.status = COMMENT_STATE;\n\t}\n\tif (s.status === COMMENT_STATE) {\n\t\tif (s.gzhead.comment) {\n\t\t\tlet beg = s.pending;\n\t\t\tlet val;\n\t\t\tdo {\n\t\t\t\tif (s.pending === s.pending_buf_size) {\n\t\t\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t\t\t\tflush_pending(strm);\n\t\t\t\t\tif (s.pending !== 0) {\n\t\t\t\t\t\ts.last_flush = -1;\n\t\t\t\t\t\treturn 0;\n\t\t\t\t\t}\n\t\t\t\t\tbeg = 0;\n\t\t\t\t}\n\t\t\t\tif (s.gzindex < s.gzhead.comment.length) val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;\n\t\t\t\telse val = 0;\n\t\t\t\tput_byte(s, val);\n\t\t\t} while (val !== 0);\n\t\t\tif (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);\n\t\t}\n\t\ts.status = HCRC_STATE;\n\t}\n\tif (s.status === HCRC_STATE) {\n\t\tif (s.gzhead.hcrc) {\n\t\t\tif (s.pending + 2 > s.pending_buf_size) {\n\t\t\t\tflush_pending(strm);\n\t\t\t\tif (s.pending !== 0) {\n\t\t\t\t\ts.last_flush = -1;\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tput_byte(s, strm.adler & 255);\n\t\t\tput_byte(s, strm.adler >> 8 & 255);\n\t\t\tstrm.adler = 0;\n\t\t}\n\t\ts.status = BUSY_STATE;\n\t\tflush_pending(strm);\n\t\tif (s.pending !== 0) {\n\t\t\ts.last_flush = -1;\n\t\t\treturn 0;\n\t\t}\n\t}\n\tif (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== 0 && s.status !== FINISH_STATE) {\n\t\tlet bstate = s.level === 0 ? deflate_stored(s, flush) : s.strategy === 2 ? deflate_huff(s, flush) : s.strategy === 3 ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush);\n\t\tif (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) s.status = FINISH_STATE;\n\t\tif (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n\t\t\tif (strm.avail_out === 0) s.last_flush = -1;\n\t\t\treturn 0;\n\t\t}\n\t\tif (bstate === BS_BLOCK_DONE) {\n\t\t\tif (flush === 1) _tr_align(s);\n\t\t\telse if (flush !== 5) {\n\t\t\t\t_tr_stored_block(s, 0, 0, false);\n\t\t\t\tif (flush === 3) {\n\t\t\t\t\t/*** CLEAR_HASH(s); ***/ zero(s.head);\n\t\t\t\t\tif (s.lookahead === 0) {\n\t\t\t\t\t\ts.strstart = 0;\n\t\t\t\t\t\ts.block_start = 0;\n\t\t\t\t\t\ts.insert = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tflush_pending(strm);\n\t\t\tif (strm.avail_out === 0) {\n\t\t\t\ts.last_flush = -1;\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t}\n\tif (flush !== 4) return 0;\n\tif (s.wrap <= 0) return 1;\n\tif (s.wrap === 2) {\n\t\tput_byte(s, strm.adler & 255);\n\t\tput_byte(s, strm.adler >> 8 & 255);\n\t\tput_byte(s, strm.adler >> 16 & 255);\n\t\tput_byte(s, strm.adler >> 24 & 255);\n\t\tput_byte(s, strm.total_in & 255);\n\t\tput_byte(s, strm.total_in >> 8 & 255);\n\t\tput_byte(s, strm.total_in >> 16 & 255);\n\t\tput_byte(s, strm.total_in >> 24 & 255);\n\t} else {\n\t\tputShortMSB(s, strm.adler >>> 16);\n\t\tputShortMSB(s, strm.adler & 65535);\n\t}\n\tflush_pending(strm);\n\tif (s.wrap > 0) s.wrap = -s.wrap;\n\treturn s.pending !== 0 ? 0 : 1;\n};\nvar deflateEnd = (strm) => {\n\tif (deflateStateCheck(strm)) return -2;\n\tconst status = strm.state.status;\n\tstrm.state = null;\n\treturn status === BUSY_STATE ? err(strm, -3) : 0;\n};\nvar deflateSetDictionary = (strm, dictionary) => {\n\tlet dictLength = dictionary.length;\n\tif (deflateStateCheck(strm)) return -2;\n\tconst s = strm.state;\n\tconst wrap = s.wrap;\n\tif (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) return -2;\n\tif (wrap === 1) strm.adler = adler32(strm.adler, dictionary, dictLength, 0);\n\ts.wrap = 0;\n\tif (dictLength >= s.w_size) {\n\t\tif (wrap === 0) {\n\t\t\t/*** CLEAR_HASH(s); ***/\n\t\t\tzero(s.head);\n\t\t\ts.strstart = 0;\n\t\t\ts.block_start = 0;\n\t\t\ts.insert = 0;\n\t\t}\n\t\tlet tmpDict = new Uint8Array(s.w_size);\n\t\ttmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);\n\t\tdictionary = tmpDict;\n\t\tdictLength = s.w_size;\n\t}\n\tconst avail = strm.avail_in;\n\tconst next = strm.next_in;\n\tconst input = strm.input;\n\tstrm.avail_in = dictLength;\n\tstrm.next_in = 0;\n\tstrm.input = dictionary;\n\tfill_window(s);\n\twhile (s.lookahead >= MIN_MATCH) {\n\t\tlet str = s.strstart;\n\t\tlet n = s.lookahead - (MIN_MATCH - 1);\n\t\tdo {\n\t\t\tINSERT_STRING(s, str);\n\t\t\tstr++;\n\t\t} while (--n);\n\t\ts.strstart = str;\n\t\ts.lookahead = MIN_MATCH - 1;\n\t\tfill_window(s);\n\t}\n\ts.strstart += s.lookahead;\n\ts.block_start = s.strstart;\n\ts.insert = s.lookahead;\n\ts.lookahead = 0;\n\ts.match_length = s.prev_length = MIN_MATCH - 1;\n\ts.match_available = 0;\n\tstrm.next_in = next;\n\tstrm.input = input;\n\tstrm.avail_in = avail;\n\ts.wrap = wrap;\n\treturn 0;\n};\n//#endregion\n//#region src/zlib/inffast.mjs\nvar BAD$1 = 16209;\nvar TYPE$1 = 16191;\nfunction inflate_fast(strm, start) {\n\tlet _in;\n\tlet last;\n\tlet _out;\n\tlet beg;\n\tlet end;\n\tlet dmax;\n\tlet wsize;\n\tlet whave;\n\tlet wnext;\n\tlet s_window;\n\tlet hold;\n\tlet bits;\n\tlet lcode;\n\tlet dcode;\n\tlet lmask;\n\tlet dmask;\n\tlet here;\n\tlet op;\n\tlet len;\n\tlet dist;\n\tlet from;\n\tlet from_source;\n\tlet input, output;\n\tconst state = strm.state;\n\t_in = strm.next_in;\n\tinput = strm.input;\n\tlast = _in + (strm.avail_in - 5);\n\t_out = strm.next_out;\n\toutput = strm.output;\n\tbeg = _out - (start - strm.avail_out);\n\tend = _out + (strm.avail_out - 257);\n\tdmax = state.dmax;\n\twsize = state.wsize;\n\twhave = state.whave;\n\twnext = state.wnext;\n\ts_window = state.window;\n\thold = state.hold;\n\tbits = state.bits;\n\tlcode = state.lencode;\n\tdcode = state.distcode;\n\tlmask = (1 << state.lenbits) - 1;\n\tdmask = (1 << state.distbits) - 1;\n\ttop: do {\n\t\tif (bits < 15) {\n\t\t\thold += input[_in++] << bits;\n\t\t\tbits += 8;\n\t\t\thold += input[_in++] << bits;\n\t\t\tbits += 8;\n\t\t}\n\t\there = lcode[hold & lmask];\n\t\tdolen: for (;;) {\n\t\t\top = here >>> 24;\n\t\t\thold >>>= op;\n\t\t\tbits -= op;\n\t\t\top = here >>> 16 & 255;\n\t\t\tif (op === 0) output[_out++] = here & 65535;\n\t\t\telse if (op & 16) {\n\t\t\t\tlen = here & 65535;\n\t\t\t\top &= 15;\n\t\t\t\tif (op) {\n\t\t\t\t\tif (bits < op) {\n\t\t\t\t\t\thold += input[_in++] << bits;\n\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t}\n\t\t\t\t\tlen += hold & (1 << op) - 1;\n\t\t\t\t\thold >>>= op;\n\t\t\t\t\tbits -= op;\n\t\t\t\t}\n\t\t\t\tif (bits < 15) {\n\t\t\t\t\thold += input[_in++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t\thold += input[_in++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\there = dcode[hold & dmask];\n\t\t\t\tdodist: for (;;) {\n\t\t\t\t\top = here >>> 24;\n\t\t\t\t\thold >>>= op;\n\t\t\t\t\tbits -= op;\n\t\t\t\t\top = here >>> 16 & 255;\n\t\t\t\t\tif (op & 16) {\n\t\t\t\t\t\tdist = here & 65535;\n\t\t\t\t\t\top &= 15;\n\t\t\t\t\t\tif (bits < op) {\n\t\t\t\t\t\t\thold += input[_in++] << bits;\n\t\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t\t\tif (bits < op) {\n\t\t\t\t\t\t\t\thold += input[_in++] << bits;\n\t\t\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdist += hold & (1 << op) - 1;\n\t\t\t\t\t\tif (dist > dmax) {\n\t\t\t\t\t\t\tstrm.msg = \"invalid distance too far back\";\n\t\t\t\t\t\t\tstate.mode = BAD$1;\n\t\t\t\t\t\t\tbreak top;\n\t\t\t\t\t\t}\n\t\t\t\t\t\thold >>>= op;\n\t\t\t\t\t\tbits -= op;\n\t\t\t\t\t\top = _out - beg;\n\t\t\t\t\t\tif (dist > op) {\n\t\t\t\t\t\t\top = dist - op;\n\t\t\t\t\t\t\tif (op > whave) {\n\t\t\t\t\t\t\t\tif (state.sane) {\n\t\t\t\t\t\t\t\t\tstrm.msg = \"invalid distance too far back\";\n\t\t\t\t\t\t\t\t\tstate.mode = BAD$1;\n\t\t\t\t\t\t\t\t\tbreak top;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tfrom = 0;\n\t\t\t\t\t\t\tfrom_source = s_window;\n\t\t\t\t\t\t\tif (wnext === 0) {\n\t\t\t\t\t\t\t\tfrom += wsize - op;\n\t\t\t\t\t\t\t\tif (op < len) {\n\t\t\t\t\t\t\t\t\tlen -= op;\n\t\t\t\t\t\t\t\t\tdo\n\t\t\t\t\t\t\t\t\t\toutput[_out++] = s_window[from++];\n\t\t\t\t\t\t\t\t\twhile (--op);\n\t\t\t\t\t\t\t\t\tfrom = _out - dist;\n\t\t\t\t\t\t\t\t\tfrom_source = output;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if (wnext < op) {\n\t\t\t\t\t\t\t\tfrom += wsize + wnext - op;\n\t\t\t\t\t\t\t\top -= wnext;\n\t\t\t\t\t\t\t\tif (op < len) {\n\t\t\t\t\t\t\t\t\tlen -= op;\n\t\t\t\t\t\t\t\t\tdo\n\t\t\t\t\t\t\t\t\t\toutput[_out++] = s_window[from++];\n\t\t\t\t\t\t\t\t\twhile (--op);\n\t\t\t\t\t\t\t\t\tfrom = 0;\n\t\t\t\t\t\t\t\t\tif (wnext < len) {\n\t\t\t\t\t\t\t\t\t\top = wnext;\n\t\t\t\t\t\t\t\t\t\tlen -= op;\n\t\t\t\t\t\t\t\t\t\tdo\n\t\t\t\t\t\t\t\t\t\t\toutput[_out++] = s_window[from++];\n\t\t\t\t\t\t\t\t\t\twhile (--op);\n\t\t\t\t\t\t\t\t\t\tfrom = _out - dist;\n\t\t\t\t\t\t\t\t\t\tfrom_source = output;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tfrom += wnext - op;\n\t\t\t\t\t\t\t\tif (op < len) {\n\t\t\t\t\t\t\t\t\tlen -= op;\n\t\t\t\t\t\t\t\t\tdo\n\t\t\t\t\t\t\t\t\t\toutput[_out++] = s_window[from++];\n\t\t\t\t\t\t\t\t\twhile (--op);\n\t\t\t\t\t\t\t\t\tfrom = _out - dist;\n\t\t\t\t\t\t\t\t\tfrom_source = output;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\twhile (len > 2) {\n\t\t\t\t\t\t\t\toutput[_out++] = from_source[from++];\n\t\t\t\t\t\t\t\toutput[_out++] = from_source[from++];\n\t\t\t\t\t\t\t\toutput[_out++] = from_source[from++];\n\t\t\t\t\t\t\t\tlen -= 3;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (len) {\n\t\t\t\t\t\t\t\toutput[_out++] = from_source[from++];\n\t\t\t\t\t\t\t\tif (len > 1) output[_out++] = from_source[from++];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tfrom = _out - dist;\n\t\t\t\t\t\t\tdo {\n\t\t\t\t\t\t\t\toutput[_out++] = output[from++];\n\t\t\t\t\t\t\t\toutput[_out++] = output[from++];\n\t\t\t\t\t\t\t\toutput[_out++] = output[from++];\n\t\t\t\t\t\t\t\tlen -= 3;\n\t\t\t\t\t\t\t} while (len > 2);\n\t\t\t\t\t\t\tif (len) {\n\t\t\t\t\t\t\t\toutput[_out++] = output[from++];\n\t\t\t\t\t\t\t\tif (len > 1) output[_out++] = output[from++];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if ((op & 64) === 0) {\n\t\t\t\t\t\there = dcode[(here & 65535) + (hold & (1 << op) - 1)];\n\t\t\t\t\t\tcontinue dodist;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstrm.msg = \"invalid distance code\";\n\t\t\t\t\t\tstate.mode = BAD$1;\n\t\t\t\t\t\tbreak top;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else if ((op & 64) === 0) {\n\t\t\t\there = lcode[(here & 65535) + (hold & (1 << op) - 1)];\n\t\t\t\tcontinue dolen;\n\t\t\t} else if (op & 32) {\n\t\t\t\tstate.mode = TYPE$1;\n\t\t\t\tbreak top;\n\t\t\t} else {\n\t\t\t\tstrm.msg = \"invalid literal/length code\";\n\t\t\t\tstate.mode = BAD$1;\n\t\t\t\tbreak top;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t} while (_in < last && _out < end);\n\tlen = bits >> 3;\n\t_in -= len;\n\tbits -= len << 3;\n\thold &= (1 << bits) - 1;\n\tstrm.next_in = _in;\n\tstrm.next_out = _out;\n\tstrm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);\n\tstrm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);\n\tstate.hold = hold;\n\tstate.bits = bits;\n}\n//#endregion\n//#region src/zlib/inftrees.mjs\nvar MAXBITS = 15;\nvar ENOUGH_LENS$1 = 852;\nvar ENOUGH_DISTS$1 = 592;\nvar CODES$1 = 0;\nvar LENS$1 = 1;\nvar DISTS$1 = 2;\nvar lbase = new Uint16Array([\n\t3,\n\t4,\n\t5,\n\t6,\n\t7,\n\t8,\n\t9,\n\t10,\n\t11,\n\t13,\n\t15,\n\t17,\n\t19,\n\t23,\n\t27,\n\t31,\n\t35,\n\t43,\n\t51,\n\t59,\n\t67,\n\t83,\n\t99,\n\t115,\n\t131,\n\t163,\n\t195,\n\t227,\n\t258,\n\t0,\n\t0\n]);\nvar lext = new Uint8Array([\n\t16,\n\t16,\n\t16,\n\t16,\n\t16,\n\t16,\n\t16,\n\t16,\n\t17,\n\t17,\n\t17,\n\t17,\n\t18,\n\t18,\n\t18,\n\t18,\n\t19,\n\t19,\n\t19,\n\t19,\n\t20,\n\t20,\n\t20,\n\t20,\n\t21,\n\t21,\n\t21,\n\t21,\n\t16,\n\t199,\n\t75\n]);\nvar dbase = new Uint16Array([\n\t1,\n\t2,\n\t3,\n\t4,\n\t5,\n\t7,\n\t9,\n\t13,\n\t17,\n\t25,\n\t33,\n\t49,\n\t65,\n\t97,\n\t129,\n\t193,\n\t257,\n\t385,\n\t513,\n\t769,\n\t1025,\n\t1537,\n\t2049,\n\t3073,\n\t4097,\n\t6145,\n\t8193,\n\t12289,\n\t16385,\n\t24577,\n\t0,\n\t0\n]);\nvar dext = new Uint8Array([\n\t16,\n\t16,\n\t16,\n\t16,\n\t17,\n\t17,\n\t18,\n\t18,\n\t19,\n\t19,\n\t20,\n\t20,\n\t21,\n\t21,\n\t22,\n\t22,\n\t23,\n\t23,\n\t24,\n\t24,\n\t25,\n\t25,\n\t26,\n\t26,\n\t27,\n\t27,\n\t28,\n\t28,\n\t29,\n\t29,\n\t64,\n\t64\n]);\nvar inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) => {\n\tconst bits = opts.bits;\n\tlet len = 0;\n\tlet sym = 0;\n\tlet min = 0, max = 0;\n\tlet root = 0;\n\tlet curr = 0;\n\tlet drop = 0;\n\tlet left = 0;\n\tlet used = 0;\n\tlet huff = 0;\n\tlet incr;\n\tlet fill;\n\tlet low;\n\tlet mask;\n\tlet next;\n\tlet base = null;\n\tlet match;\n\tconst count = /* @__PURE__ */ new Uint16Array(16);\n\tconst offs = /* @__PURE__ */ new Uint16Array(16);\n\tlet extra = null;\n\tlet here_bits, here_op, here_val;\n\tfor (len = 0; len <= MAXBITS; len++) count[len] = 0;\n\tfor (sym = 0; sym < codes; sym++) count[lens[lens_index + sym]]++;\n\troot = bits;\n\tfor (max = MAXBITS; max >= 1; max--) if (count[max] !== 0) break;\n\tif (root > max) root = max;\n\tif (max === 0) {\n\t\ttable[table_index++] = 20971520;\n\t\ttable[table_index++] = 20971520;\n\t\topts.bits = 1;\n\t\treturn 0;\n\t}\n\tfor (min = 1; min < max; min++) if (count[min] !== 0) break;\n\tif (root < min) root = min;\n\tleft = 1;\n\tfor (len = 1; len <= MAXBITS; len++) {\n\t\tleft <<= 1;\n\t\tleft -= count[len];\n\t\tif (left < 0) return -1;\n\t}\n\tif (left > 0 && (type === CODES$1 || max !== 1)) return -1;\n\toffs[1] = 0;\n\tfor (len = 1; len < MAXBITS; len++) offs[len + 1] = offs[len] + count[len];\n\tfor (sym = 0; sym < codes; sym++) if (lens[lens_index + sym] !== 0) work[offs[lens[lens_index + sym]]++] = sym;\n\tif (type === CODES$1) {\n\t\tbase = extra = work;\n\t\tmatch = 20;\n\t} else if (type === LENS$1) {\n\t\tbase = lbase;\n\t\textra = lext;\n\t\tmatch = 257;\n\t} else {\n\t\tbase = dbase;\n\t\textra = dext;\n\t\tmatch = 0;\n\t}\n\thuff = 0;\n\tsym = 0;\n\tlen = min;\n\tnext = table_index;\n\tcurr = root;\n\tdrop = 0;\n\tlow = -1;\n\tused = 1 << root;\n\tmask = used - 1;\n\tif (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) return 1;\n\tfor (;;) {\n\t\there_bits = len - drop;\n\t\tif (work[sym] + 1 < match) {\n\t\t\there_op = 0;\n\t\t\there_val = work[sym];\n\t\t} else if (work[sym] >= match) {\n\t\t\there_op = extra[work[sym] - match];\n\t\t\there_val = base[work[sym] - match];\n\t\t} else {\n\t\t\there_op = 96;\n\t\t\there_val = 0;\n\t\t}\n\t\tincr = 1 << len - drop;\n\t\tfill = 1 << curr;\n\t\tmin = fill;\n\t\tdo {\n\t\t\tfill -= incr;\n\t\t\ttable[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;\n\t\t} while (fill !== 0);\n\t\tincr = 1 << len - 1;\n\t\twhile (huff & incr) incr >>= 1;\n\t\tif (incr !== 0) {\n\t\t\thuff &= incr - 1;\n\t\t\thuff += incr;\n\t\t} else huff = 0;\n\t\tsym++;\n\t\tif (--count[len] === 0) {\n\t\t\tif (len === max) break;\n\t\t\tlen = lens[lens_index + work[sym]];\n\t\t}\n\t\tif (len > root && (huff & mask) !== low) {\n\t\t\tif (drop === 0) drop = root;\n\t\t\tnext += min;\n\t\t\tcurr = len - drop;\n\t\t\tleft = 1 << curr;\n\t\t\twhile (curr + drop < max) {\n\t\t\t\tleft -= count[curr + drop];\n\t\t\t\tif (left <= 0) break;\n\t\t\t\tcurr++;\n\t\t\t\tleft <<= 1;\n\t\t\t}\n\t\t\tused += 1 << curr;\n\t\t\tif (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) return 1;\n\t\t\tlow = huff & mask;\n\t\t\ttable[low] = root << 24 | curr << 16 | next - table_index | 0;\n\t\t}\n\t}\n\tif (huff !== 0) table[next + huff] = len - drop << 24 | 4194304;\n\topts.bits = root;\n\treturn 0;\n};\n//#endregion\n//#region src/zlib/inflate.mjs\nvar CODES = 0;\nvar LENS = 1;\nvar DISTS = 2;\nvar HEAD = 16180;\nvar FLAGS = 16181;\nvar TIME = 16182;\nvar OS = 16183;\nvar EXLEN = 16184;\nvar EXTRA = 16185;\nvar NAME = 16186;\nvar COMMENT = 16187;\nvar HCRC = 16188;\nvar DICTID = 16189;\nvar DICT = 16190;\nvar TYPE = 16191;\nvar TYPEDO = 16192;\nvar STORED = 16193;\nvar COPY_ = 16194;\nvar COPY = 16195;\nvar TABLE = 16196;\nvar LENLENS = 16197;\nvar CODELENS = 16198;\nvar LEN_ = 16199;\nvar LEN = 16200;\nvar LENEXT = 16201;\nvar DIST = 16202;\nvar DISTEXT = 16203;\nvar MATCH = 16204;\nvar LIT = 16205;\nvar CHECK = 16206;\nvar LENGTH = 16207;\nvar DONE = 16208;\nvar BAD = 16209;\nvar MEM = 16210;\nvar SYNC = 16211;\nvar ENOUGH_LENS = 852;\nvar ENOUGH_DISTS = 592;\nvar DEF_WBITS = 15;\nvar zswap32 = (q) => {\n\treturn (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);\n};\nvar InflateState = class {\n\tconstructor() {\n\t\tthis.strm = null;\n\t\tthis.mode = 0;\n\t\tthis.last = false;\n\t\tthis.wrap = 0;\n\t\tthis.havedict = false;\n\t\tthis.flags = 0;\n\t\tthis.dmax = 0;\n\t\tthis.check = 0;\n\t\tthis.total = 0;\n\t\tthis.head = null;\n\t\tthis.wbits = 0;\n\t\tthis.wsize = 0;\n\t\tthis.whave = 0;\n\t\tthis.wnext = 0;\n\t\tthis.window = null;\n\t\tthis.hold = 0;\n\t\tthis.bits = 0;\n\t\tthis.length = 0;\n\t\tthis.offset = 0;\n\t\tthis.extra = 0;\n\t\tthis.lencode = null;\n\t\tthis.distcode = null;\n\t\tthis.lenbits = 0;\n\t\tthis.distbits = 0;\n\t\tthis.ncode = 0;\n\t\tthis.nlen = 0;\n\t\tthis.ndist = 0;\n\t\tthis.have = 0;\n\t\tthis.next = null;\n\t\tthis.lens = /* @__PURE__ */ new Uint16Array(320);\n\t\tthis.work = /* @__PURE__ */ new Uint16Array(288);\n\t\tthis.lendyn = null;\n\t\tthis.distdyn = null;\n\t\tthis.sane = 0;\n\t\tthis.back = 0;\n\t\tthis.was = 0;\n\t}\n};\nvar inflateStateCheck = (strm) => {\n\tif (!strm) return 1;\n\tconst state = strm.state;\n\tif (!state || state.strm !== strm || state.mode < HEAD || state.mode > SYNC) return 1;\n\treturn 0;\n};\nvar inflateResetKeep = (strm) => {\n\tif (inflateStateCheck(strm)) return -2;\n\tconst state = strm.state;\n\tstrm.total_in = strm.total_out = state.total = 0;\n\tstrm.msg = \"\";\n\tif (state.wrap) strm.adler = state.wrap & 1;\n\tstate.mode = HEAD;\n\tstate.last = 0;\n\tstate.havedict = 0;\n\tstate.flags = -1;\n\tstate.dmax = 32768;\n\tstate.head = null;\n\tstate.hold = 0;\n\tstate.bits = 0;\n\tstate.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);\n\tstate.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);\n\tstate.sane = 1;\n\tstate.back = -1;\n\treturn 0;\n};\nvar inflateReset = (strm) => {\n\tif (inflateStateCheck(strm)) return -2;\n\tconst state = strm.state;\n\tstate.wsize = 0;\n\tstate.whave = 0;\n\tstate.wnext = 0;\n\treturn inflateResetKeep(strm);\n};\nvar inflateReset2 = (strm, windowBits) => {\n\tlet wrap;\n\tif (inflateStateCheck(strm)) return -2;\n\tconst state = strm.state;\n\tif (windowBits < 0) {\n\t\twrap = 0;\n\t\twindowBits = -windowBits;\n\t} else {\n\t\twrap = (windowBits >> 4) + 5;\n\t\tif (windowBits < 48) windowBits &= 15;\n\t}\n\tif (windowBits && (windowBits < 8 || windowBits > 15)) return -2;\n\tif (state.window !== null && state.wbits !== windowBits) state.window = null;\n\tstate.wrap = wrap;\n\tstate.wbits = windowBits;\n\treturn inflateReset(strm);\n};\nvar inflateInit2 = (strm, windowBits) => {\n\tif (!strm) return -2;\n\tconst state = new InflateState();\n\tstrm.state = state;\n\tstate.strm = strm;\n\tstate.window = null;\n\tstate.mode = HEAD;\n\tconst ret = inflateReset2(strm, windowBits);\n\tif (ret !== 0) strm.state = null;\n\treturn ret;\n};\nvar inflateInit = (strm) => {\n\treturn inflateInit2(strm, DEF_WBITS);\n};\nvar virgin = true;\nvar lenfix, distfix;\nvar fixedtables = (state) => {\n\tif (virgin) {\n\t\tlenfix = /* @__PURE__ */ new Int32Array(512);\n\t\tdistfix = /* @__PURE__ */ new Int32Array(32);\n\t\tlet sym = 0;\n\t\twhile (sym < 144) state.lens[sym++] = 8;\n\t\twhile (sym < 256) state.lens[sym++] = 9;\n\t\twhile (sym < 280) state.lens[sym++] = 7;\n\t\twhile (sym < 288) state.lens[sym++] = 8;\n\t\tinflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });\n\t\tsym = 0;\n\t\twhile (sym < 32) state.lens[sym++] = 5;\n\t\tinflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });\n\t\tvirgin = false;\n\t}\n\tstate.lencode = lenfix;\n\tstate.lenbits = 9;\n\tstate.distcode = distfix;\n\tstate.distbits = 5;\n};\nvar updatewindow = (strm, src, end, copy) => {\n\tlet dist;\n\tconst state = strm.state;\n\tif (state.window === null) state.window = new Uint8Array(1 << state.wbits);\n\tif (state.wsize === 0) {\n\t\tstate.wsize = 1 << state.wbits;\n\t\tstate.wnext = 0;\n\t\tstate.whave = 0;\n\t}\n\tif (copy >= state.wsize) {\n\t\tstate.window.set(src.subarray(end - state.wsize, end), 0);\n\t\tstate.wnext = 0;\n\t\tstate.whave = state.wsize;\n\t} else {\n\t\tdist = state.wsize - state.wnext;\n\t\tif (dist > copy) dist = copy;\n\t\tstate.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);\n\t\tcopy -= dist;\n\t\tif (copy) {\n\t\t\tstate.window.set(src.subarray(end - copy, end), 0);\n\t\t\tstate.wnext = copy;\n\t\t\tstate.whave = state.wsize;\n\t\t} else {\n\t\t\tstate.wnext += dist;\n\t\t\tif (state.wnext === state.wsize) state.wnext = 0;\n\t\t\tif (state.whave < state.wsize) state.whave += dist;\n\t\t}\n\t}\n\treturn 0;\n};\nvar inflate$1 = (strm, flush) => {\n\tlet state;\n\tlet input, output;\n\tlet next;\n\tlet put;\n\tlet have, left;\n\tlet hold;\n\tlet bits;\n\tlet _in, _out;\n\tlet copy;\n\tlet from;\n\tlet from_source;\n\tlet here = 0;\n\tlet here_bits, here_op, here_val;\n\tlet last_bits, last_op, last_val;\n\tlet len;\n\tlet ret;\n\tconst hbuf = /* @__PURE__ */ new Uint8Array(4);\n\tlet opts;\n\tlet n;\n\tconst order = new Uint8Array([\n\t\t16,\n\t\t17,\n\t\t18,\n\t\t0,\n\t\t8,\n\t\t7,\n\t\t9,\n\t\t6,\n\t\t10,\n\t\t5,\n\t\t11,\n\t\t4,\n\t\t12,\n\t\t3,\n\t\t13,\n\t\t2,\n\t\t14,\n\t\t1,\n\t\t15\n\t]);\n\tif (inflateStateCheck(strm) || !strm.output || !strm.input && strm.avail_in !== 0) return -2;\n\tstate = strm.state;\n\tif (state.mode === TYPE) state.mode = TYPEDO;\n\tput = strm.next_out;\n\toutput = strm.output;\n\tleft = strm.avail_out;\n\tnext = strm.next_in;\n\tinput = strm.input;\n\thave = strm.avail_in;\n\thold = state.hold;\n\tbits = state.bits;\n\t_in = have;\n\t_out = left;\n\tret = 0;\n\tinf_leave: for (;;) switch (state.mode) {\n\t\tcase HEAD:\n\t\t\tif (state.wrap === 0) {\n\t\t\t\tstate.mode = TYPEDO;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\twhile (bits < 16) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif (state.wrap & 2 && hold === 35615) {\n\t\t\t\tif (state.wbits === 0) state.wbits = 15;\n\t\t\t\tstate.check = 0;\n\t\t\t\thbuf[0] = hold & 255;\n\t\t\t\thbuf[1] = hold >>> 8 & 255;\n\t\t\t\tstate.check = crc32(state.check, hbuf, 2, 0);\n\t\t\t\thold = 0;\n\t\t\t\tbits = 0;\n\t\t\t\tstate.mode = FLAGS;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (state.head) state.head.done = false;\n\t\t\tif (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {\n\t\t\t\tstrm.msg = \"incorrect header check\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ((hold & 15) !== 8) {\n\t\t\t\tstrm.msg = \"unknown compression method\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\thold >>>= 4;\n\t\t\tbits -= 4;\n\t\t\tlen = (hold & 15) + 8;\n\t\t\tif (state.wbits === 0) state.wbits = len;\n\t\t\tif (len > 15 || len > state.wbits) {\n\t\t\t\tstrm.msg = \"invalid window size\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.dmax = 1 << state.wbits;\n\t\t\tstate.flags = 0;\n\t\t\tstrm.adler = state.check = 1;\n\t\t\tstate.mode = hold & 512 ? DICTID : TYPE;\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tbreak;\n\t\tcase FLAGS:\n\t\t\twhile (bits < 16) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tstate.flags = hold;\n\t\t\tif ((state.flags & 255) !== 8) {\n\t\t\t\tstrm.msg = \"unknown compression method\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (state.flags & 57344) {\n\t\t\t\tstrm.msg = \"unknown header flags set\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (state.head) state.head.text = hold >> 8 & 1;\n\t\t\tif (state.flags & 512 && state.wrap & 4) {\n\t\t\t\thbuf[0] = hold & 255;\n\t\t\t\thbuf[1] = hold >>> 8 & 255;\n\t\t\t\tstate.check = crc32(state.check, hbuf, 2, 0);\n\t\t\t}\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tstate.mode = TIME;\n\t\tcase TIME:\n\t\t\twhile (bits < 32) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif (state.head) state.head.time = hold;\n\t\t\tif (state.flags & 512 && state.wrap & 4) {\n\t\t\t\thbuf[0] = hold & 255;\n\t\t\t\thbuf[1] = hold >>> 8 & 255;\n\t\t\t\thbuf[2] = hold >>> 16 & 255;\n\t\t\t\thbuf[3] = hold >>> 24 & 255;\n\t\t\t\tstate.check = crc32(state.check, hbuf, 4, 0);\n\t\t\t}\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tstate.mode = OS;\n\t\tcase OS:\n\t\t\twhile (bits < 16) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif (state.head) {\n\t\t\t\tstate.head.xflags = hold & 255;\n\t\t\t\tstate.head.os = hold >> 8;\n\t\t\t}\n\t\t\tif (state.flags & 512 && state.wrap & 4) {\n\t\t\t\thbuf[0] = hold & 255;\n\t\t\t\thbuf[1] = hold >>> 8 & 255;\n\t\t\t\tstate.check = crc32(state.check, hbuf, 2, 0);\n\t\t\t}\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tstate.mode = EXLEN;\n\t\tcase EXLEN:\n\t\t\tif (state.flags & 1024) {\n\t\t\t\twhile (bits < 16) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tstate.length = hold;\n\t\t\t\tif (state.head) state.head.extra_len = hold;\n\t\t\t\tif (state.flags & 512 && state.wrap & 4) {\n\t\t\t\t\thbuf[0] = hold & 255;\n\t\t\t\t\thbuf[1] = hold >>> 8 & 255;\n\t\t\t\t\tstate.check = crc32(state.check, hbuf, 2, 0);\n\t\t\t\t}\n\t\t\t\thold = 0;\n\t\t\t\tbits = 0;\n\t\t\t} else if (state.head) state.head.extra = null;\n\t\t\tstate.mode = EXTRA;\n\t\tcase EXTRA:\n\t\t\tif (state.flags & 1024) {\n\t\t\t\tcopy = state.length;\n\t\t\t\tif (copy > have) copy = have;\n\t\t\t\tif (copy) {\n\t\t\t\t\tif (state.head) {\n\t\t\t\t\t\tlen = state.head.extra_len - state.length;\n\t\t\t\t\t\tif (!state.head.extra) state.head.extra = new Uint8Array(state.head.extra_len);\n\t\t\t\t\t\tstate.head.extra.set(input.subarray(next, next + copy), len);\n\t\t\t\t\t}\n\t\t\t\t\tif (state.flags & 512 && state.wrap & 4) state.check = crc32(state.check, input, copy, next);\n\t\t\t\t\thave -= copy;\n\t\t\t\t\tnext += copy;\n\t\t\t\t\tstate.length -= copy;\n\t\t\t\t}\n\t\t\t\tif (state.length) break inf_leave;\n\t\t\t}\n\t\t\tstate.length = 0;\n\t\t\tstate.mode = NAME;\n\t\tcase NAME:\n\t\t\tif (state.flags & 2048) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\tcopy = 0;\n\t\t\t\tdo {\n\t\t\t\t\tlen = input[next + copy++];\n\t\t\t\t\tif (state.head && len && state.length < 65536) state.head.name += String.fromCharCode(len);\n\t\t\t\t} while (len && copy < have);\n\t\t\t\tif (state.flags & 512 && state.wrap & 4) state.check = crc32(state.check, input, copy, next);\n\t\t\t\thave -= copy;\n\t\t\t\tnext += copy;\n\t\t\t\tif (len) break inf_leave;\n\t\t\t} else if (state.head) state.head.name = null;\n\t\t\tstate.length = 0;\n\t\t\tstate.mode = COMMENT;\n\t\tcase COMMENT:\n\t\t\tif (state.flags & 4096) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\tcopy = 0;\n\t\t\t\tdo {\n\t\t\t\t\tlen = input[next + copy++];\n\t\t\t\t\tif (state.head && len && state.length < 65536) state.head.comment += String.fromCharCode(len);\n\t\t\t\t} while (len && copy < have);\n\t\t\t\tif (state.flags & 512 && state.wrap & 4) state.check = crc32(state.check, input, copy, next);\n\t\t\t\thave -= copy;\n\t\t\t\tnext += copy;\n\t\t\t\tif (len) break inf_leave;\n\t\t\t} else if (state.head) state.head.comment = null;\n\t\t\tstate.mode = HCRC;\n\t\tcase HCRC:\n\t\t\tif (state.flags & 512) {\n\t\t\t\twhile (bits < 16) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tif (state.wrap & 4 && hold !== (state.check & 65535)) {\n\t\t\t\t\tstrm.msg = \"header crc mismatch\";\n\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\thold = 0;\n\t\t\t\tbits = 0;\n\t\t\t}\n\t\t\tif (state.head) {\n\t\t\t\tstate.head.hcrc = state.flags >> 9 & 1;\n\t\t\t\tstate.head.done = true;\n\t\t\t}\n\t\t\tstrm.adler = state.check = 0;\n\t\t\tstate.mode = TYPE;\n\t\t\tbreak;\n\t\tcase DICTID:\n\t\t\twhile (bits < 32) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tstrm.adler = state.check = zswap32(hold);\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tstate.mode = DICT;\n\t\tcase DICT:\n\t\t\tif (state.havedict === 0) {\n\t\t\t\tstrm.next_out = put;\n\t\t\t\tstrm.avail_out = left;\n\t\t\t\tstrm.next_in = next;\n\t\t\t\tstrm.avail_in = have;\n\t\t\t\tstate.hold = hold;\n\t\t\t\tstate.bits = bits;\n\t\t\t\treturn 2;\n\t\t\t}\n\t\t\tstrm.adler = state.check = 1;\n\t\t\tstate.mode = TYPE;\n\t\tcase TYPE: if (flush === 5 || flush === 6) break inf_leave;\n\t\tcase TYPEDO:\n\t\t\tif (state.last) {\n\t\t\t\thold >>>= bits & 7;\n\t\t\t\tbits -= bits & 7;\n\t\t\t\tstate.mode = CHECK;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\twhile (bits < 3) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tstate.last = hold & 1;\n\t\t\thold >>>= 1;\n\t\t\tbits -= 1;\n\t\t\tswitch (hold & 3) {\n\t\t\t\tcase 0:\n\t\t\t\t\tstate.mode = STORED;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 1:\n\t\t\t\t\tfixedtables(state);\n\t\t\t\t\tstate.mode = LEN_;\n\t\t\t\t\tif (flush === 6) {\n\t\t\t\t\t\thold >>>= 2;\n\t\t\t\t\t\tbits -= 2;\n\t\t\t\t\t\tbreak inf_leave;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tstate.mode = TABLE;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 3:\n\t\t\t\t\tstrm.msg = \"invalid block type\";\n\t\t\t\t\tstate.mode = BAD;\n\t\t\t}\n\t\t\thold >>>= 2;\n\t\t\tbits -= 2;\n\t\t\tbreak;\n\t\tcase STORED:\n\t\t\thold >>>= bits & 7;\n\t\t\tbits -= bits & 7;\n\t\t\twhile (bits < 32) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif ((hold & 65535) !== (hold >>> 16 ^ 65535)) {\n\t\t\t\tstrm.msg = \"invalid stored block lengths\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.length = hold & 65535;\n\t\t\thold = 0;\n\t\t\tbits = 0;\n\t\t\tstate.mode = COPY_;\n\t\t\tif (flush === 6) break inf_leave;\n\t\tcase COPY_: state.mode = COPY;\n\t\tcase COPY:\n\t\t\tcopy = state.length;\n\t\t\tif (copy) {\n\t\t\t\tif (copy > have) copy = have;\n\t\t\t\tif (copy > left) copy = left;\n\t\t\t\tif (copy === 0) break inf_leave;\n\t\t\t\toutput.set(input.subarray(next, next + copy), put);\n\t\t\t\thave -= copy;\n\t\t\t\tnext += copy;\n\t\t\t\tleft -= copy;\n\t\t\t\tput += copy;\n\t\t\t\tstate.length -= copy;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.mode = TYPE;\n\t\t\tbreak;\n\t\tcase TABLE:\n\t\t\twhile (bits < 14) {\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tstate.nlen = (hold & 31) + 257;\n\t\t\thold >>>= 5;\n\t\t\tbits -= 5;\n\t\t\tstate.ndist = (hold & 31) + 1;\n\t\t\thold >>>= 5;\n\t\t\tbits -= 5;\n\t\t\tstate.ncode = (hold & 15) + 4;\n\t\t\thold >>>= 4;\n\t\t\tbits -= 4;\n\t\t\tif (state.nlen > 286 || state.ndist > 30) {\n\t\t\t\tstrm.msg = \"too many length or distance symbols\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.have = 0;\n\t\t\tstate.mode = LENLENS;\n\t\tcase LENLENS:\n\t\t\twhile (state.have < state.ncode) {\n\t\t\t\twhile (bits < 3) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tstate.lens[order[state.have++]] = hold & 7;\n\t\t\t\thold >>>= 3;\n\t\t\t\tbits -= 3;\n\t\t\t}\n\t\t\twhile (state.have < 19) state.lens[order[state.have++]] = 0;\n\t\t\tstate.lencode = state.lendyn;\n\t\t\tstate.lenbits = 7;\n\t\t\topts = { bits: state.lenbits };\n\t\t\tret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);\n\t\t\tstate.lenbits = opts.bits;\n\t\t\tif (ret) {\n\t\t\t\tstrm.msg = \"invalid code lengths set\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.have = 0;\n\t\t\tstate.mode = CODELENS;\n\t\tcase CODELENS:\n\t\t\twhile (state.have < state.nlen + state.ndist) {\n\t\t\t\tfor (;;) {\n\t\t\t\t\there = state.lencode[hold & (1 << state.lenbits) - 1];\n\t\t\t\t\there_bits = here >>> 24;\n\t\t\t\t\there_op = here >>> 16 & 255;\n\t\t\t\t\there_val = here & 65535;\n\t\t\t\t\tif (here_bits <= bits) break;\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tif (here_val < 16) {\n\t\t\t\t\thold >>>= here_bits;\n\t\t\t\t\tbits -= here_bits;\n\t\t\t\t\tstate.lens[state.have++] = here_val;\n\t\t\t\t} else {\n\t\t\t\t\tif (here_val === 16) {\n\t\t\t\t\t\tn = here_bits + 2;\n\t\t\t\t\t\twhile (bits < n) {\n\t\t\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\t\t\thave--;\n\t\t\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t\t}\n\t\t\t\t\t\thold >>>= here_bits;\n\t\t\t\t\t\tbits -= here_bits;\n\t\t\t\t\t\tif (state.have === 0) {\n\t\t\t\t\t\t\tstrm.msg = \"invalid bit length repeat\";\n\t\t\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tlen = state.lens[state.have - 1];\n\t\t\t\t\t\tcopy = 3 + (hold & 3);\n\t\t\t\t\t\thold >>>= 2;\n\t\t\t\t\t\tbits -= 2;\n\t\t\t\t\t} else if (here_val === 17) {\n\t\t\t\t\t\tn = here_bits + 3;\n\t\t\t\t\t\twhile (bits < n) {\n\t\t\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\t\t\thave--;\n\t\t\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t\t}\n\t\t\t\t\t\thold >>>= here_bits;\n\t\t\t\t\t\tbits -= here_bits;\n\t\t\t\t\t\tlen = 0;\n\t\t\t\t\t\tcopy = 3 + (hold & 7);\n\t\t\t\t\t\thold >>>= 3;\n\t\t\t\t\t\tbits -= 3;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tn = here_bits + 7;\n\t\t\t\t\t\twhile (bits < n) {\n\t\t\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\t\t\thave--;\n\t\t\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\t\t\tbits += 8;\n\t\t\t\t\t\t}\n\t\t\t\t\t\thold >>>= here_bits;\n\t\t\t\t\t\tbits -= here_bits;\n\t\t\t\t\t\tlen = 0;\n\t\t\t\t\t\tcopy = 11 + (hold & 127);\n\t\t\t\t\t\thold >>>= 7;\n\t\t\t\t\t\tbits -= 7;\n\t\t\t\t\t}\n\t\t\t\t\tif (state.have + copy > state.nlen + state.ndist) {\n\t\t\t\t\t\tstrm.msg = \"invalid bit length repeat\";\n\t\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\twhile (copy--) state.lens[state.have++] = len;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (state.mode === BAD) break;\n\t\t\tif (state.lens[256] === 0) {\n\t\t\t\tstrm.msg = \"invalid code -- missing end-of-block\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.lenbits = 9;\n\t\t\topts = { bits: state.lenbits };\n\t\t\tret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);\n\t\t\tstate.lenbits = opts.bits;\n\t\t\tif (ret) {\n\t\t\t\tstrm.msg = \"invalid literal/lengths set\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.distbits = 6;\n\t\t\tstate.distcode = state.distdyn;\n\t\t\topts = { bits: state.distbits };\n\t\t\tret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);\n\t\t\tstate.distbits = opts.bits;\n\t\t\tif (ret) {\n\t\t\t\tstrm.msg = \"invalid distances set\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.mode = LEN_;\n\t\t\tif (flush === 6) break inf_leave;\n\t\tcase LEN_: state.mode = LEN;\n\t\tcase LEN:\n\t\t\tif (have >= 6 && left >= 258) {\n\t\t\t\tstrm.next_out = put;\n\t\t\t\tstrm.avail_out = left;\n\t\t\t\tstrm.next_in = next;\n\t\t\t\tstrm.avail_in = have;\n\t\t\t\tstate.hold = hold;\n\t\t\t\tstate.bits = bits;\n\t\t\t\tinflate_fast(strm, _out);\n\t\t\t\tput = strm.next_out;\n\t\t\t\toutput = strm.output;\n\t\t\t\tleft = strm.avail_out;\n\t\t\t\tnext = strm.next_in;\n\t\t\t\tinput = strm.input;\n\t\t\t\thave = strm.avail_in;\n\t\t\t\thold = state.hold;\n\t\t\t\tbits = state.bits;\n\t\t\t\tif (state.mode === TYPE) state.back = -1;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.back = 0;\n\t\t\tfor (;;) {\n\t\t\t\there = state.lencode[hold & (1 << state.lenbits) - 1];\n\t\t\t\there_bits = here >>> 24;\n\t\t\t\there_op = here >>> 16 & 255;\n\t\t\t\there_val = here & 65535;\n\t\t\t\tif (here_bits <= bits) break;\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif (here_op && (here_op & 240) === 0) {\n\t\t\t\tlast_bits = here_bits;\n\t\t\t\tlast_op = here_op;\n\t\t\t\tlast_val = here_val;\n\t\t\t\tfor (;;) {\n\t\t\t\t\there = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];\n\t\t\t\t\there_bits = here >>> 24;\n\t\t\t\t\there_op = here >>> 16 & 255;\n\t\t\t\t\there_val = here & 65535;\n\t\t\t\t\tif (last_bits + here_bits <= bits) break;\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\thold >>>= last_bits;\n\t\t\t\tbits -= last_bits;\n\t\t\t\tstate.back += last_bits;\n\t\t\t}\n\t\t\thold >>>= here_bits;\n\t\t\tbits -= here_bits;\n\t\t\tstate.back += here_bits;\n\t\t\tstate.length = here_val;\n\t\t\tif (here_op === 0) {\n\t\t\t\tstate.mode = LIT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (here_op & 32) {\n\t\t\t\tstate.back = -1;\n\t\t\t\tstate.mode = TYPE;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (here_op & 64) {\n\t\t\t\tstrm.msg = \"invalid literal/length code\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.extra = here_op & 15;\n\t\t\tstate.mode = LENEXT;\n\t\tcase LENEXT:\n\t\t\tif (state.extra) {\n\t\t\t\tn = state.extra;\n\t\t\t\twhile (bits < n) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tstate.length += hold & (1 << state.extra) - 1;\n\t\t\t\thold >>>= state.extra;\n\t\t\t\tbits -= state.extra;\n\t\t\t\tstate.back += state.extra;\n\t\t\t}\n\t\t\tstate.was = state.length;\n\t\t\tstate.mode = DIST;\n\t\tcase DIST:\n\t\t\tfor (;;) {\n\t\t\t\there = state.distcode[hold & (1 << state.distbits) - 1];\n\t\t\t\there_bits = here >>> 24;\n\t\t\t\there_op = here >>> 16 & 255;\n\t\t\t\there_val = here & 65535;\n\t\t\t\tif (here_bits <= bits) break;\n\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\thave--;\n\t\t\t\thold += input[next++] << bits;\n\t\t\t\tbits += 8;\n\t\t\t}\n\t\t\tif ((here_op & 240) === 0) {\n\t\t\t\tlast_bits = here_bits;\n\t\t\t\tlast_op = here_op;\n\t\t\t\tlast_val = here_val;\n\t\t\t\tfor (;;) {\n\t\t\t\t\there = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];\n\t\t\t\t\there_bits = here >>> 24;\n\t\t\t\t\there_op = here >>> 16 & 255;\n\t\t\t\t\there_val = here & 65535;\n\t\t\t\t\tif (last_bits + here_bits <= bits) break;\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\thold >>>= last_bits;\n\t\t\t\tbits -= last_bits;\n\t\t\t\tstate.back += last_bits;\n\t\t\t}\n\t\t\thold >>>= here_bits;\n\t\t\tbits -= here_bits;\n\t\t\tstate.back += here_bits;\n\t\t\tif (here_op & 64) {\n\t\t\t\tstrm.msg = \"invalid distance code\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.offset = here_val;\n\t\t\tstate.extra = here_op & 15;\n\t\t\tstate.mode = DISTEXT;\n\t\tcase DISTEXT:\n\t\t\tif (state.extra) {\n\t\t\t\tn = state.extra;\n\t\t\t\twhile (bits < n) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tstate.offset += hold & (1 << state.extra) - 1;\n\t\t\t\thold >>>= state.extra;\n\t\t\t\tbits -= state.extra;\n\t\t\t\tstate.back += state.extra;\n\t\t\t}\n\t\t\tif (state.offset > state.dmax) {\n\t\t\t\tstrm.msg = \"invalid distance too far back\";\n\t\t\t\tstate.mode = BAD;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tstate.mode = MATCH;\n\t\tcase MATCH:\n\t\t\tif (left === 0) break inf_leave;\n\t\t\tcopy = _out - left;\n\t\t\tif (state.offset > copy) {\n\t\t\t\tcopy = state.offset - copy;\n\t\t\t\tif (copy > state.whave) {\n\t\t\t\t\tif (state.sane) {\n\t\t\t\t\t\tstrm.msg = \"invalid distance too far back\";\n\t\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (copy > state.wnext) {\n\t\t\t\t\tcopy -= state.wnext;\n\t\t\t\t\tfrom = state.wsize - copy;\n\t\t\t\t} else from = state.wnext - copy;\n\t\t\t\tif (copy > state.length) copy = state.length;\n\t\t\t\tfrom_source = state.window;\n\t\t\t} else {\n\t\t\t\tfrom_source = output;\n\t\t\t\tfrom = put - state.offset;\n\t\t\t\tcopy = state.length;\n\t\t\t}\n\t\t\tif (copy > left) copy = left;\n\t\t\tleft -= copy;\n\t\t\tstate.length -= copy;\n\t\t\tdo\n\t\t\t\toutput[put++] = from_source[from++];\n\t\t\twhile (--copy);\n\t\t\tif (state.length === 0) state.mode = LEN;\n\t\t\tbreak;\n\t\tcase LIT:\n\t\t\tif (left === 0) break inf_leave;\n\t\t\toutput[put++] = state.length;\n\t\t\tleft--;\n\t\t\tstate.mode = LEN;\n\t\t\tbreak;\n\t\tcase CHECK:\n\t\t\tif (state.wrap) {\n\t\t\t\twhile (bits < 32) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold |= input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\t_out -= left;\n\t\t\t\tstrm.total_out += _out;\n\t\t\t\tstate.total += _out;\n\t\t\t\tif (state.wrap & 4 && _out) strm.adler = state.check = state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out);\n\t\t\t\t_out = left;\n\t\t\t\tif (state.wrap & 4 && (state.flags ? hold : zswap32(hold)) !== state.check) {\n\t\t\t\t\tstrm.msg = \"incorrect data check\";\n\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\thold = 0;\n\t\t\t\tbits = 0;\n\t\t\t}\n\t\t\tstate.mode = LENGTH;\n\t\tcase LENGTH:\n\t\t\tif (state.wrap && state.flags) {\n\t\t\t\twhile (bits < 32) {\n\t\t\t\t\tif (have === 0) break inf_leave;\n\t\t\t\t\thave--;\n\t\t\t\t\thold += input[next++] << bits;\n\t\t\t\t\tbits += 8;\n\t\t\t\t}\n\t\t\t\tif (state.wrap & 4 && hold !== (state.total & 4294967295)) {\n\t\t\t\t\tstrm.msg = \"incorrect length check\";\n\t\t\t\t\tstate.mode = BAD;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\thold = 0;\n\t\t\t\tbits = 0;\n\t\t\t}\n\t\t\tstate.mode = DONE;\n\t\tcase DONE:\n\t\t\tret = 1;\n\t\t\tbreak inf_leave;\n\t\tcase BAD:\n\t\t\tret = -3;\n\t\t\tbreak inf_leave;\n\t\tcase MEM: return -4;\n\t\tcase SYNC:\n\t\tdefault: return -2;\n\t}\n\tstrm.next_out = put;\n\tstrm.avail_out = left;\n\tstrm.next_in = next;\n\tstrm.avail_in = have;\n\tstate.hold = hold;\n\tstate.bits = bits;\n\tif (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== 4)) {\n\t\tif (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {\n\t\t\tstate.mode = MEM;\n\t\t\treturn -4;\n\t\t}\n\t}\n\t_in -= strm.avail_in;\n\t_out -= strm.avail_out;\n\tstrm.total_in += _in;\n\tstrm.total_out += _out;\n\tstate.total += _out;\n\tif (state.wrap & 4 && _out) strm.adler = state.check = state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out);\n\tstrm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);\n\tif ((_in === 0 && _out === 0 || flush === 4) && ret === 0) ret = -5;\n\treturn ret;\n};\nvar inflateEnd = (strm) => {\n\tif (inflateStateCheck(strm)) return -2;\n\tlet state = strm.state;\n\tif (state.window) state.window = null;\n\tstrm.state = null;\n\treturn 0;\n};\nvar inflateGetHeader = (strm, head) => {\n\tif (inflateStateCheck(strm)) return -2;\n\tconst state = strm.state;\n\tif ((state.wrap & 2) === 0) return -2;\n\tstate.head = head;\n\thead.done = false;\n\treturn 0;\n};\nvar inflateSetDictionary = (strm, dictionary) => {\n\tconst dictLength = dictionary.length;\n\tlet state;\n\tlet dictid;\n\tlet ret;\n\tif (inflateStateCheck(strm)) return -2;\n\tstate = strm.state;\n\tif (state.wrap !== 0 && state.mode !== DICT) return -2;\n\tif (state.mode === DICT) {\n\t\tdictid = 1;\n\t\tdictid = adler32(dictid, dictionary, dictLength, 0);\n\t\tif (dictid !== state.check) return -3;\n\t}\n\tret = updatewindow(strm, dictionary, dictLength, dictLength);\n\tif (ret) {\n\t\tstate.mode = MEM;\n\t\treturn -4;\n\t}\n\tstate.havedict = 1;\n\treturn 0;\n};\n//#endregion\n//#region src/zlib/zstream.mjs\nvar ZStream = class {\n\tconstructor() {\n\t\tthis.input = null;\n\t\tthis.next_in = 0;\n\t\tthis.avail_in = 0;\n\t\tthis.total_in = 0;\n\t\tthis.output = null;\n\t\tthis.next_out = 0;\n\t\tthis.avail_out = 0;\n\t\tthis.total_out = 0;\n\t\tthis.msg = \"\";\n\t\tthis.state = null;\n\t\tthis.data_type = 2;\n\t\tthis.adler = 0;\n\t}\n};\n//#endregion\n//#region src/zlib/gzheader.mjs\nvar GZheader = class {\n\tconstructor() {\n\t\tthis.text = 0;\n\t\tthis.time = 0;\n\t\tthis.xflags = 0;\n\t\tthis.os = 0;\n\t\tthis.extra = null;\n\t\tthis.extra_len = 0;\n\t\tthis.name = \"\";\n\t\tthis.comment = \"\";\n\t\tthis.hcrc = 0;\n\t\tthis.done = false;\n\t}\n};\n//#endregion\n//#region src/utils.ts\nvar flattenChunks = (chunks) => {\n\tconst result = new Uint8Array(chunks.reduce((len, chunk) => len + chunk.length, 0));\n\tlet pos = 0;\n\tfor (const chunk of chunks) {\n\t\tresult.set(chunk, pos);\n\t\tpos += chunk.length;\n\t}\n\treturn result;\n};\n//#endregion\n//#region src/deflate.ts\nvar toString$1 = Object.prototype.toString;\nvar defaultOptions$1 = {\n\tlevel: -1,\n\tchunkSize: 16384,\n\twindowBits: 15,\n\tmemLevel: 8,\n\tstrategy: 0,\n\traw: false,\n\tgzip: false,\n\tlegacyHash: false,\n\tdictionary: /* @__PURE__ */ new Uint8Array(0)\n};\n/**\n* Generic JS-style wrapper for zlib calls. If you don't need\n* streaming behaviour, use the simpler functions {@link deflate},\n* {@link deflateRaw} and {@link gzip}.\n*/\nvar Deflate = class {\n\toptions;\n\t/**\n\t* Error code after deflate finishes. {@link Z_OK} on success.\n\t* You will not need it in real life, because deflate errors\n\t* are possible only on wrong options or bad custom `onData` / `onEnd`\n\t* handlers.\n\t*/\n\terr;\n\t/** Error message, if {@link Deflate.err} is not {@link Z_OK}. */\n\tmsg;\n\tended;\n\tstarted;\n\t/**\n\t* Chunks of output data, if {@link Deflate.onData} not overridden.\n\t* @internal\n\t*/\n\tchunks;\n\tstrm;\n\t/**\n\t* Compressed result, generated by default {@link Deflate.onData}\n\t* and {@link Deflate.onEnd} handlers. Filled after you push last chunk\n\t* (call {@link Deflate.push} with {@link Z_FINISH} / `true` param).\n\t*/\n\tresult;\n\t/**\n\t* Creates a new deflator instance with the specified params. Throws an\n\t* exception on bad params. See {@link DeflateOptions} for the list of\n\t* supported options.\n\t*\n\t* @example\n\t* ```javascript\n\t* import { Deflate } from 'pako'\n\t*\n\t* const chunk1 = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n\t* const chunk2 = new Uint8Array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])\n\t*\n\t* const deflate = new Deflate({ level: 3 })\n\t*\n\t* deflate.push(chunk1, false)\n\t* deflate.push(chunk2, true)  // true -> last chunk\n\t*\n\t* if (deflate.err) throw new Error(deflate.err)\n\t*\n\t* console.log(deflate.result)\n\t* ```\n\t*/\n\tconstructor(options = {}) {\n\t\tthis.options = Object.assign({}, defaultOptions$1, options);\n\t\tconst opt = this.options;\n\t\tif (opt.raw && opt.windowBits > 0) opt.windowBits = -opt.windowBits;\n\t\telse if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) opt.windowBits += 16;\n\t\tthis.err = 0;\n\t\tthis.msg = \"\";\n\t\tthis.ended = false;\n\t\tthis.started = false;\n\t\tthis.chunks = [];\n\t\tthis.result = /* @__PURE__ */ new Uint8Array(0);\n\t\tthis.strm = new ZStream();\n\t\tthis.strm.avail_out = 0;\n\t\tlet status = deflateInit2(this.strm, opt.level, 8, opt.windowBits, opt.memLevel, opt.strategy, opt.legacyHash);\n\t\tif (status !== 0) throw new Error(messages_default[status]);\n\t\tif (toString$1.call(opt.dictionary) === \"[object ArrayBuffer]\") opt.dictionary = new Uint8Array(opt.dictionary);\n\t\tconst dictionary = opt.dictionary;\n\t\tif (dictionary.length) {\n\t\t\tif (opt.gzip) throw new Error(\"dictionary is not supported with gzip\");\n\t\t\tstatus = deflateSetDictionary(this.strm, dictionary);\n\t\t\tif (status !== 0) throw new Error(messages_default[status]);\n\t\t}\n\t}\n\t/**\n\t* Sends input data to the deflate pipe, generating {@link Deflate.onData} calls\n\t* with new compressed chunks. Returns `true` on success. The last data block must\n\t* have `flush_mode` {@link Z_FINISH} (or `true`). That will flush the internal\n\t* pending buffers and call {@link Deflate.onEnd}.\n\t*\n\t* On failure, calls {@link Deflate.onEnd} with the error code and returns false.\n\t*\n\t* @param data input data. Strings will be converted to utf8 byte sequence.\n\t* @param flush_mode 0..6 for corresponding {@link Z_NO_FLUSH}..{@link Z_TREES} modes.\n\t*   See constants. Skipped or `false` means {@link Z_NO_FLUSH}, `true` means {@link Z_FINISH}.\n\t*\n\t* @example\n\t* ```javascript\n\t* push(chunk, false) // push one of data chunks\n\t* ...\n\t* push(chunk, true)  // push last chunk\n\t* ```\n\t*/\n\tpush(data, flush_mode = false) {\n\t\tconst strm = this.strm;\n\t\tconst chunkSize = this.options.chunkSize;\n\t\tlet status;\n\t\tlet _flush_mode;\n\t\tif (this.ended) return false;\n\t\tif (typeof flush_mode === \"number\") _flush_mode = flush_mode;\n\t\telse _flush_mode = flush_mode === true ? 4 : 0;\n\t\tif (typeof data === \"string\") strm.input = new TextEncoder().encode(data);\n\t\telse if (toString$1.call(data) === \"[object ArrayBuffer]\") strm.input = new Uint8Array(data);\n\t\telse strm.input = data;\n\t\tstrm.next_in = 0;\n\t\tstrm.avail_in = strm.input.length;\n\t\tif (!this.started) {\n\t\t\tthis.started = true;\n\t\t\tthis.onStart(strm);\n\t\t}\n\t\tfor (;;) {\n\t\t\tif (strm.avail_out === 0) {\n\t\t\t\tstrm.output = new Uint8Array(chunkSize);\n\t\t\t\tstrm.next_out = 0;\n\t\t\t\tstrm.avail_out = chunkSize;\n\t\t\t}\n\t\t\tif ((_flush_mode === 2 || _flush_mode === 3) && strm.avail_out <= 6) {\n\t\t\t\tthis.onData(strm.output.subarray(0, strm.next_out));\n\t\t\t\tstrm.avail_out = 0;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tstatus = deflate$1(strm, _flush_mode);\n\t\t\tif (status === 1) {\n\t\t\t\tif (strm.next_out > 0) this.onData(strm.output.subarray(0, strm.next_out));\n\t\t\t\tstatus = deflateEnd(this.strm);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (strm.avail_out === 0) {\n\t\t\t\tthis.onData(strm.output);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (_flush_mode > 0 && strm.next_out > 0) {\n\t\t\t\tthis.onData(strm.output.subarray(0, strm.next_out));\n\t\t\t\tstrm.avail_out = 0;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (strm.avail_in === 0) return true;\n\t\t}\n\t\tthis.err = status;\n\t\tthis.msg = strm.msg || messages_default[status];\n\t\tthis.ended = true;\n\t\tthis.onEnd(status);\n\t\treturn status === 0;\n\t}\n\t/**\n\t* Called once before the first low-level deflate call.\n\t*/\n\tonStart(strm) {}\n\t/**\n\t* By default, stores data blocks in the {@link Deflate.chunks} property and glues\n\t* them in {@link Deflate.onEnd}. Override this handler if you need another behaviour.\n\t*/\n\tonData(chunk) {\n\t\tthis.chunks.push(chunk);\n\t}\n\t/**\n\t* Called once after you tell deflate that the input stream is\n\t* complete ({@link Z_FINISH}). By default, joins the collected {@link Deflate.chunks}\n\t* into the {@link Deflate.result} property.\n\t*\n\t* @param status deflate status. {@link Z_OK} on success, other if not.\n\t*/\n\tonEnd(status) {\n\t\tif (status === 0) this.result = flattenChunks(this.chunks);\n\t\tthis.chunks = [];\n\t}\n};\n/**\n* Compress `data` with deflate algorithm and `options`.\n* See {@link DeflateOptions} for the list of supported options.\n*\n* @example\n* ```javascript\n* import { deflate } from 'pako'\n*\n* const data = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n*\n* console.log(deflate(data))\n* ```\n*/\nfunction deflate(input, options = {}) {\n\tconst deflator = new Deflate(options);\n\tdeflator.push(input, true);\n\tif (deflator.err) throw new Error(deflator.msg);\n\treturn deflator.result;\n}\n/**\n* The same as {@link deflate}, but creates raw data without a wrapper\n* (header and adler32 crc).\n*/\nfunction deflateRaw(input, options = {}) {\n\treturn deflate(input, Object.assign({}, options, { raw: true }));\n}\n/**\n* The same as {@link deflate}, but creates a gzip wrapper instead of\n* a deflate one.\n*/\nfunction gzip(input, options = {}) {\n\treturn deflate(input, Object.assign({}, options, { gzip: true }));\n}\n//#endregion\n//#region src/inflate.ts\nvar toString = Object.prototype.toString;\nvar defaultOptions = {\n\tchunkSize: 1024 * 64,\n\twindowBits: 15,\n\traw: false,\n\tdictionary: /* @__PURE__ */ new Uint8Array(0)\n};\n/**\n* Generic JS-style wrapper for zlib calls. If you don't need\n* streaming behaviour, use the simpler functions {@link inflate}\n* and {@link inflateRaw}.\n*/\nvar Inflate = class {\n\toptions;\n\t/**\n\t* Error code after inflate finishes. {@link Z_OK} on success.\n\t* Should be checked when broken data is possible.\n\t*/\n\terr;\n\t/** Error message, if {@link Inflate.err} is not {@link Z_OK}. */\n\tmsg;\n\t/**\n\t* `true` once the compressed stream has ended. A stream may end before the\n\t* caller's data does (trailing bytes), so check this to know when to stop\n\t* pushing - further {@link Inflate.push} calls are no-ops.\n\t*/\n\tended;\n\tstarted;\n\t/**\n\t* Chunks of output data, if {@link Inflate.onData} not overridden.\n\t* @internal\n\t*/\n\tchunks;\n\tstrm;\n\t/**\n\t* Uncompressed result, generated by default {@link Inflate.onData}\n\t* and {@link Inflate.onEnd} handlers. Filled after you push last chunk\n\t* (call {@link Inflate.push} with {@link Z_FINISH} / `true` param).\n\t*/\n\tresult;\n\t/**\n\t* Creates a new inflator instance with the specified params. Throws an\n\t* exception on bad params. See {@link InflateOptions} for the list of\n\t* supported options.\n\t*\n\t* By default, when no options are set, the deflate/gzip data format is\n\t* autodetected via the wrapper header.\n\t*\n\t* @example\n\t* ```javascript\n\t* import { Inflate } from 'pako'\n\t*\n\t* const chunk1 = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n\t* const chunk2 = new Uint8Array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])\n\t*\n\t* const inflate = new Inflate({ level: 3 })\n\t*\n\t* inflate.push(chunk1, false)\n\t* inflate.push(chunk2, true)  // true -> last chunk\n\t*\n\t* if (inflate.err) throw new Error(inflate.err)\n\t*\n\t* console.log(inflate.result)\n\t* ```\n\t*/\n\tconstructor(options = {}) {\n\t\tthis.options = Object.assign({}, defaultOptions, options);\n\t\tconst opt = this.options;\n\t\tif (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {\n\t\t\topt.windowBits = -opt.windowBits;\n\t\t\tif (opt.windowBits === 0) opt.windowBits = -15;\n\t\t}\n\t\tif (opt.windowBits >= 0 && opt.windowBits < 16 && !options.windowBits) opt.windowBits += 32;\n\t\tif (opt.windowBits > 15 && opt.windowBits < 48) {\n\t\t\tif ((opt.windowBits & 15) === 0) opt.windowBits |= 15;\n\t\t}\n\t\tthis.err = 0;\n\t\tthis.msg = \"\";\n\t\tthis.ended = false;\n\t\tthis.started = false;\n\t\tthis.chunks = [];\n\t\tthis.result = /* @__PURE__ */ new Uint8Array(0);\n\t\tthis.strm = new ZStream();\n\t\tthis.strm.avail_out = 0;\n\t\tlet status = inflateInit2(this.strm, opt.windowBits);\n\t\tif (status !== 0) throw new Error(messages_default[status]);\n\t\tif (toString.call(opt.dictionary) === \"[object ArrayBuffer]\") opt.dictionary = new Uint8Array(opt.dictionary);\n\t\tconst dictionary = opt.dictionary;\n\t\tif (opt.raw && dictionary.length) {\n\t\t\tstatus = inflateSetDictionary(this.strm, dictionary);\n\t\t\tif (status !== 0) throw new Error(messages_default[status]);\n\t\t}\n\t}\n\t/**\n\t* Sends input data to the inflate pipe, generating {@link Inflate.onData} calls\n\t* with new output chunks. Returns `true` on success. If end of stream is\n\t* detected, {@link Inflate.onEnd} will be called.\n\t*\n\t* `flush_mode` is not needed for normal operation, because end of stream\n\t* is detected automatically. Pass {@link Z_SYNC_FLUSH} to force the decoder\n\t* to emit all currently available output — handy when you need to decode\n\t* data frame-by-frame from a long-running stream.\n\t*\n\t* On failure, calls {@link Inflate.onEnd} with the error code and returns false.\n\t*\n\t* Once the stream has ended (a compressed stream may end before your data\n\t* does), further `push` calls are no-ops and return whether the decode\n\t* finished successfully. The final outcome is in {@link Inflate.result},\n\t* {@link Inflate.err} and {@link Inflate.msg}.\n\t*\n\t* @param flush_mode 0..6 for corresponding {@link Z_NO_FLUSH}..{@link Z_TREES}\n\t*   flush modes. See constants. Skipped or `false` means {@link Z_NO_FLUSH},\n\t*   `true` means {@link Z_FINISH}.\n\t*\n\t* @example\n\t* ```javascript\n\t* push(chunk, false) // push one of data chunks\n\t* ...\n\t* push(chunk, true)  // push last chunk\n\t* ```\n\t*/\n\tpush(data, flush_mode = false) {\n\t\tconst strm = this.strm;\n\t\tconst chunkSize = this.options.chunkSize;\n\t\tlet status;\n\t\tlet _flush_mode;\n\t\tlet last_avail_out;\n\t\tif (this.ended) return this.err === 0;\n\t\tif (typeof flush_mode === \"number\") _flush_mode = flush_mode;\n\t\telse _flush_mode = flush_mode === true ? 4 : 0;\n\t\tif (toString.call(data) === \"[object ArrayBuffer]\") strm.input = new Uint8Array(data);\n\t\telse strm.input = data;\n\t\tstrm.next_in = 0;\n\t\tstrm.avail_in = strm.input.length;\n\t\tif (!this.started) {\n\t\t\tthis.started = true;\n\t\t\tthis.onStart(strm);\n\t\t}\n\t\tfor (;;) {\n\t\t\tif (strm.avail_out === 0) {\n\t\t\t\tstrm.output = new Uint8Array(chunkSize);\n\t\t\t\tstrm.next_out = 0;\n\t\t\t\tstrm.avail_out = chunkSize;\n\t\t\t}\n\t\t\tstatus = inflate$1(strm, _flush_mode);\n\t\t\tif (status === 2) {\n\t\t\t\tconst dictionary = this.options.dictionary;\n\t\t\t\tif (dictionary.length) {\n\t\t\t\t\tstatus = inflateSetDictionary(strm, dictionary);\n\t\t\t\t\tif (status === 0) status = inflate$1(strm, _flush_mode);\n\t\t\t\t\telse if (status === -3) status = 2;\n\t\t\t\t}\n\t\t\t}\n\t\t\twhile (strm.avail_in > 0 && status === 1 && strm.state.wrap & 2 && strm.state.flags !== 0 && strm.input[strm.next_in] !== 0) {\n\t\t\t\tinflateReset(strm);\n\t\t\t\tstatus = inflate$1(strm, _flush_mode);\n\t\t\t}\n\t\t\tif (status === -2 || status === -3 || status === 2 || status === -4) break;\n\t\t\tlast_avail_out = strm.avail_out;\n\t\t\tif (strm.next_out) {\n\t\t\t\tif (strm.avail_out === 0 || status === 1 || _flush_mode > 0) {\n\t\t\t\t\tthis.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));\n\t\t\t\t\tstrm.avail_out = 0;\n\t\t\t\t\tstrm.next_out = 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ((status === 0 || status === -5) && last_avail_out === 0) continue;\n\t\t\tif (status === 1) {\n\t\t\t\tstatus = inflateEnd(this.strm);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (strm.avail_in === 0) {\n\t\t\t\tif (_flush_mode === 4) {\n\t\t\t\t\tstatus = inflateEnd(this.strm);\n\t\t\t\t\tif (status === 0) status = -5;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\tthis.err = status;\n\t\tthis.msg = strm.msg || messages_default[status];\n\t\tthis.ended = true;\n\t\tthis.onEnd(status);\n\t\treturn status === 0;\n\t}\n\t/**\n\t* Called once before the first low-level inflate call.\n\t*\n\t* Override this handler to attach low-level inflate state, for example to read\n\t* gzip header metadata:\n\t*\n\t* ```javascript\n\t* import { Inflate, GZheader, zlibInflateGetHeader } from 'pako'\n\t*\n\t* const inflator = new Inflate()\n\t*\n\t* inflator.onStart = function (strm) {\n\t*   this.header = new GZheader()\n\t*   zlibInflateGetHeader(strm, this.header)\n\t* }\n\t*\n\t* inflator.push(data, true)\n\t* console.log(inflator.header.name)\n\t* ```\n\t*/\n\tonStart(strm) {}\n\t/**\n\t* By default, stores data blocks in the {@link Inflate.chunks} property and glues\n\t* them in {@link Inflate.onEnd}. Override this handler if you need another behaviour.\n\t*\n\t* @param chunk output data.\n\t*/\n\tonData(chunk) {\n\t\tthis.chunks.push(chunk);\n\t}\n\t/**\n\t* Called after you tell inflate that the input stream is\n\t* complete ({@link Z_FINISH}). By default, joins the collected {@link Inflate.chunks},\n\t* frees memory and fills the {@link Inflate.result} property.\n\t*\n\t* @param status inflate status. {@link Z_OK} on success, other if not.\n\t*/\n\tonEnd(status) {\n\t\tif (status === 0) this.result = flattenChunks(this.chunks);\n\t\tthis.chunks = [];\n\t}\n};\n/**\n* One-shot inflate decompress. Autodetects `gzip`/`zlib`\n* format via the wrapper header — so {@link ungzip} is just a convenience alias of\n* this function. See {@link InflateOptions} for zlib options. Set\n* `toText: true` to decode the result as UTF-8 text.\n*\n* @example\n* ```javascript\n* import { deflate, inflate } from 'pako'\n*\n* const input = deflate(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]))\n* let output\n*\n* try {\n*   output = inflate(input)\n* } catch (err) {\n*   console.log(err)\n* }\n* ```\n*/\nfunction inflate(input, options = {}) {\n\tconst inflator = new Inflate(options);\n\tinflator.push(input, true);\n\tif (inflator.err) throw new Error(inflator.msg);\n\tconst result = inflator.result;\n\treturn options.toText ? new TextDecoder().decode(result) : result;\n}\n/**\n* The same as {@link inflate}, but consumes raw data without a wrapper\n* (header and adler32 crc).\n*/\nfunction inflateRaw(input, options = {}) {\n\treturn inflate(input, {\n\t\t...options,\n\t\traw: true\n\t});\n}\n//#endregion\nexport { Deflate, GZheader, Inflate, ZStream, Z_BLOCK, Z_BUF_ERROR, Z_DATA_ERROR, Z_ERRNO, Z_FINISH, Z_FULL_FLUSH, Z_MEM_ERROR, Z_NEED_DICT, Z_NO_FLUSH, Z_OK, Z_PARTIAL_FLUSH, Z_STREAM_END, Z_STREAM_ERROR, Z_SYNC_FLUSH, Z_TREES, deflate, deflateRaw, gzip, inflate, inflate as ungzip, inflateRaw, deflate$1 as zlibDeflate, deflateEnd as zlibDeflateEnd, deflateInit as zlibDeflateInit, deflateInit2 as zlibDeflateInit2, deflateReset as zlibDeflateReset, deflateResetKeep as zlibDeflateResetKeep, deflateSetDictionary as zlibDeflateSetDictionary, deflateSetHeader as zlibDeflateSetHeader, inflate$1 as zlibInflate, inflateEnd as zlibInflateEnd, inflateGetHeader as zlibInflateGetHeader, inflateInit as zlibInflateInit, inflateInit2 as zlibInflateInit2, inflateReset as zlibInflateReset, inflateReset2 as zlibInflateReset2, inflateResetKeep as zlibInflateResetKeep, inflateSetDictionary as zlibInflateSetDictionary };\n\n//# sourceMappingURL=pako.mjs.map","// this code is modified from https://github.com/uuidjs/uuid\n\nimport { Uuid } from './brs/types';\n\n/*\nThe MIT License (MIT)\n\nCopyright (c) 2010-2020 Robert Kieffer and other contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\nconst hexTable: string[] = Array.from({ length: 256 }).map((_, i) =>\n  (i + 0x100).toString(16).substr(1),\n);\n\n// stringify uuid\nexport function uuidStringify(arr: number[]): Uuid {\n  return (\n    hexTable[arr[0]] +\n    hexTable[arr[1]] +\n    hexTable[arr[2]] +\n    hexTable[arr[3]] +\n    '-' +\n    hexTable[arr[4]] +\n    hexTable[arr[5]] +\n    '-' +\n    hexTable[arr[6]] +\n    hexTable[arr[7]] +\n    '-' +\n    hexTable[arr[8]] +\n    hexTable[arr[9]] +\n    '-' +\n    hexTable[arr[10]] +\n    hexTable[arr[11]] +\n    hexTable[arr[12]] +\n    hexTable[arr[13]] +\n    hexTable[arr[14]] +\n    hexTable[arr[15]]\n  ).toLowerCase();\n}\n\nexport function uuidParse(uuid: Uuid): Uint8Array {\n  let v;\n  const arr = new Uint8Array(16);\n\n  // Parse ########-....-....-....-............\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = (v >>> 16) & 0xff;\n  arr[2] = (v >>> 8) & 0xff;\n  arr[3] = v & 0xff;\n\n  // Parse ........-####-....-....-............\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff;\n\n  // Parse ........-....-####-....-............\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff;\n\n  // Parse ........-....-....-####-............\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff;\n\n  // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n  arr[10] = ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff;\n  arr[11] = (v / 0x100000000) & 0xff;\n  arr[12] = (v >>> 24) & 0xff;\n  arr[13] = (v >>> 16) & 0xff;\n  arr[14] = (v >>> 8) & 0xff;\n  arr[15] = v & 0xff;\n\n  return arr;\n}\n","import { deflate, inflate } from 'pako';\nimport { MAX_INT } from './constants';\nimport {\n  BRInventoryEntryPlan,\n  BRSBytes,\n  Bytes,\n  IntVector,\n  UnrealColor,\n  UnrealFloat,\n  UnrealType,\n  Uuid,\n  Vector3d,\n  WireGraphVariant,\n} from './types';\nimport { uuidParse, uuidStringify } from '../uuid';\n\n/*\n  Notes:\n    - Everything is Little Endian by default because\n      UE4 uses it.\n    - I'd use Buffer.readUInt16LE if I was making this\n      nodejs only. I don't want to require('Buffer/')\n\n */\n\n// Determine if a string is ascii-only\nfunction isASCII(text: string): boolean {\n  return /^[\\x00-\\x7F]*$/.test(text);\n}\n\n// convert BGRA color to RGBA color\nexport const bgra = ([b, g, r, a]: number[]): [\n  number,\n  number,\n  number,\n  number,\n] => [r, g, b, a];\n\n// Compare equality of byte arrays\nexport function isEqual<T>(arrA: Array<T>, arrB: Array<T>): boolean {\n  return arrA.length === arrB.length && arrA.every((a: T, i) => arrB[i] === a);\n}\n\nfunction isBRSBytes(data: Bytes): data is BRSBytes {\n  return (data as BRSBytes).brsOffset !== undefined;\n}\n\n// read `len` bytes and return slice while updating offset\nexport function subarray(data: Bytes, len: number, isCopy = false): Uint8Array {\n  if (!(data instanceof Uint8Array)) {\n    throw new Error(`Invalid data type in bytes reader (${typeof data})`);\n  }\n\n  let bytes: BRSBytes;\n  if (!isBRSBytes(data)) {\n    bytes = data as BRSBytes;\n    bytes.brsOffset = 0;\n  } else {\n    bytes = data;\n  }\n\n  const chunk = bytes[isCopy ? 'slice' : 'subarray'](\n    bytes.brsOffset,\n    bytes.brsOffset + len,\n  );\n  bytes.brsOffset += len;\n  return chunk;\n}\n\n// break a byte array into chunks of a specified size\nexport function chunk(arr: Bytes, size: number): BRSBytes[] {\n  // relative length based on the offset of the array's data view\n  const length = arr.length - (isBRSBytes(arr) ? arr.brsOffset : 0);\n\n  // out array of chunks pre-allocated\n  const out = Array(Math.floor(length / size));\n\n  for (let i = 0; i < length / size; i++) {\n    out[i] = subarray(arr, size, true);\n  }\n\n  return out;\n}\n\n// Read a u16 from a byte array\nfunction read_u16(data: Bytes, littleEndian = true): number {\n  const [a, b] = subarray(data, 2);\n\n  return littleEndian ? (b << 8) | a : (a << 8) | b;\n}\n\n// Write a u16 into byte array\nfunction write_u16(num: number, littleEndian = true): Uint8Array {\n  const data = [num & 255, (num >> 8) & 255];\n  return new Uint8Array(!littleEndian ? data.reverse() : data);\n}\n\n// Read an i32 from a byte array\nfunction read_i32(data: Bytes, littleEndian = true): number {\n  const [a, b, c, d] = subarray(data, 4);\n  return littleEndian\n    ? (d << 24) | (c << 16) | (b << 8) | a\n    : (a << 24) | (b << 16) | (c << 8) | d;\n}\n\n// Write an i32 from a byte array\nfunction write_i32(num: number, littleEndian = true): Uint8Array {\n  const data = new Uint8Array([\n    num & 255,\n    (num >> 8) & 255,\n    (num >> 16) & 255,\n    (num >> 24) & 255,\n  ]);\n\n  return !littleEndian ? data.reverse() : data;\n}\n\n// Decompress a byte array of compressed data\nfunction read_compressed(data: Bytes): Bytes {\n  const uncompressedSize = read_i32(data);\n  const compressedSize = read_i32(data);\n\n  // Throw error for weird compression/uncompression sizes\n  if (\n    compressedSize < 0 ||\n    uncompressedSize < 0 ||\n    compressedSize >= uncompressedSize\n  ) {\n    throw new Error(\n      `Invalid compressed section size (comp: ${compressedSize}, uncomp: ${uncompressedSize})`,\n    );\n  }\n\n  // No compressed data? Return those bytes\n  if (compressedSize === 0) {\n    return subarray(data, uncompressedSize);\n  } else {\n    // Decompress the data otherwise\n    const compressed = subarray(data, compressedSize);\n    return inflate(compressed);\n  }\n}\n\n// Compress a byte array into fewer bytes\nfunction write_uncompressed(...args: Uint8Array[]): Uint8Array {\n  // Concat the args to one massive array\n  const data = concat(...args);\n\n  // Build the output\n  return concat(write_i32(data.length), write_i32(0), data);\n}\n\n// Compress a byte array into fewer bytes\nfunction write_compressed(...args: Uint8Array[]): Uint8Array {\n  // Concat the args to one massive array\n  const data = concat(...args);\n\n  // Do the compression\n  const compressed = deflate(data);\n  const uncompressedSize = data.length;\n  const compressedSize = compressed.length;\n\n  if (uncompressedSize > MAX_INT) {\n    throw new Error(`uncompressedSize (${uncompressedSize}) out of range`);\n  }\n\n  if (compressedSize > MAX_INT) {\n    throw new Error(`compressedSize (${compressedSize}) out of range`);\n  }\n\n  // Determine if compression increases size\n  const badCompress = compressedSize >= uncompressedSize;\n\n  // Build the output\n  return concat(\n    write_i32(uncompressedSize),\n    write_i32(badCompress ? 0 : compressedSize),\n    badCompress ? data : compressed,\n  );\n}\n\n// Read a string from a byte array\nfunction read_string(data: Bytes): string {\n  const raw_size = read_i32(data);\n  const is_ucs2 = raw_size < 0;\n  const size = is_ucs2 ? -raw_size * 2 : raw_size;\n\n  // Determine if we are using UCS-2\n  if (is_ucs2) {\n    if (size % 2 !== 0) {\n      throw new Error('Invalid UCS-2 data size');\n    }\n\n    // Create ucs2 encoded string\n    return String.fromCodePoint(\n      // Read the data in 2 byte windows\n      ...chunk(subarray(data, size), 2).map(arr => read_u16(arr)), // Convert the two bytes into u16\n    );\n  } else {\n    // Read the data, remove the \\u0000 at the end :)\n    const strData = subarray(data, size).subarray(0, -1);\n\n    // Convert into ascii\n    // console.debug('[debug] strdata', strData);\n    return String.fromCharCode.apply(null, strData);\n  }\n}\n\n// Write a string to bytes\nfunction write_string(str: string): Uint8Array {\n  if (isASCII(str)) {\n    return concat(\n      write_i32(str.length + 1), // Write string length (+ null term)\n      new Uint8Array(str.split('').map(s => s.charCodeAt(0))), // Write string as bytes\n      new Uint8Array([0]), // Null terminator\n    );\n  } else {\n    // ucs2 strings denoted by negative length\n    const len = -str.length;\n    return concat(\n      write_i32(len), // write length\n      // convert string to little endian ucs2\n      new Uint8Array(\n        str\n          .split('')\n          .flatMap(s => [s.charCodeAt(0) & 0xff, s.charCodeAt(0) >> 8]),\n      ),\n      // new Uint8Array([0]) // Null terminator\n    );\n  }\n}\n\n// Read uuid from 4 LE ints\nfunction read_uuid(data: Bytes): string {\n  return uuidStringify(\n    // each chunk is LE\n    chunk(subarray(data, 16), 4).flatMap(([a, b, c, d]) => [d, c, b, a]),\n  );\n}\n\n// parse a uuid into 4 LE ints\nfunction write_uuid(uuid: Uuid) {\n  return concat(\n    ...chunk(uuidParse(uuid), 4).map(\n      ([a, b, c, d]) => new Uint8Array([d, c, b, a]),\n    ),\n  );\n}\n\n// Read an array of things given a fn\nfunction read_array<T>(data: Bytes, fn: (_: Bytes) => T): T[] {\n  const length = read_i32(data);\n  const arr = Array(length);\n  for (let i = 0; i < length; i++) {\n    arr[i] = fn(data);\n  }\n  return arr;\n}\n\n// iterate an array of things given a fn\nfunction read_each(data: Bytes, fn: (_: Bytes) => void) {\n  const length = read_i32(data);\n  for (let i = 0; i < length; i++) {\n    fn(data);\n  }\n}\n\n// Write an array of things to bytes\nfunction write_array<T>(arr: T[], fn: (_: T) => Uint8Array) {\n  return concat(write_i32(arr.length), ...arr.map(o => fn(o)));\n}\n\n// Tool for reading byte arrays 1 bit at a time\nexport class BitReader {\n  buffer: Uint8Array;\n  pos: number = 0;\n\n  constructor(data: Uint8Array) {\n    this.buffer = data;\n  }\n\n  empty(): boolean {\n    return this.pos >= this.buffer.length * 8;\n  }\n\n  // Read one bit as a boolean\n  bit(): boolean {\n    const bit = (this.buffer[this.pos >> 3] & (1 << (this.pos & 0b111))) !== 0;\n    this.pos++;\n    return bit;\n  }\n\n  // Align the pos to the nearest byte\n  align() {\n    this.pos = (this.pos + 7) & ~7;\n  }\n\n  // read an int up to max\n  int(max: number): number {\n    let value = 0;\n    let mask = 1;\n\n    while (value + mask < max && mask !== 0) {\n      if (this.bit()) {\n        value |= mask;\n      }\n      mask <<= 1;\n    }\n\n    return value;\n  }\n\n  // read a packet in from bits\n  uint_packed(): number {\n    let value = 0;\n    for (let i = 0; i < 5; i++) {\n      const next = this.bit();\n\n      let part = 0;\n      for (let shift = 0; shift < 7; shift++) {\n        part |= (this.bit() ? 1 : 0) << shift;\n      }\n      value |= part << (7 * i);\n      if (!next) {\n        break;\n      }\n    }\n\n    return value;\n  }\n\n  // an item in a read_positive_int_vector array\n  int_packed(): number {\n    const value = this.uint_packed();\n    return (value >> 1) * ((value & 1) !== 0 ? 1 : -1);\n  }\n\n  // read some bits\n  bits(num: number): number[] {\n    const arr: number[] = [];\n    for (let bit = 0; bit < num; bit++) {\n      const shift = bit & 7;\n      arr[bit >> 3] =\n        (arr[bit >> 3] & ~(1 << shift)) | ((this.bit() ? 1 : 0) << shift);\n    }\n    return arr;\n  }\n\n  // Read some bytes\n  bytes(num: number): Uint8Array {\n    return new Uint8Array(this.bytesArr(num));\n  }\n\n  // read some bytes but not as a Uint8Array\n  bytesArr(num: number): number[] {\n    return this.bits(num * 8);\n  }\n\n  // read an array\n  array<T>(fn: (_: BitReader) => T): T[] {\n    const length = read_i32(this.bytes(4));\n    const arr = Array(length);\n    for (let i = 0; i < length; i++) {\n      arr[i] = fn(this);\n    }\n    return arr;\n  }\n\n  // for each\n  each(fn: (data: BitReader) => void) {\n    const length = read_i32(this.bytes(4));\n    for (let i = 0; i < length; i++) {\n      fn(this);\n    }\n  }\n\n  // read a string\n  string(): string {\n    const lenBytes = this.bytesArr(4);\n    let len = read_i32(new Uint8Array(lenBytes));\n    if (len < 0) len = -len * 2;\n    return read_string(new Uint8Array(lenBytes.concat(this.bytesArr(len))));\n  }\n\n  // read a 32-bit float\n  float(): number {\n    const view = new DataView(new ArrayBuffer(4));\n\n    // Write the ints to it\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a float; note that by doing this, we're implicitly\n    // converting it from a 32-bit float into JavaScript's native 64-bit double\n    return view.getFloat32(0);\n  }\n\n  integer(): number {\n    const view = new DataView(new ArrayBuffer(4));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a signed 32-bit integer\n    return view.getInt32(0);\n  }\n\n  int64(): number {\n    const view = new DataView(new ArrayBuffer(8));\n\n    // Read it 2 bytes at a time\n    view.setUint16(6, read_u16(this.bytes(2)));\n    view.setUint16(4, read_u16(this.bytes(2)));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a signed 64-bit integer\n    const num = view.getBigInt64(0);\n    if (num <= 1n << 64n) {\n      return Number(num);\n    }\n    throw new Error(\n      `Cannot read 64-bit integer ${num} as a JavaScript number...`,\n    );\n  }\n\n  // read a 64-bit double\n  double(): number {\n    const view = new DataView(new ArrayBuffer(8));\n\n    // Read it 2 bytes at a time\n    view.setUint16(6, read_u16(this.bytes(2)));\n    view.setUint16(4, read_u16(this.bytes(2)));\n    view.setUint16(2, read_u16(this.bytes(2)));\n    view.setUint16(0, read_u16(this.bytes(2)));\n\n    // Read the bits as a double\n    return view.getFloat64(0);\n  }\n\n  wireGraphVariant(): WireGraphVariant {\n    const type = this.bytes(1)[0];\n    switch (type) {\n      case 0: // number\n        return { number: this.double() };\n      case 1: // integer\n        return { integer: this.int64() };\n      case 2: // bool\n        return { bool: this.bytes(1)[0] !== 0 };\n      case 3: // exec\n        return { exec: true };\n      case 4: // object\n        return { object: true };\n      default:\n        throw new Error(`Unknown wire graph variant type ${type}`);\n    }\n  }\n\n  // read unreal types\n  unreal(type: string): UnrealType {\n    switch (type) {\n      case 'String':\n      case 'Class':\n      case 'Object':\n        return this.string();\n      case 'Boolean':\n        return !!read_i32(this.bytes(4));\n      case 'Integer':\n        return this.integer();\n      case 'Integer64':\n        return this.int64();\n      case 'Float':\n        return this.float();\n      case 'Double':\n        return this.double();\n      case 'Color':\n        return bgra(this.bytesArr(4)) as UnrealColor;\n      case 'Byte':\n        return this.bytes(1)[0];\n      case 'Rotator':\n      case 'Rotator3d':\n        return [this.float(), this.float(), this.float()];\n      case 'Vector3d':\n        return [this.float(), this.float(), this.float()] as Vector3d;\n      case 'IntVector':\n        return [this.integer(), this.integer(), this.integer()] as IntVector;\n      case 'BRInventoryEntryPlan':\n        return this.string() as BRInventoryEntryPlan;\n      case 'WireGraphVariant':\n        return this.wireGraphVariant();\n      case 'WireGraphPrimMathVariant':\n        return this.wireGraphVariant();\n    }\n    throw new Error('Unknown unreal type ' + type);\n  }\n}\n\nexport class BitWriter {\n  buffer: number[] = [];\n  cur: number = 0;\n  bitNum: number = 0;\n\n  // Write a boolean as a bit\n  bit(val: boolean) {\n    this.cur |= (val ? 1 : 0) << this.bitNum;\n    this.bitNum++;\n    if (this.bitNum >= 8) {\n      this.align();\n    }\n  }\n\n  // Write `len` bits from `src` bytes\n  bits(src: number[] | Uint8Array, len: number) {\n    for (let bit = 0; bit < len; bit++) {\n      this.bit((src[bit >> 3] & (1 << (bit & 7))) !== 0);\n    }\n  }\n\n  // Write multiple bytes\n  bytes(src: number[] | Uint8Array) {\n    this.bits(src, 8 * src.length);\n  }\n\n  // Push the current bit into the buffer\n  align() {\n    if (this.bitNum > 0) {\n      this.buffer.push(this.cur);\n      this.cur = 0;\n      this.bitNum = 0;\n    }\n  }\n\n  // Write an int up to the potential max size\n  int(value: number, max: number) {\n    if (max < 2) {\n      throw new Error(\n        `Invalid input (BitWriter) -- max (${max}) must be at least 2`,\n      );\n    }\n\n    if (value >= max) {\n      throw new Error(\n        `Invalid input (BitWriter) -- value (${value}) is larger than max (${max})`,\n      );\n    }\n\n    let new_val = 0;\n    let mask = 1;\n\n    while (new_val + mask < max && mask !== 0) {\n      this.bit((value & mask) !== 0);\n      if ((value & mask) !== 0) {\n        new_val |= mask;\n      }\n\n      mask <<= 1;\n    }\n  }\n\n  // Write a packed unsigned int\n  uint_packed(value: number) {\n    do {\n      const src = value & 0b1111111;\n      value >>= 7;\n      this.bit(value !== 0);\n      this.bits([src], 7);\n    } while (value !== 0);\n  }\n\n  // Write a packed integer\n  int_packed(value: number) {\n    this.uint_packed((Math.abs(value) << 1) | (value >= 0 ? 1 : 0));\n  }\n\n  // Return built buffer\n  finish(): Uint8Array {\n    this.align();\n    return new Uint8Array(this.buffer);\n  }\n\n  // Return built buffer (and include length)\n  finishSection() {\n    this.align();\n    return concat(write_i32(this.buffer.length), new Uint8Array(this.buffer));\n  }\n\n  // write a string\n  string(str: string) {\n    this.bytes(write_string(str));\n  }\n\n  float(num: UnrealFloat) {\n    // create a float array\n    const floatArr = new Float32Array(1);\n    // assign the number\n    floatArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(floatArr.buffer);\n    this.bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);\n  }\n\n  integer(num: number) {\n    // create an int array\n    const intArr = new Int32Array(1);\n    // assign the number\n    intArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(intArr.buffer);\n    this.bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);\n  }\n\n  int64(num: number | bigint | string) {\n    // write this as a 64-bit integer using a dataview\n    const view = new DataView(new ArrayBuffer(8));\n    view.setBigInt64(0, typeof num === 'bigint' ? num : BigInt(num), true);\n    this.bytes(new Uint8Array(view.buffer));\n  }\n\n  double(num: number) {\n    // create a double array\n    const doubleArr = new Float64Array(1);\n    // assign the number\n    doubleArr[0] = num;\n    // convert it into a byte array\n    const bytes = new Int8Array(doubleArr.buffer);\n    this.bytes([\n      bytes[0],\n      bytes[1],\n      bytes[2],\n      bytes[3],\n      bytes[4],\n      bytes[5],\n      bytes[6],\n      bytes[7],\n    ]);\n  }\n\n  wireGraphVariant(variant: WireGraphVariant) {\n    if ('number' in variant) {\n      this.bytes([0]); // type 0\n      this.double(variant.number);\n    } else if ('integer' in variant) {\n      this.bytes([1]); // type 1\n      this.int64(variant.integer);\n    } else if ('bool' in variant) {\n      this.bytes([2, variant.bool ? 1 : 0]); // type 2\n    } else if ('exec' in variant) {\n      this.bytes([3]); // type 3\n      // no data for exec\n    } else if ('object' in variant) {\n      this.bytes([4]); // type 4\n      // no data for object\n    } else {\n      throw new Error(\n        `Unknown wire graph variant type ${JSON.stringify(variant)}`,\n      );\n    }\n  }\n\n  // run a function with `this` as a BitReader\n  self(fn: (this: BitWriter) => void) {\n    fn.bind(this)();\n    return this;\n  }\n\n  // write an array\n  array<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {\n    this.bytes(write_i32(arr.length));\n    arr.forEach(fn.bind(this));\n    return this;\n  }\n\n  // write things from an array\n  each<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {\n    arr.forEach(fn.bind(this));\n    return this;\n  }\n\n  // write unreal types\n  unreal(type: string, value: UnrealType) {\n    switch (type) {\n      case 'Class':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type Class, did not receive string (${value})`,\n          );\n        }\n        this.string(value);\n        return;\n      case 'String':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type String, did not receive string (${value})`,\n          );\n        }\n        this.string(value);\n        return;\n      case 'Object':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type Object, did not receive string (${value})`,\n          );\n        }\n        this.string(value);\n        return;\n      case 'Boolean':\n        if (typeof value !== 'boolean') {\n          throw new Error(\n            `writing unreal type Boolean, did not receive boolean (${value})`,\n          );\n        }\n        this.bytes(write_i32(value ? 1 : 0));\n        return;\n      case 'Float':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Float, did not receive float (${value})`,\n          );\n        }\n        this.float(value);\n        return;\n      case 'Byte':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Byte, did not receive Byte (${value})`,\n          );\n        }\n        this.bytes([value & 255]);\n        return;\n      case 'Color':\n        if (!Array.isArray(value) || value.length !== 4) {\n          throw new Error(\n            `writing unreal type Color, did not receive Array (${value})`,\n          );\n        }\n        this.bytes(bgra(value));\n        return;\n      case 'Rotator':\n      case 'Rotator3d':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type Rotator, did not receive Array (${value})`,\n          );\n        }\n\n        this.float(value[0]);\n        this.float(value[1]);\n        this.float(value[2]);\n        return;\n      case 'Vector3d':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type Vector3d, did not receive Array (${value})`,\n          );\n        }\n\n        this.float(value[0]);\n        this.float(value[1]);\n        this.float(value[2]);\n        return;\n      case 'IntVector':\n        if (!Array.isArray(value) || value.length !== 3) {\n          throw new Error(\n            `writing unreal type IntVector, did not receive Array (${value})`,\n          );\n        }\n        this.integer(value[0]);\n        this.integer(value[1]);\n        this.integer(value[2]);\n        return;\n      case 'Integer':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Integer, did not receive integer (${value})`,\n          );\n        }\n        this.integer(value);\n        return;\n      case 'Integer64':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Integer64, did not receive integer (${value})`,\n          );\n        }\n        this.int64(value);\n        return;\n      case 'Double':\n        if (typeof value !== 'number') {\n          throw new Error(\n            `writing unreal type Double, did not receive double (${value})`,\n          );\n        }\n        this.double(value);\n        return;\n      case 'WireGraphVariant':\n        if (typeof value !== 'object') {\n          throw new Error(\n            `writing unreal type WireGraphVariant, did not receive object (${value})`,\n          );\n        }\n        this.wireGraphVariant(value as WireGraphVariant);\n        return;\n      case 'WireGraphPrimMathVariant':\n        if (typeof value !== 'object') {\n          throw new Error(\n            `writing unreal type WireGraphPrimMathVariant, did not receive object (${value})`,\n          );\n        }\n        this.wireGraphVariant(value as WireGraphVariant);\n        return;\n      case 'BRInventoryEntryPlan':\n        if (typeof value !== 'string') {\n          throw new Error(\n            `writing unreal type BRInventoryEntryPlan, did not receive string (${value})`,\n          );\n        }\n        this.string(value);\n        return;\n    }\n    throw new Error('Unknown unreal type ' + type);\n  }\n}\n\n// concat uint8arrays together\nexport function concat(...arrays: Uint8Array[]): Uint8Array {\n  const buffLen = arrays.reduce((sum, value) => sum + value.length, 0);\n  const buff = new Uint8Array(buffLen);\n\n  // for each array - copy it over buff\n  // next array is copied right after the previous one\n  let length = 0;\n  for (const array of arrays) {\n    buff.set(array, length);\n    length += array.length;\n  }\n\n  return buff;\n}\n\nexport const read = {\n  bytes: subarray,\n  u16: read_u16,\n  i32: read_i32,\n  compressed: read_compressed,\n  string: read_string,\n  uuid: read_uuid,\n  array: read_array,\n  each: read_each,\n  bits: (data: Bytes) => new BitReader(data),\n};\n\nexport const write = {\n  u16: write_u16,\n  i32: write_i32,\n  compressed: write_compressed,\n  uncompressed: write_uncompressed,\n  string: write_string,\n  uuid: write_uuid,\n  array: write_array,\n  bits: () => new BitWriter(),\n};\n","import {\n  BrickV1,\n  BRSBytes,\n  BrsV1,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV1(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV1 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n\n  // Read in bricks\n  let bricks: BrickV1[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        collision,\n        position,\n        direction,\n        rotation,\n        visibility,\n        color,\n      };\n    }\n  }\n\n  return {\n    version: 1,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV10,\n  BRSBytes,\n  BrsV10,\n  Collision,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV10(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV10 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV10[] = [];\n  const components: BrsV10['components'] = {};\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision: Collision = {\n        player: brickBits.bit(),\n        weapon: brickBits.bit(),\n        interaction: brickBits.bit(),\n        tool: brickBits.bit(),\n        physics: false, // v10 does not have physics collision\n      };\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision: collision as Collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 10,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV10,\n  BRSBytes,\n  BrsV14,\n  Collision,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n  Wire,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV14(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV14 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    display_name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV10[] = [];\n  const components: BrsV14['components'] = {};\n  const wires: Wire[] = [];\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision: Collision = {\n        player: brickBits.bit(),\n        weapon: brickBits.bit(),\n        interaction: brickBits.bit(),\n        tool: brickBits.bit(),\n        physics: brickBits.bit(),\n      };\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision: collision as Collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const wiresData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n    const componentIndex: string[] = [];\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      if (!(name in components)) {\n        componentIndex.push(name);\n      }\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n\n    const numComponents = Math.max(componentIndex.length, 2);\n\n    {\n      const bits = read.bits(wiresData);\n\n      const numWires = bits.int(4294967295); // u32 max\n      for (let i = 0; i < numWires; i++) {\n        const srcBrick = bits.int(numBricks);\n        const srcComponentIndex = bits.int(numComponents);\n        const srcPort = bits.string();\n\n        const dstBrick = bits.int(numBricks);\n        const dstComponentIndex = bits.int(numComponents);\n        const dstPort = bits.string();\n\n        bits.bit(); // \"skip prev bit that was in use lmao\"\n        bits.align();\n\n        wires.push({\n          source: {\n            brick_index: srcBrick,\n            component: componentIndex[srcComponentIndex],\n            port: srcPort,\n          },\n          target: {\n            brick_index: dstBrick,\n            component: componentIndex[dstComponentIndex],\n            port: dstPort,\n          },\n        });\n      }\n    }\n  }\n\n  return {\n    version: 14,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n    wires,\n  };\n}\n","import {\n  BrickV2,\n  BRSBytes,\n  BrsV2,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV2(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV2 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n\n  // Read in bricks\n  let bricks: BrickV2[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n      };\n    }\n  }\n\n  return {\n    version: 2,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  BrickV3,\n  BRSBytes,\n  BrsV3,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV3(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV3 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners: User[] = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n  }));\n\n  // Read in bricks\n  let bricks: BrickV3[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n      };\n    }\n  }\n\n  return {\n    version: 3,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    bricks,\n    brick_count,\n  };\n}\n","import {\n  BrickV3,\n  BRSBytes,\n  BrsV4,\n  ReadOptions,\n  UnrealColor,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV4(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV4 {\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n  }));\n\n  // Read in bricks\n  let bricks: BrickV3[] = [];\n\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.bit() ? brickBits.uint_packed() : 1;\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n      };\n    }\n  }\n\n  return {\n    version: 4,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    bricks,\n    brick_count,\n    save_time,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV8,\n  BRSBytes,\n  BrsV8,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV8(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV8 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV8[] = [];\n  const components: BrsV8['components'] = {};\n\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n\n      const color = brickBits.bit()\n        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        color,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 8,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import {\n  AppliedComponent,\n  BrickV9,\n  BRSBytes,\n  BrsV9,\n  ColorRgb,\n  ReadOptions,\n  UnrealColor,\n  User,\n  Vector,\n} from './types';\nimport { bgra, read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrsV9(\n  brsData: BRSBytes,\n  options: ReadOptions = {}\n): BrsV9 {\n  // game version is included in saves >= v8\n  const game_version = read.i32(brsData);\n\n  // Read in Headers\n  const header1Data = read.compressed(brsData);\n  const header2Data = read.compressed(brsData);\n\n  const map = read.string(header1Data);\n  const author_name = read.string(header1Data);\n  const description = read.string(header1Data);\n  const author_id = read.uuid(header1Data);\n\n  const host: User = {\n    name: read.string(header1Data),\n    id: read.uuid(header1Data),\n  };\n  const save_time = read.bytes(header1Data, 8);\n\n  const brick_count = read.i32(header1Data);\n\n  const mods = read.array(header2Data, read.string);\n  const brick_assets = read.array(header2Data, read.string);\n  const colors = read.array(\n    header2Data,\n    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor\n  );\n  const materials = read.array(header2Data, read.string);\n  const brick_owners = read.array(header2Data, data => ({\n    id: read.uuid(data),\n    name: read.string(data),\n    bricks: read.i32(data),\n  }));\n\n  const physical_materials = read.array(header2Data, read.string);\n\n  // check for preview byte\n  let preview = null;\n  if (read.bytes(brsData, 1)[0]) {\n    const len = read.i32(brsData);\n    if (options.preview) {\n      preview = read.bytes(brsData, len);\n    } else {\n      brsData.brsOffset += len;\n    }\n  }\n\n  // Read in bricks\n  let bricks: BrickV9[] = [];\n  const components: BrsV9['components'] = {};\n\n  const numPhysMats = Math.max(physical_materials.length, 2);\n  const numMats = Math.max(materials.length, 2);\n  const numAssets = Math.max(brick_assets.length, 2);\n\n  if (options.bricks) {\n    bricks = Array(brick_count);\n    const brickData = read.compressed(brsData);\n    const brickBits = read.bits(brickData);\n\n    // Brick reader\n    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {\n      brickBits.align();\n      const asset_name_index = brickBits.int(numAssets);\n      const size: Vector = brickBits.bit()\n        ? [\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n            brickBits.uint_packed(),\n          ]\n        : [0, 0, 0];\n      const position: Vector = [\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n        brickBits.int_packed(),\n      ];\n\n      const orientation = brickBits.int(24);\n      const direction = (orientation >> 2) % 6;\n      const rotation = orientation & 3;\n      const collision = brickBits.bit();\n      const visibility = brickBits.bit();\n      const material_index = brickBits.int(numMats);\n      const physical_index = brickBits.int(numPhysMats);\n      const material_intensity = brickBits.int(11);\n\n      const color = brickBits.bit()\n        ? (brickBits.bytesArr(3) as [number, number, number])\n        : brickBits.int(colors.length);\n\n      const owner_index = brickBits.uint_packed();\n\n      bricks[i] = {\n        asset_name_index,\n        size,\n        position,\n        direction,\n        rotation,\n        collision,\n        visibility,\n        material_index,\n        physical_index,\n        material_intensity,\n        color: color as ColorRgb | number,\n        owner_index,\n        components: {},\n      };\n    }\n\n    const componentData = read.compressed(brsData);\n    const numBricks = Math.max(bricks.length, 2);\n\n    read.each(componentData, data => {\n      // read component name\n      const name = read.string(data);\n\n      // read component body\n      const bits = read.bits(read.bytes(data, read.i32(data)));\n\n      const version = read.i32(bits.bytes(4));\n      // list of bricks\n      const brick_indices = bits.array(() => bits.int(numBricks));\n\n      // list of name, type properties\n      const properties = bits.array(() => [bits.string(), bits.string()]);\n\n      // read components for each brick\n      for (const i of brick_indices) {\n        const props: AppliedComponent = {};\n        for (const [name, type] of properties) props[name] = bits.unreal(type);\n        bricks[i].components[name] = props;\n      }\n\n      components[name] = {\n        version,\n        brick_indices,\n        properties: Object.fromEntries(properties),\n      };\n    });\n  }\n\n  return {\n    version: 9,\n    game_version,\n    map,\n    description,\n    author: {\n      id: author_id,\n      name: author_name,\n    },\n    host,\n    mods,\n    brick_assets,\n    colors,\n    materials,\n    brick_owners,\n    physical_materials,\n    preview,\n    bricks,\n    brick_count,\n    save_time,\n    components,\n  };\n}\n","import { MAGIC } from './constants';\nimport readBrsV1 from './read.v1';\nimport readBrsV10 from './read.v10';\nimport readBrsV14 from './read.v14';\nimport readBrsV2 from './read.v2';\nimport readBrsV3 from './read.v3';\nimport readBrsV4 from './read.v4';\nimport readBrsV8 from './read.v8';\nimport readBrsV9 from './read.v9';\nimport { BRSBytes, ReadOptions, ReadSaveObject } from './types';\nimport { read } from './utils';\n\n// Reads in a byte array to build a brs object\nexport default function readBrs(\n  rawBytes: Uint8Array,\n  options: ReadOptions = {}\n): ReadSaveObject {\n  if (typeof options !== 'object') throw new Error('Invalid options');\n\n  // default enable brick reading\n  if (typeof options.bricks !== 'boolean') options.bricks = true;\n\n  // default disable preview (a5 only)\n  if (typeof options.preview !== 'boolean') options.preview = false;\n\n  // Determine if the first 3 bytes are equal to the Brickadia save magic bytes\n  if (\n    rawBytes[0] !== MAGIC[0] ||\n    rawBytes[1] !== MAGIC[1] ||\n    rawBytes[2] !== MAGIC[2]\n  ) {\n    throw new Error('Invalid starting bytes');\n  }\n\n  const brsData = rawBytes as BRSBytes;\n  brsData.brsOffset = 3;\n\n  // Determine if the file version supported\n  const version = read.u16(brsData);\n  switch (version) {\n    case 1:\n      return readBrsV1(brsData, options);\n    case 2:\n      return readBrsV2(brsData, options);\n    case 3:\n      return readBrsV3(brsData, options);\n    case 4:\n      return readBrsV4(brsData, options);\n    case 8:\n      return readBrsV8(brsData, options);\n    case 9:\n      return readBrsV9(brsData, options);\n    case 10:\n      return readBrsV10(brsData, options);\n    case 14:\n      return readBrsV14(brsData, options);\n    default:\n      throw new Error('Unsupported version ' + version);\n  }\n}\n","import { DEFAULT_UUID, LATEST_VERSION, MAGIC, MAX_INT } from './constants';\nimport {\n  Brick,\n  DefinedComponents,\n  Owner,\n  WriteOptions,\n  WriteSaveObject,\n} from './types';\nimport { concat, isEqual, write } from './utils';\n\nconst EMPTY_ARR = new Uint8Array([]);\n\nexport const DEFAULT_COMPONENTS: DefinedComponents = {\n  BCD_SpotLight: {\n    version: 1,\n    properties: {\n      Rotation: 'Rotator',\n      InnerConeAngle: 'Float',\n      OuterConeAngle: 'Float',\n      Brightness: 'Float',\n      Radius: 'Float',\n      Color: 'Color',\n      bUseBrickColor: 'Boolean',\n      bCastShadows: 'Boolean',\n    },\n  },\n  BCD_PointLight: {\n    version: 1,\n    properties: {\n      bMatchBrickShape: 'Boolean',\n      Brightness: 'Float',\n      Radius: 'Float',\n      Color: 'Color',\n      bUseBrickColor: 'Boolean',\n      bCastShadows: 'Boolean',\n    },\n  },\n  BCD_ItemSpawn: {\n    version: 1,\n    properties: {\n      PickupClass: 'Class',\n      bPickupEnabled: 'Boolean',\n      bPickupRespawnOnMinigameReset: 'Boolean',\n      PickupMinigameResetRespawnDelay: 'Float',\n      bPickupAutoDisableOnPickup: 'Boolean',\n      PickupRespawnTime: 'Float',\n      PickupOffsetDirection: 'Byte',\n      PickupOffsetDistance: 'Float',\n      PickupRotation: 'Rotator',\n      PickupScale: 'Float',\n      bPickupAnimationEnabled: 'Boolean',\n      PickupAnimationAxis: 'Byte',\n      bPickupAnimationAxisLocal: 'Boolean',\n      PickupSpinSpeed: 'Float',\n      PickupBobSpeed: 'Float',\n      PickupBobHeight: 'Float',\n      PickupAnimationPhase: 'Float',\n    },\n  },\n  BCD_Interact: {\n    version: 1,\n    properties: {\n      bPlayInteractSound: 'Boolean',\n      Message: 'String',\n      ConsoleTag: 'String',\n    },\n  },\n  BCD_AudioEmitter: {\n    version: 1,\n    properties: {\n      AudioDescriptor: 'Object',\n      VolumeMultiplier: 'Float',\n      PitchMultiplier: 'Float',\n      InnerRadius: 'Float',\n      MaxDistance: 'Float',\n      bSpatialization: 'Boolean',\n    },\n  },\n  Component_Internal_Rerouter: {\n    version: 1,\n    properties: {},\n  },\n  BrickComponentType_Internal_ReadBrickGrid: {\n    version: 1,\n    properties: {},\n  },\n  BrickComponentType_WireGraphPseudo_BufferSeconds: {\n    version: 1,\n    properties: {\n      SecondsToWait: 'Float',\n      ZeroSecondsToWait: 'Float',\n      CurrentTime: 'Float',\n      Input: 'WireGraphVariant',\n      Output: 'WireGraphVariant',\n      Buffered: 'WireGraphVariant',\n      Queued: 'WireGraphVariant',\n      bHasQueued: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraphPseudo_BufferTicks: {\n    version: 1,\n    properties: {\n      TicksToWait: 'Integer',\n      ZeroTicksToWait: 'Integer',\n      CurrentTicks: 'Integer',\n      Input: 'WireGraphVariant',\n      Output: 'WireGraphVariant',\n      Buffered: 'WireGraphVariant',\n      Queued: 'WireGraphVariant',\n      bHasQueued: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraphPseudo_Const: {\n    version: 1,\n    properties: {\n      Value: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseAND: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNAND: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseNOT: {\n    version: 1,\n    properties: {\n      Input: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseShiftRight: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_BitwiseXOR: {\n    version: 1,\n    properties: {\n      InputA: 'Integer64',\n      InputB: 'Integer64',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_Ceil: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphVariant',\n      InputB: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareGreater: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareLess: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareLessOrEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_CompareNotEqual: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphVariant',\n      InputB: 'WireGraphVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_Floor: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalAND: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNAND: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalNOT: {\n    version: 1,\n    properties: {\n      bInput: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_LogicalXOR: {\n    version: 1,\n    properties: {\n      bInputA: 'Boolean',\n      bInputB: 'Boolean',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathAdd: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathBlend: {\n    version: 1,\n\n    properties: {\n      Blend: 'Double',\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathDivide: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathModulo: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathModuloFloored: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathMultiply: {\n    version: 1,\n\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponentType_WireGraph_Expr_MathSubtract: {\n    version: 1,\n    properties: {\n      InputA: 'WireGraphPrimMathVariant',\n      InputB: 'WireGraphPrimMathVariant',\n    },\n  },\n  BrickComponent_WireGraph_Expr_EdgeDetector: {\n    version: 1,\n    properties: {\n      Input: 'Double',\n      bPulseOnRisingEdge: 'Boolean',\n      bPulseOnFallingEdge: 'Boolean',\n    },\n  },\n};\n\nexport default function writeBrs(\n  save: WriteSaveObject,\n  options: WriteOptions = {}\n) {\n  if (typeof save !== 'object') {\n    throw new Error('Expected save to be an object');\n  }\n\n  if (!Array.isArray(save.bricks) || save.bricks.length === 0) {\n    throw new Error('Expected save to have bricks field');\n  }\n\n  if (save.bricks.length > MAX_INT) {\n    throw new Error('Brick count out of range');\n  }\n\n  // compression is disabled by default\n  const compress = options.compress ? write.compressed : write.uncompressed;\n\n  // Convert from BGRA to RGBA\n  const rgba = ([r, g, b, a]: number[]) => new Uint8Array([b, g, r, a]);\n\n  // stored brick indices from components on the bricks\n  const componentBrickOwnership: { [component_name: string]: number[] } = {};\n\n  const numColors = Math.max(save.colors?.length ?? 0, 2);\n  const numAssets = Math.max(save.brick_assets?.length ?? 0, 2);\n  const numMats = Math.max(save.materials?.length ?? 0, 2);\n  const numPhysMats = Math.max(save.physical_materials?.length ?? 0, 2);\n\n  if (save.preview && !Array.isArray(save.preview))\n    throw new Error('Expected preview to be an array');\n\n  let componentMap: Record<string, number> = {};\n  let componentCount = 0;\n\n  const buff = concat(\n    // Write magic bytes\n    MAGIC,\n    write.u16(LATEST_VERSION),\n    write.i32(save.game_version ?? 0),\n\n    // Header 1\n    compress(\n      write.string(save.map ?? 'Unknown'),\n      write.string(save.author?.name ?? 'Unknown'),\n      write.string(save.description ?? ''),\n      write.uuid(save.author?.id ?? DEFAULT_UUID),\n      concat(\n        write.string(save.host?.name ?? 'Unknown'),\n        write.uuid(save.host?.id ?? DEFAULT_UUID)\n      ),\n      new Uint8Array(\n        save.save_time &&\n        (Array.isArray(save.save_time) ||\n          save.save_time instanceof Uint8Array) &&\n        save.save_time.length === 8\n          ? save.save_time\n          : [0, 0, 0, 0, 0, 0, 0, 0]\n      ),\n      write.i32(save.bricks.length)\n    ),\n\n    // Header 2\n    compress(\n      write.array(save.mods ?? [], write.string),\n      write.array(save.brick_assets ?? ['PB_DefaultBrick'], write.string),\n      write.array(save.colors ?? [], rgba),\n      write.array(save.materials ?? ['BMC_Plastic'], write.string),\n      write.array(\n        save.brick_owners ?? [],\n        ({\n          id = DEFAULT_UUID,\n          name = 'Unknown',\n          display_name = 'Unknown',\n          bricks = 0,\n        }: Partial<Owner>) =>\n          concat(\n            write.uuid(id),\n            write.string(name),\n            write.string(display_name),\n            write.i32(bricks)\n          )\n      ),\n      write.array(save.physical_materials ?? ['BPMC_Default'], write.string)\n    ),\n\n    // write the save preview if it exists\n    concat(\n      new Uint8Array([save.preview ? 1 : 0]),\n      save.preview ? write.i32(save.preview.length) : EMPTY_ARR, // <- Sorry @Uxie https://i.imgur.com/hSRxdbf.png\n      save.preview ?? EMPTY_ARR\n    ),\n\n    // Bricks\n    compress(\n      write\n        .bits()\n        .each(save.bricks, function (brick: Brick, i) {\n          if (typeof brick !== 'object')\n            throw new Error(`Expected save.bricks[${i}] to be an object`);\n\n          if (!Array.isArray(brick.size) || brick.size.length !== 3)\n            throw new Error(\n              `Expected save.bricks[${i}].size to be an array of length 3`\n            );\n\n          if (!Array.isArray(brick.position) || brick.position.length !== 3)\n            throw new Error(\n              `Expected save.bricks[${i}].position to be an array of length 3`\n            );\n\n          this.align();\n          this.int(brick.asset_name_index ?? 0, numAssets);\n\n          const isNonProcedural =\n            brick.size === null || isEqual(brick.size, [0, 0, 0]);\n          this.bit(!isNonProcedural);\n          if (!isNonProcedural) {\n            brick.size.map(s => this.uint_packed(s >= 0 ? s : 1));\n          }\n          brick.position.map(s => this.int_packed(s));\n          this.int(((brick.direction ?? 4) << 2) | (brick.rotation ?? 0), 24);\n\n          if (typeof brick.collision === 'boolean') {\n            this.bit(brick.collision);\n            this.bit(brick.collision);\n            this.bit(brick.collision);\n            this.bit(true);\n            this.bit(brick.collision);\n          } else {\n            this.bit(brick.collision?.player ?? true);\n            this.bit(brick.collision?.weapon ?? true);\n            this.bit(brick.collision?.interaction ?? true);\n            this.bit(brick.collision?.tool ?? true);\n            this.bit(brick.collision?.physics ?? true);\n          }\n\n          this.bit(brick.visibility ?? true);\n          this.int(brick.material_index ?? 0, numMats);\n          this.int(brick.physical_index ?? 0, numPhysMats);\n          this.int(brick.material_intensity ?? 5, 11);\n\n          if (typeof brick.color === 'number') {\n            this.bit(false);\n            this.int(brick.color, numColors);\n          } else {\n            this.bit(true);\n            if (\n              brick.color &&\n              (!Array.isArray(brick.color) || brick.color.length < 3)\n            )\n              throw new Error(\n                `Expected save.bricks[${i}].color to be an array of at least length 3`\n              );\n            this.bytes(\n              new Uint8Array(brick.color?.slice(0, 3) ?? [255, 255, 255])\n            );\n          }\n\n          this.uint_packed(brick.owner_index >= 0 ? brick.owner_index : 0);\n\n          // add all the brick indices to the components list\n          for (const key in brick.components ?? {}) {\n            componentBrickOwnership[key] ??= [];\n            componentBrickOwnership[key].push(i);\n          }\n        })\n        .finish()\n    ),\n\n    // write components section\n    compress(\n      write.array(\n        Object.keys(save.components ?? DEFAULT_COMPONENTS).filter(\n          name => componentBrickOwnership[name]\n        ),\n        name =>\n          concat(\n            write.string(name),\n            write\n              .bits()\n              .self(function () {\n                const component =\n                  save.components?.[name] ?? DEFAULT_COMPONENTS[name];\n                const brick_indices = componentBrickOwnership[name];\n                const properties = Object.entries(component.properties);\n\n                if (!(name in componentMap)) {\n                  componentMap[name] = componentCount;\n                  componentCount++;\n                }\n\n                // write version\n                this.bytes(write.i32(component.version));\n\n                // write bricks;\n                this.array(brick_indices, i => {\n                  this.int(i, Math.max(save.bricks.length, 2));\n                });\n\n                // write properties\n                this.array(properties, ([name, type]) => {\n                  this.string(name);\n                  this.string(type);\n                });\n\n                // read brick indices\n                for (const i of brick_indices) {\n                  for (const [prop, type] of properties) {\n                    if (!(prop in (save.bricks[i].components?.[name] ?? {}))) {\n                      throw new Error(\n                        `Expected save.bricks[${i}].components[${name}] to have property '${prop}' of type '${type}'`\n                      );\n                    }\n                    this.unreal(type, save.bricks[i].components[name][prop]);\n                  }\n                }\n                this.align();\n              })\n              .finishSection()\n          )\n      )\n    ),\n\n    compress(\n      write\n        .bits()\n        .self(function () {\n          const intMax = 4294967295;\n          if (\n            !save.wires ||\n            !Array.isArray(save.wires) ||\n            save.wires.length === 0\n          ) {\n            // if no wires, write\n            this.int(0, intMax); // u32 max\n            return;\n          }\n\n          this.int(save.wires.length, intMax);\n          for (const wire of save.wires) {\n            if (typeof wire !== 'object')\n              throw new Error('Expected save.wires to be an array of objects');\n\n            if (\n              !(\n                wire.source &&\n                typeof wire.source === 'object' &&\n                typeof wire.source.brick_index === 'number' &&\n                typeof wire.source.component === 'string' &&\n                typeof wire.source.port === 'string'\n              )\n            ) {\n              throw new Error(\n                'Expected save.wires[i].source to be an object with brick_index, component, and port properties'\n              );\n            }\n\n            if (\n              !(\n                wire.target &&\n                typeof wire.target === 'object' &&\n                typeof wire.target.brick_index === 'number' &&\n                typeof wire.target.component === 'string' &&\n                typeof wire.target.port === 'string'\n              )\n            ) {\n              throw new Error(\n                'Expected save.wires[i].target to be an object with brick_index, component, and port properties'\n              );\n            }\n\n            if (!(wire.source.component in componentMap))\n              throw new Error(\n                `Unknown component '${wire.source.component}' in wire source`\n              );\n            if (!(wire.target.component in componentMap))\n              throw new Error(\n                `Unknown component '${wire.target.component}' in wire target`\n              );\n\n            this.int(wire.source.brick_index, save.bricks.length);\n            this.int(componentMap[wire.source.component], componentCount);\n            this.string(wire.source.port);\n\n            this.int(wire.target.brick_index, save.bricks.length);\n            this.int(componentMap[wire.target.component], componentCount);\n            this.string(wire.target.port);\n\n            this.bit(false); // \"skip prev bit that was in use lmao\"\n            this.align();\n          }\n        })\n        .finish()\n    )\n  );\n  return buff;\n}\n","export interface BRSBytes extends Uint8Array {\n  brsOffset: number;\n}\n\ntype Modify<T, R> = Omit<T, keyof R> & R;\n\nexport type Bytes = Uint8Array | BRSBytes;\nexport type Uuid = string;\n\nexport type UnrealClass = string;\nexport type UnrealObject = string;\nexport type UnrealBoolean = boolean;\nexport type UnrealFloat = number;\nexport type UnrealInteger = number;\nexport type UnrealInteger64 = number;\nexport type UnrealColor = [number, number, number, number];\nexport type UnrealByte = number;\nexport type UnrealRotator = [number, number, number];\nexport type Vector3d = Vector;\nexport type IntVector = Vector;\nexport type UnrealString = string;\nexport type WireGraphVariant =\n  | { number: number }\n  | { integer: number }\n  | { bool: boolean }\n  | { exec: true }\n  | { object: true };\nexport type BRInventoryEntryPlan = string;\nexport type UnrealType =\n  | UnrealClass\n  | UnrealObject\n  | UnrealBoolean\n  | UnrealFloat\n  | UnrealColor\n  | UnrealByte\n  | UnrealRotator\n  | UnrealString\n  | WireGraphVariant\n  | UnrealInteger64\n  | Vector3d\n  | IntVector\n  | BRInventoryEntryPlan;\n\ntype UnrealTypeFromString<T> = T extends 'Class'\n  ? UnrealClass\n  : T extends 'Object'\n  ? UnrealObject\n  : T extends 'Boolean'\n  ? UnrealBoolean\n  : T extends 'Float'\n  ? UnrealFloat\n  : T extends 'Color'\n  ? UnrealColor\n  : T extends 'Byte'\n  ? UnrealByte\n  : T extends 'Rotator'\n  ? UnrealRotator\n  : T extends 'Rotator3d'\n  ? UnrealRotator\n  : T extends 'Vector3d'\n  ? Vector3d\n  : T extends 'IntVector'\n  ? IntVector\n  : T extends 'String'\n  ? UnrealString\n  : T extends 'BRInventoryEntryPlan'\n  ? BRInventoryEntryPlan\n  : T extends 'WireGraphVariant'\n  ? WireGraphVariant\n  : T extends 'WireGraphPrimMathVariant'\n  ? WireGraphVariant\n  : T extends 'Integer'\n  ? UnrealInteger\n  : T extends 'Integer64'\n  ? UnrealInteger64\n  : UnrealType;\n\nexport interface User {\n  id: Uuid;\n  name: string;\n}\n\nexport interface LegacyOwner extends User {\n  bricks: number;\n}\n\nexport interface Owner extends LegacyOwner {\n  display_name: string;\n}\n\nexport enum Direction {\n  XPositive,\n  XNegative,\n  YPositive,\n  YNegative,\n  ZPositive,\n  ZNegative,\n}\n\nexport enum Rotation {\n  Deg0,\n  Deg90,\n  Deg180,\n  Deg270,\n}\n\nexport type ColorRgb = [number, number, number];\n\nexport interface Collision {\n  player: boolean;\n  weapon: boolean;\n  interaction: boolean;\n  tool: boolean;\n  physics: boolean;\n}\n\nexport interface AppliedComponent {\n  [property: string]: UnrealType;\n}\n\nexport interface UnknownComponents {\n  [component_name: string]: {\n    version: number;\n    brick_indices?: number[];\n    properties: { [property: string]: string };\n  };\n}\n\nexport type KnownComponents = {\n  BCD_SpotLight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator';\n      InnerConeAngle: 'Float';\n      OuterConeAngle: 'Float';\n      Brightness: 'Float';\n      Radius: 'Float';\n      Color: 'Color';\n      bUseBrickColor: 'Boolean';\n      bCastShadows: 'Boolean';\n    };\n  };\n  BCD_PointLight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bMatchBrickShape: 'Boolean';\n      Brightness: 'Float';\n      Radius: 'Float';\n      Color: 'Color';\n      bUseBrickColor: 'Boolean';\n      bCastShadows: 'Boolean';\n    };\n  };\n  BCD_ItemSpawn: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PickupClass: 'Class';\n      bPickupEnabled: 'Boolean';\n      bPickupRespawnOnMinigameReset: 'Boolean';\n      PickupMinigameResetRespawnDelay: 'Float';\n      bPickupAutoDisableOnPickup: 'Boolean';\n      PickupRespawnTime: 'Float';\n      PickupOffsetDirection: 'Byte';\n      PickupOffsetDistance: 'Float';\n      PickupRotation: 'Rotator';\n      PickupScale: 'Float';\n      bPickupAnimationEnabled: 'Boolean';\n      PickupAnimationAxis: 'Byte';\n      bPickupAnimationAxisLocal: 'Boolean';\n      PickupSpinSpeed: 'Float';\n      PickupBobSpeed: 'Float';\n      PickupBobHeight: 'Float';\n      PickupAnimationPhase: 'Float';\n    };\n  };\n  BCD_Interact: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bPlayInteractSound: 'Boolean';\n      Message: 'String';\n      ConsoleTag: 'String';\n    };\n  };\n  BCD_AudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n    };\n  };\n  Component_AudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n      FocusAzimuth: 'Float';\n      NonFocusAzimuth: 'Float';\n      NonFocusVolumeAttenuation: 'Float';\n    };\n  };\n  Component_BotSpawn: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RespawnTime: 'Float';\n      CorpseTimeout: 'Float';\n      GunSkill: 'Float';\n      Agression: 'Float';\n      ReactionTime: 'Float';\n      MovementRandomness: 'Float';\n      Jumpyness: 'Float';\n      MovementAmount: 'Float';\n      AttackMovementAmount: 'Float';\n      AggroRange: 'Float';\n      bCanJump: 'Boolean';\n      bBackVision: 'Boolean';\n      bVisionRaycasting: 'Boolean';\n      bCanTargetPlayers: 'Boolean';\n      bCanTargetBots: 'Boolean';\n      MoveTarget: 'Vector3d';\n      BotWeapon: 'Class';\n    };\n  };\n  Component_CheckPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bRotatePlayerGravityOnSpawn: 'Boolean';\n    };\n  };\n  Component_Damage: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Message: 'String';\n      ConsoleTag: 'String';\n    };\n  };\n  Component_GoalPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_InputSplitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_OneShotAudioEmitter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n      bEnableRepeat: 'Boolean';\n      RepeatTime: 'Float';\n      RepeatVariance: 'Float';\n    };\n  };\n  Component_SpawnPoint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bRotatePlayerGravityOnSpawn: 'Boolean';\n      bEnable: 'Boolean';\n    };\n  };\n  Component_Target: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      OnTime: 'Float';\n    };\n  };\n  Component_Internal_AnimatedButton: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PressSound: 'Object';\n      ReleaseSound: 'Object';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_AnimatedSwitch: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      InteractSound: 'Object';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_AttachedZone: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      ZoneStartDistance: 'Integer';\n      ZoneEndDistance: 'Integer';\n      bIsBuildingZone: 'Boolean';\n      bIsLooseZone: 'Boolean';\n      bIsShareZone: 'Boolean';\n    };\n  };\n  Component_Internal_Bearing: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Joint_Wheel: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      DriveSpeed: 'Float';\n      DrivePower: 'Float';\n      bSteerEnabled: 'Boolean';\n      Steer: 'Float';\n      SteerLimitDegree: 'Float';\n      SteerPower: 'Float';\n      bSuspensionEnabled: 'Boolean';\n      SuspensionStiffness: 'Float';\n      SuspensionDamping: 'Float';\n      JointDistance: 'Integer';\n      bDriveWhenNotAttachedToEngine: 'Boolean';\n      bCanBrake: 'Boolean';\n      bAllowEngineSteerCorrect: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Motor: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      Speed: 'Float';\n      Power: 'Float';\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_MotorSlider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      Speed: 'Float';\n      Power: 'Float';\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Rerouter: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_Internal_Seat: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bIsOccupied: 'Boolean';\n      ExitOffset: 'IntVector';\n      bAllowNearbyInteraction: 'Boolean';\n      bHiddenInteraction: 'Boolean';\n      PromptCustomLabel: 'String';\n    };\n  };\n  Component_Internal_Servo: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      TargetAngle: 'Float';\n      Power: 'Float';\n      ActiveDamping: 'Float';\n      ForceLimit: 'Float';\n      bLimitAngle: 'Boolean';\n      LimitAngle: 'Float';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_ServoSlider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      TargetPosition: 'Float';\n      Power: 'Float';\n      TopSpeed: 'Float';\n      Exponent: 'Float';\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Slider: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bPositionsArePercentages: 'Boolean';\n      Damping: 'Float';\n    };\n  };\n  Component_Internal_Socket: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  Component_Internal_WeightBrick: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Mass: 'Float';\n      MassSize: 'IntVector';\n      MassOffset: 'IntVector';\n    };\n  };\n  Component_Internal_WheelEngine: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bEnabled: 'Boolean';\n      bEnableManualControl: 'Boolean';\n      ManualInput_Drive: 'Float';\n      ManualInput_Steer: 'Float';\n      bManualInput_Brake: 'Boolean';\n      CustomMass: 'Float';\n      CustomMassVerticalOffset: 'Float';\n      DriveInterpSpeed: 'Float';\n      DriveSpeed: 'Float';\n      DriveAcceleratingPowerMultiplier: 'Float';\n      DriveBrakingPowerMultiplier: 'Float';\n      DriveDampingMultiplier: 'Float';\n      SteerPowerMultiplier: 'Float';\n      SteerInterpSpeed: 'Float';\n      SteerLimitDegree: 'Float';\n      CenterOfSteering: 'Float';\n      bTankSteering: 'Boolean';\n      TankSteerSpeedMultiplier: 'Float';\n      WaterDriveForce: 'Float';\n      WaterSteeringForce: 'Float';\n      AudioDescriptor: 'Object';\n    };\n  };\n  Component_WireGraph_PlayAudioAt: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      AudioDescriptor: 'Object';\n      VolumeMultiplier: 'Float';\n      PitchMultiplier: 'Float';\n      InnerRadius: 'Float';\n      MaxDistance: 'Float';\n      bSpatialization: 'Boolean';\n    };\n  };\n  Component_WireGraph_SetInventoryEntry: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Slot: 'Integer';\n      EntryPlan: 'BRInventoryEntryPlan';\n    };\n  };\n  BrickComponentType_Internal_CharacterZoneEvent_Entered: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_CharacterZoneEvent_Left: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ReadBrickGrid: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_TeleportDestination: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ZoneEvent_BrickChanged: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_Internal_ZoneEvent_BrickRemoved: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraphPseudo_BufferSeconds: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      SecondsToWait: 'Float';\n      ZeroSecondsToWait: 'Float';\n      CurrentTime: 'Float';\n      Input: 'WireGraphVariant';\n      Output: 'WireGraphVariant';\n      Buffered: 'WireGraphVariant';\n      Queued: 'WireGraphVariant';\n      bHasQueued: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraphPseudo_BufferTicks: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      TicksToWait: 'Integer';\n      ZeroTicksToWait: 'Integer';\n      CurrentTicks: 'Integer';\n      Input: 'WireGraphVariant';\n      Output: 'WireGraphVariant';\n      Buffered: 'WireGraphVariant';\n      Queued: 'WireGraphVariant';\n      bHasQueued: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraphPseudo_Var: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Branch: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Character_SetTempPermission: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      PermissionTagStr: 'String';\n      bPermissionEnable: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Character_ShowHint: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      HintTitle: 'String';\n      HintText: 'String';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_AddLocationRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_AddVelocity: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_RelativeTeleport: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetGravityDirection: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetLocation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetLocationRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetRotation: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Rotation: 'Rotator3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_SetVelocity: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Vector: 'Vector3d';\n      Rotation: 'Vector3d';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Entity_Teleport: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Union: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {};\n  };\n  BrickComponentType_WireGraph_Exec_Var_Get: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Var_Increment: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Exec_Var_Set: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Value: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseNOT: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseShiftLeft: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseShiftRight: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_BitwiseXOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'Integer64';\n      InputB: 'Integer64';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_Ceil: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphVariant';\n      InputB: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareGreater: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareLess: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareLessOrEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_CompareNotEqual: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphVariant';\n      InputB: 'WireGraphVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_Floor: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNAND: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalNOT: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInput: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_LogicalXOR: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      bInputA: 'Boolean';\n      bInputB: 'Boolean';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathAdd: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathBlend: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Blend: 'Double';\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathDivide: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathModulo: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathModuloFloored: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathMultiply: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Expr_MathSubtract: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      InputA: 'WireGraphPrimMathVariant';\n      InputB: 'WireGraphPrimMathVariant';\n    };\n  };\n  BrickComponentType_WireGraph_Fake_Gamemode_RoundEndEvent: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RoundNumber: 'Integer';\n    };\n  };\n  BrickComponentType_WireGraph_Fake_Gamemode_RoundStartEvent: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      RoundNumber: 'Integer';\n    };\n  };\n  BrickComponent_WireGraph_Expr_EdgeDetector: {\n    version: 1;\n    brick_indices?: number[];\n    properties: {\n      Input: 'Double';\n      bPulseOnRisingEdge: 'Boolean';\n      bPulseOnFallingEdge: 'Boolean';\n    };\n  };\n};\n\nexport interface DefinedComponents\n  extends UnknownComponents,\n    Partial<KnownComponents> {}\n\nexport type Components<C extends DefinedComponents> = {\n  [T in keyof C]: {\n    [V in keyof C[T]['properties']]: UnrealTypeFromString<\n      C[T]['properties'][V]\n    >;\n  };\n} & { [component_name: string]: AppliedComponent };\n\nexport type Vector = [number, number, number];\n\nexport type WirePort = {\n  brick_index: number;\n  component: string;\n  port: string;\n};\n\nexport type Wire = {\n  source: WirePort;\n  target: WirePort;\n};\n\nexport interface BrickV1 {\n  asset_name_index: number;\n  size: Vector;\n  position: Vector;\n  direction: Direction;\n  rotation: Rotation;\n  collision: boolean;\n  visibility: boolean;\n  color: UnrealColor | number;\n}\n\nexport interface BrickV2 extends BrickV1 {\n  material_index: number;\n}\n\nexport interface BrickV3 extends BrickV2 {\n  owner_index: number;\n}\n\nexport interface BrickV8 extends BrickV3 {\n  components: Components<DefinedComponents>;\n}\n\nexport type BrickV9 = Modify<\n  BrickV8,\n  {\n    physical_index: number;\n    material_intensity: number;\n    color: ColorRgb | number;\n  }\n>;\n\nexport type BrickV10 = Modify<\n  BrickV9,\n  {\n    collision: Collision;\n  }\n>;\n\nexport interface BrsV1 {\n  version: 1;\n  map: string;\n  author: User;\n  description: string;\n  brick_count: number;\n  mods: string[];\n  brick_assets: string[];\n  colors: UnrealColor[];\n  bricks: BrickV1[];\n}\n\nexport type BrsV2 = Modify<\n  BrsV1,\n  {\n    version: 2;\n    materials: string[];\n    bricks: BrickV2[];\n  }\n>;\n\nexport type BrsV3 = Modify<\n  BrsV2,\n  {\n    version: 3;\n    brick_owners: User[];\n    bricks: BrickV3[];\n  }\n>;\n\nexport type BrsV4 = Modify<\n  BrsV3,\n  {\n    version: 4;\n    save_time: Uint8Array;\n  }\n>;\n\n// not sure what part of 8 makes up 5-7 but nobody should have any saves in those versions\n\nexport type BrsV8 = Modify<\n  BrsV4,\n  {\n    version: 8;\n    host: User;\n    brick_owners: LegacyOwner[];\n    preview?: Bytes;\n    game_version: number;\n    bricks: BrickV8[];\n    components: DefinedComponents;\n  }\n>;\n\nexport type BrsV9 = Modify<\n  BrsV8,\n  {\n    version: 9;\n    physical_materials: string[];\n    bricks: BrickV9[];\n  }\n>;\n\nexport type BrsV10 = Modify<\n  BrsV9,\n  {\n    version: 10;\n    bricks: BrickV10[];\n  }\n>;\n\nexport type BrsV14 = Modify<\n  BrsV10,\n  {\n    version: 14;\n    wires: Wire[];\n  }\n>;\n\n// a save read from a file\nexport type ReadSaveObject =\n  | BrsV1\n  | BrsV2\n  | BrsV3\n  | BrsV4\n  | BrsV8\n  | BrsV9\n  | BrsV10\n  | BrsV14;\n\n// a brick a user provides\nexport interface Brick {\n  asset_name_index?: number;\n  size: Vector;\n  position: Vector;\n  direction?: Direction;\n  rotation?: Rotation;\n  collision?: boolean | Partial<Collision>;\n  visibility?: boolean;\n  material_index?: number;\n  physical_index?: number;\n  material_intensity?: number;\n  color?: ColorRgb | number | UnrealColor | number[];\n  owner_index?: number;\n  components?: Components<DefinedComponents>;\n}\n\n// save a user can write\nexport interface WriteSaveObject {\n  game_version?: number;\n  map?: string;\n  description?: string;\n  author?: Partial<User>;\n  host?: Partial<User>;\n  mods?: string[];\n  brick_assets?: string[];\n  colors?: UnrealColor[];\n  materials?: string[];\n  brick_owners?: Partial<Owner>[];\n  physical_materials?: string[];\n  preview?: Bytes;\n  bricks: Brick[];\n  save_time?: ArrayLike<number>;\n  components?: DefinedComponents;\n  wires?: Wire[];\n}\n\nexport interface ReadOptions {\n  bricks?: boolean;\n  preview?: boolean;\n}\n\nexport interface WriteOptions {\n  compress?: boolean;\n}\n","// SoA bit-flag helpers. Boolean columns in chunk SoAs are packed as\n// { Flags: byte[] } with bit i stored at byte i >> 3, bit position i & 7.\n// Exposed so consumers can build their own SoA readers and writers.\nimport type { BrdbValue } from './schema';\n\n/** Read bit i of a packed { Flags } column. Bytes past the end read as 0. */\nexport const bit = (flags: { Flags: number[] }, i: number): boolean =>\n  (((flags.Flags[i >> 3] ?? 0) >> (i & 7)) & 1) === 1;\n\n/** Accumulate booleans into a packed { Flags } column. */\nexport class BitFlags {\n  bytes: number[] = [];\n  private bits = 0;\n  push(v: boolean) {\n    if (this.bits >= this.bytes.length * 8) this.bytes.push(0);\n    if (v) this.bytes[this.bits >> 3] |= 1 << (this.bits & 7);\n    this.bits += 1;\n  }\n  toValue(): BrdbValue {\n    return { Flags: this.bytes };\n  }\n}\n","/**\n * Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.\n * @param a - value to test\n * @returns `true` when the value is a Uint8Array-compatible view.\n * @example\n * Check whether a value is a Uint8Array-compatible view.\n * ```ts\n * isBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function isBytes(a) {\n    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases.\n    // The fallback still requires a real ArrayBuffer view, so plain\n    // JSON-deserialized `{ constructor: ... }` spoofing is rejected, and\n    // `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.\n    return (a instanceof Uint8Array ||\n        (ArrayBuffer.isView(a) &&\n            a.constructor.name === 'Uint8Array' &&\n            'BYTES_PER_ELEMENT' in a &&\n            a.BYTES_PER_ELEMENT === 1));\n}\n/**\n * Asserts something is a non-negative integer.\n * @param n - number to validate\n * @param title - label included in thrown errors\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a non-negative integer option.\n * ```ts\n * anumber(32, 'length');\n * ```\n */\nexport function anumber(n, title = '') {\n    if (typeof n !== 'number') {\n        const prefix = title && `\"${title}\" `;\n        throw new TypeError(`${prefix}expected number, got ${typeof n}`);\n    }\n    if (!Number.isSafeInteger(n) || n < 0) {\n        const prefix = title && `\"${title}\" `;\n        throw new RangeError(`${prefix}expected integer >= 0, got ${n}`);\n    }\n}\n/**\n * Asserts something is Uint8Array.\n * @param value - value to validate\n * @param length - optional exact length constraint\n * @param title - label included in thrown errors\n * @returns The validated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate that a value is a byte array.\n * ```ts\n * abytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function abytes(value, length, title = '') {\n    const bytes = isBytes(value);\n    const len = value?.length;\n    const needsLen = length !== undefined;\n    if (!bytes || (needsLen && len !== length)) {\n        const prefix = title && `\"${title}\" `;\n        const ofLen = needsLen ? ` of length ${length}` : '';\n        const got = bytes ? `length=${len}` : `type=${typeof value}`;\n        const message = prefix + 'expected Uint8Array' + ofLen + ', got ' + got;\n        if (!bytes)\n            throw new TypeError(message);\n        throw new RangeError(message);\n    }\n    return value;\n}\n/**\n * Copies bytes into a fresh Uint8Array.\n * Buffer-style slices can alias the same backing store, so callers that need ownership should copy.\n * @param bytes - source bytes to clone\n * @returns Freshly allocated copy of `bytes`.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Clone a byte array before mutating it.\n * ```ts\n * const copy = copyBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function copyBytes(bytes) {\n    // `Uint8Array.from(...)` would also accept arrays / other typed arrays. Keep this helper strict\n    // because callers use it at byte-validation boundaries before mutating the detached copy.\n    return Uint8Array.from(abytes(bytes));\n}\n/**\n * Asserts something is a wrapped hash constructor.\n * @param h - hash constructor to validate\n * @throws On wrong argument types or invalid hash wrapper shape. {@link TypeError}\n * @throws On invalid hash metadata ranges or values. {@link RangeError}\n * @throws If the hash metadata allows empty outputs or block sizes. {@link Error}\n * @example\n * Validate a callable hash wrapper.\n * ```ts\n * import { ahash } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * ahash(sha256);\n * ```\n */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new TypeError('Hash must wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n    // HMAC and KDF callers treat these as real byte lengths; allowing zero lets fake wrappers pass\n    // validation and can produce empty outputs instead of failing fast.\n    if (h.outputLen < 1)\n        throw new Error('\"outputLen\" must be >= 1');\n    if (h.blockLen < 1)\n        throw new Error('\"blockLen\" must be >= 1');\n}\n/**\n * Asserts a hash instance has not been destroyed or finished.\n * @param instance - hash instance to validate\n * @param checkFinished - whether to reject finalized instances\n * @throws If the hash instance has already been destroyed or finalized. {@link Error}\n * @example\n * Validate that a hash instance is still usable.\n * ```ts\n * import { aexists } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aexists(hash);\n * ```\n */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/**\n * Asserts output is a sufficiently-sized byte array.\n * @param out - destination buffer\n * @param instance - hash instance providing output length\n * Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a caller-provided digest buffer.\n * ```ts\n * import { aoutput } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aoutput(new Uint8Array(hash.outputLen), hash);\n * ```\n */\nexport function aoutput(out, instance) {\n    abytes(out, undefined, 'digestInto() output');\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new RangeError('\"digestInto() output\" expected to be of length >=' + min);\n    }\n}\n/**\n * Casts a typed array view to Uint8Array.\n * @param arr - source typed array\n * @returns Uint8Array view over the same buffer.\n * @example\n * Reinterpret a typed array as bytes.\n * ```ts\n * u8(new Uint32Array([1, 2]));\n * ```\n */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Casts a typed array view to Uint32Array.\n * `arr.byteOffset` must already be 4-byte aligned or the platform\n * Uint32Array constructor will throw.\n * @param arr - source typed array\n * @returns Uint32Array view over the same buffer.\n * @example\n * Reinterpret a byte array as 32-bit words.\n * ```ts\n * u32(new Uint8Array(8));\n * ```\n */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/**\n * Zeroizes typed arrays in place. Warning: JS provides no guarantees.\n * @param arrays - arrays to overwrite with zeros\n * @example\n * Zeroize sensitive buffers in place.\n * ```ts\n * clean(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/**\n * Creates a DataView for byte-level manipulation.\n * @param arr - source typed array\n * @returns DataView over the same buffer region.\n * @example\n * Create a DataView over an existing buffer.\n * ```ts\n * createView(new Uint8Array(4));\n * ```\n */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Rotate-right operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the right.\n * ```ts\n * rotr(0x12345678, 8);\n * ```\n */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/**\n * Rotate-left operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the left.\n * ```ts\n * rotl(0x12345678, 8);\n * ```\n */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Whether the current platform is little-endian. */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/**\n * Byte-swap operation for uint32 values.\n * @param word - source word\n * @returns Word with reversed byte order.\n * @example\n * Reverse the byte order of a 32-bit word.\n * ```ts\n * byteSwap(0x11223344);\n * ```\n */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/**\n * Conditionally byte-swaps one 32-bit word on big-endian platforms.\n * @param n - source word\n * @returns Original or byte-swapped word depending on platform endianness.\n * @example\n * Normalize a 32-bit word for host endianness.\n * ```ts\n * swap8IfBE(0x11223344);\n * ```\n */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n) >>> 0;\n/**\n * Byte-swaps every word of a Uint32Array in place.\n * @param arr - array to mutate\n * @returns The same array after mutation; callers pass live state arrays here.\n * @example\n * Reverse the byte order of every word in place.\n * ```ts\n * byteSwap32(new Uint32Array([0x11223344]));\n * ```\n */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\n/**\n * Conditionally byte-swaps a Uint32Array on big-endian platforms.\n * @param u - array to normalize for host endianness\n * @returns Original or byte-swapped array depending on platform endianness.\n *   On big-endian runtimes this mutates `u` in place via `byteSwap32(...)`.\n * @example\n * Normalize a word array for host endianness.\n * ```ts\n * swap32IfBE(new Uint32Array([0x11223344]));\n * ```\n */\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string.\n * Uses the built-in function when available and assumes it matches the tested\n * fallback semantics.\n * @param bytes - bytes to encode\n * @returns Lowercase hexadecimal string.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Convert bytes to lowercase hexadecimal.\n * ```ts\n * bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'\n * ```\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @param hex - hexadecimal string to decode\n * @returns Decoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Decode lowercase hexadecimal into bytes.\n * ```ts\n * hexToBytes('cafe0123'); // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n * ```\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError('hex string expected, got ' + typeof hex);\n    if (hasHexBuiltin) {\n        try {\n            return Uint8Array.fromHex(hex);\n        }\n        catch (error) {\n            if (error instanceof SyntaxError)\n                throw new RangeError(error.message);\n            throw error;\n        }\n    }\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new RangeError('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new RangeError('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * This yields to the Promise/microtask scheduler queue, not to timers or the\n * full macrotask event loop.\n * @example\n * Yield to the next scheduler tick.\n * ```ts\n * await nextTick();\n * ```\n */\nexport const nextTick = async () => { };\n/**\n * Returns control to the Promise/microtask scheduler every `tick`\n * milliseconds to avoid blocking long loops.\n * @param iters - number of loop iterations to run\n * @param tick - maximum time slice in milliseconds\n * @param cb - callback executed on each iteration\n * @example\n * Run a loop that periodically yields back to the event loop.\n * ```ts\n * await asyncLoop(2, 0, () => {});\n * ```\n */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * Non-ASCII details are delegated to the platform `TextEncoder`.\n * @param str - string to encode\n * @returns UTF-8 encoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Encode a string as UTF-8 bytes.\n * ```ts\n * utf8ToBytes('abc'); // Uint8Array.from([97, 98, 99])\n * ```\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Helper for KDFs: consumes Uint8Array or string.\n * String inputs are UTF-8 encoded; byte-array inputs stay aliased to the caller buffer.\n * @param data - user-provided KDF input\n * @param errorTitle - label included in thrown errors\n * @returns Byte representation of the input.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Normalize KDF input to bytes.\n * ```ts\n * kdfInputToBytes('password');\n * ```\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n    if (typeof data === 'string')\n        return utf8ToBytes(data);\n    return abytes(data, undefined, errorTitle);\n}\n/**\n * Copies several Uint8Arrays into one.\n * @param arrays - arrays to concatenate\n * @returns Concatenated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Concatenate multiple byte arrays.\n * ```ts\n * concatBytes(new Uint8Array([1]), new Uint8Array([2]));\n * ```\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/**\n * Merges default options and passed options.\n * @param defaults - base option object\n * @param opts - user overrides\n * @returns Merged option object. The merge mutates `defaults` in place.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Merge user overrides onto default options.\n * ```ts\n * checkOpts({ dkLen: 32 }, { asyncTick: 10 });\n * ```\n */\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new TypeError('options must be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/**\n * Creates a callable hash function from a stateful class constructor.\n * @param hashCons - hash constructor or factory\n * @param info - optional metadata such as DER OID\n * @returns Frozen callable hash wrapper with `.create()`.\n *   Wrapper construction eagerly calls `hashCons(undefined)` once to read\n *   `outputLen` / `blockLen`, so constructor side effects happen at module\n *   init time.\n * @example\n * Wrap a stateful hash constructor into a callable helper.\n * ```ts\n * import { createHasher } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const wrapped = createHasher(sha256.create, { oid: sha256.oid });\n * wrapped(new Uint8Array([1]));\n * ```\n */\nexport function createHasher(hashCons, info = {}) {\n    const hashC = (msg, opts) => hashCons(opts)\n        .update(msg)\n        .digest();\n    const tmp = hashCons(undefined);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.canXOF = tmp.canXOF;\n    hashC.create = (opts) => hashCons(opts);\n    Object.assign(hashC, info);\n    return Object.freeze(hashC);\n}\n/**\n * Cryptographically secure PRNG backed by `crypto.getRandomValues`.\n * @param bytesLength - number of random bytes to generate\n * @returns Random bytes.\n * The platform `getRandomValues()` implementation still defines any\n * single-call length cap, and this helper rejects oversize requests\n * with a stable library `RangeError` instead of host-specific errors.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @throws If the current runtime does not provide `crypto.getRandomValues`. {@link Error}\n * @example\n * Generate a fresh random key or nonce.\n * ```ts\n * const key = randomBytes(16);\n * ```\n */\nexport function randomBytes(bytesLength = 32) {\n    // Match the repo's other length-taking helpers instead of relying on Uint8Array coercion.\n    anumber(bytesLength, 'bytesLength');\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    // Web Cryptography API Level 2 §10.1.1:\n    // if `byteLength > 65536`, throw `QuotaExceededError`.\n    // Keep the guard explicit so callers can see the quota in code\n    // instead of discovering it by reading the spec or host errors.\n    // This wrapper surfaces the same quota as a stable library RangeError.\n    if (bytesLength > 65536)\n        throw new RangeError(`\"bytesLength\" expected <= 65536, got ${bytesLength}`);\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/**\n * Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.\n * @param suffix - final OID byte for the selected hash.\n *   The helper accepts any byte even though only the documented NIST hash\n *   suffixes are meaningful downstream.\n * @returns Object containing the DER-encoded OID.\n * @example\n * Build OID metadata for a NIST hash.\n * ```ts\n * oidNist(0x01);\n * ```\n */\nexport const oidNist = (suffix) => ({\n    // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.\n    // Larger suffix values would need base-128 OID encoding and a different length byte.\n    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { abytes, aexists, aoutput, clean, createView, } from \"./utils.js\";\n/**\n * Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.\n * Returns bits from `b` when `a` is set, otherwise from `c`.\n * The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never\n * set the same bit.\n * @param a - selector word\n * @param b - word chosen when selector bit is set\n * @param c - word chosen when selector bit is clear\n * @returns Mixed 32-bit word.\n * @example\n * Combine three words with the shared 32-bit choice primitive.\n * ```ts\n * Chi(0xffffffff, 0x12345678, 0x87654321);\n * ```\n */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/**\n * Shared 32-bit majority primitive reused by SHA-256 and SHA-1.\n * Returns bits shared by at least two inputs.\n * @param a - first input word\n * @param b - second input word\n * @param c - third input word\n * @returns Mixed 32-bit word.\n * @example\n * Combine three words with the shared 32-bit majority primitive.\n * ```ts\n * Maj(0xffffffff, 0x12345678, 0x87654321);\n * ```\n */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n * Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit\n * strings with partial-byte tails.\n * @param blockLen - internal block size in bytes\n * @param outputLen - digest size in bytes\n * @param padOffset - trailing length field size in bytes\n * @param isLE - whether length and state words are encoded in little-endian\n * @example\n * Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.\n * ```ts\n * import { _SHA1 } from '@noble/hashes/legacy.js';\n * const hash = new _SHA1();\n * hash.update(new Uint8Array([97, 98, 99]));\n * hash.digest();\n * ```\n */\nexport class HashMD {\n    blockLen;\n    outputLen;\n    canXOF = false;\n    padOffset;\n    isLE;\n    // For partial updates less than block size\n    buffer;\n    view;\n    finished = false;\n    length = 0;\n    pos = 0;\n    destroyed = false;\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path only when there is no buffered partial block: `take === blockLen` implies\n            // `this.pos === 0`, so we can process full blocks directly from the input view.\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // `padOffset` reserves the whole length field. For SHA-384/512 the high 64 bits stay zero from\n        // the padding fill above, and JS will overflow before user input can make that half non-zero.\n        // So we only need to write the low 64 bits here.\n        view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen must be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Copy before destroy(): subclasses wipe `buffer` during cleanup, but `digest()` must return\n        // fresh bytes to the caller.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to ||= new this.constructor();\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        // Only partial-block bytes need copying: when `length % blockLen === 0`, `pos === 0` and\n        // later `update()` / `digestInto()` overwrite `to.buffer` from the start before reading it.\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the\n * square roots of the first eight prime numbers. Exported as a shared table; callers must treat\n * it as read-only because constructors copy words from it by index. */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state `H(0)` from RFC 6234 §6.1. Exported as a shared table; callers must\n * treat it as read-only because constructors copy words from it by index. */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen\n * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the ninth\n * through sixteenth prime numbers. Exported as a shared table; callers must treat it as read-only\n * because constructors copy halves from it by index. */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen\n * big-endian 32-bit halves. Derived from the fractional parts of the square roots of the first\n * eight prime numbers. Exported as a shared table; callers must treat it as read-only because\n * constructors copy halves from it by index. */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map","const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n// Split bigint into two 32-bit halves. With `le=true`, returned fields become `{ h: low, l: high\n// }` to match little-endian word order rather than the property names.\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\n// Split bigint list into `[highWords, lowWords]` when `le=false`; with `le=true`, the first array\n// holds the low halves because `fromBig(...)` swaps the semantic meaning of `h` and `l`.\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\n// Combine explicit `(high, low)` 32-bit halves into a bigint; `>>> 0` normalizes signed JS\n// bitwise results back to uint32 first, and little-endian callers must swap.\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// High 32-bit half of a 64-bit logical right shift for `s` in `0..31`.\nconst shrSH = (h, _l, s) => h >>> s;\n// Low 32-bit half of a 64-bit logical right shift, valid for `s` in `1..31`.\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// High 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\n// Low 32-bit half of a 64-bit right rotate, valid for `s` in `1..31`.\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// High 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\n// Low 32-bit half of a 64-bit right rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// High 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped low half.\nconst rotr32H = (_h, l) => l;\n// Low 32-bit half of a 64-bit right rotate for `s === 32`; this is just the swapped high half.\nconst rotr32L = (h, _l) => h;\n// High 32-bit half of a 64-bit left rotate, valid for `s` in `1..31`.\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\n// Low 32-bit half of a 64-bit left rotate, valid for `s` in `1..31`.\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// High 32-bit half of a 64-bit left rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\n// Low 32-bit half of a 64-bit left rotate, valid for `s` in `33..63`; `32` uses `rotr32*`.\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// Add two split 64-bit words and return the split `{ h, l }` sum.\n// JS uses 32-bit signed integers for bitwise operations, so we cannot simply shift the carry out\n// of the low sum and instead use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\n// Unmasked low-word accumulator for 3-way addition; pass the raw result into `add3H(...)`.\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\n// High-word finalize step for 3-way addition; `low` must be the untruncated output of `add3L(...)`.\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\n// Unmasked low-word accumulator for 4-way addition; pass the raw result into `add4H(...)`.\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\n// High-word finalize step for 4-way addition; `low` must be the untruncated output of `add4L(...)`.\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\n// Unmasked low-word accumulator for 5-way addition; pass the raw result into `add5H(...)`.\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\n// High-word finalize step for 5-way addition; `low` must be the untruncated output of `add5L(...)`.\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\n// Canonical grouped namespace for callers that prefer one object.\n// Named exports stay for direct imports.\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\n// Default export mirrors named `u64` for compatibility with object-style imports.\nexport default u64;\n//# sourceMappingURL=_u64.js.map","/**\n * Internal helpers for blake hash.\n * @module\n */\nimport { rotr } from \"./utils.js\";\n/**\n * Internal blake permutation table.\n * Rows `0..9` serve BLAKE2s, rows `0..11` serve BLAKE2b with `10..11 = 0..1`, and Blake1 also\n * reuses the later rows shown below. Blake1 expands rounds `10..15` as `SIGMA[i % 10]`, so rows\n * `10..15` intentionally repeat rows `0..5` for the 14-round (256) and 16-round (512) variants.\n */\n// prettier-ignore\nexport const BSIGMA = /* @__PURE__ */ Uint8Array.from([\n    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,\n    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,\n    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,\n    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,\n    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,\n    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,\n    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,\n    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,\n    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,\n    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,\n    // Blake1, unused in others\n    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,\n    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,\n    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,\n    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,\n]);\n// 32-bit / BLAKE2s first half of G, with the fixed `(16, 12)` rotation pair.\n// Parameter `x` is the RFC 7693 first-half message word, or Blake1's pre-mixed\n// `m[sigma[r][2i]] ^ u[sigma[r][2i+1]]` addend in the 32-bit path.\nexport function G1s(a, b, c, d, x) {\n    a = (a + b + x) | 0;\n    d = rotr(d ^ a, 16);\n    c = (c + d) | 0;\n    b = rotr(b ^ c, 12);\n    return { a, b, c, d };\n}\n// 32-bit / BLAKE2s second half of G.\n// Parameter `x` is the RFC 7693 second-half (`y`) message word, or Blake1's pre-mixed\n// `m[sigma[r][2i + 1]] ^ u[sigma[r][2i]]` addend in the 32-bit path.\nexport function G2s(a, b, c, d, x) {\n    a = (a + b + x) | 0;\n    d = rotr(d ^ a, 8);\n    c = (c + d) | 0;\n    b = rotr(b ^ c, 7);\n    return { a, b, c, d };\n}\n//# sourceMappingURL=_blake.js.map","/**\n * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.\n * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.\n * @module\n */\nimport { BSIGMA, G1s, G2s } from \"./_blake.js\";\nimport { SHA256_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, clean, createHasher, swap32IfBE, swap8IfBE, u32 } from \"./utils.js\";\n// Same IV words as `SHA512_IV`, but endian-swapped into LE u32 low/high halves\n// for the BLAKE2b u64 helpers below.\nconst B2B_IV = /* @__PURE__ */ Uint32Array.from([\n    0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,\n    0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,\n]);\n// Shared synchronous BLAKE2b work vector as LE u32 low/high halves.\nconst BBUF = /* @__PURE__ */ new Uint32Array(32);\n// BLAKE2b G mix split into two half-rounds over LE u32 low/high limbs.\nfunction G1b(a, b, c, d, msg, x) {\n    // NOTE: V is LE here\n    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore\n    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore\n    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore\n    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore\n    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore\n    // v[a] = (v[a] + v[b] + x) | 0;\n    let ll = u64.add3L(Al, Bl, Xl);\n    Ah = u64.add3H(ll, Ah, Bh, Xh);\n    Al = ll | 0;\n    // v[d] = rotr(v[d] ^ v[a], 32)\n    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });\n    ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });\n    // v[c] = (v[c] + v[d]) | 0;\n    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));\n    // v[b] = rotr(v[b] ^ v[c], 24)\n    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });\n    ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 24), Bl: u64.rotrSL(Bh, Bl, 24) });\n    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));\n    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));\n    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));\n    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));\n}\n// Second half-round of the same LE-limb BLAKE2b G mix; `x` is the message word offset.\nfunction G2b(a, b, c, d, msg, x) {\n    // NOTE: V is LE here\n    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore\n    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore\n    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore\n    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore\n    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore\n    // v[a] = (v[a] + v[b] + x) | 0;\n    let ll = u64.add3L(Al, Bl, Xl);\n    Ah = u64.add3H(ll, Ah, Bh, Xh);\n    Al = ll | 0;\n    // v[d] = rotr(v[d] ^ v[a], 16)\n    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });\n    ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });\n    // v[c] = (v[c] + v[d]) | 0;\n    ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));\n    // v[b] = rotr(v[b] ^ v[c], 63)\n    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });\n    ({ Bh, Bl } = { Bh: u64.rotrBH(Bh, Bl, 63), Bl: u64.rotrBL(Bh, Bl, 63) });\n    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));\n    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));\n    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));\n    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));\n}\nfunction checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {\n    anumber(keyLen);\n    // RFC 7693 §2.1 requires digest length nn in 1..keyLen.\n    if (outputLen <= 0 || outputLen > keyLen)\n        throw new Error('outputLen bigger than keyLen');\n    const { key, salt, personalization } = opts;\n    // This API uses `undefined` for the RFC 7693 `kk = 0` case, so a provided key must be non-empty.\n    if (key !== undefined && (key.length < 1 || key.length > keyLen))\n        throw new Error('\"key\" expected to be undefined or of length=1..' + keyLen);\n    if (salt !== undefined)\n        abytes(salt, saltLen, 'salt');\n    if (personalization !== undefined)\n        abytes(personalization, persLen, 'personalization');\n}\n/** Internal base class for BLAKE2. */\nexport class _BLAKE2 {\n    buffer;\n    buffer32;\n    finished = false;\n    destroyed = false;\n    length = 0;\n    pos = 0;\n    blockLen;\n    outputLen;\n    canXOF = false;\n    constructor(blockLen, outputLen) {\n        anumber(blockLen);\n        anumber(outputLen);\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.buffer = new Uint8Array(blockLen);\n        this.buffer32 = u32(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        // Main difference with other hashes: there is flag for last block,\n        // so we cannot process current block before we know that there\n        // is the next one. This significantly complicates logic and reduces ability\n        // to do zero-copy processing\n        const { blockLen, buffer, buffer32 } = this;\n        const len = data.length;\n        const offset = data.byteOffset;\n        const buf = data.buffer;\n        for (let pos = 0; pos < len;) {\n            // If buffer is full and we still have input (don't process last block, same as blake2s)\n            if (this.pos === blockLen) {\n                swap32IfBE(buffer32);\n                this.compress(buffer32, 0, false);\n                swap32IfBE(buffer32);\n                this.pos = 0;\n            }\n            const take = Math.min(blockLen - this.pos, len - pos);\n            const dataOffset = offset + pos;\n            // Zero-copy only for full, 4-byte-aligned, non-final blocks.\n            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {\n                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));\n                swap32IfBE(data32);\n                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {\n                    this.length += blockLen;\n                    this.compress(data32, pos32, false);\n                }\n                swap32IfBE(data32);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            this.length += take;\n            pos += take;\n        }\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        const { pos, buffer32 } = this;\n        this.finished = true;\n        // Padding\n        clean(this.buffer.subarray(pos));\n        swap32IfBE(buffer32);\n        this.compress(buffer32, 0, true);\n        swap32IfBE(buffer32);\n        // Reject unaligned views explicitly instead of hiding them behind a full scratch copy.\n        if (out.byteOffset & 3)\n            throw new RangeError('\"digestInto() output\" expected 4-byte aligned byteOffset, got ' + out.byteOffset);\n        const state = this.get();\n        const out32 = u32(out);\n        const full = Math.floor(this.outputLen / 4);\n        for (let i = 0; i < full; i++)\n            out32[i] = swap8IfBE(state[i]);\n        const tail = this.outputLen % 4;\n        if (!tail)\n            return;\n        const off = full * 4;\n        const word = state[full];\n        for (let i = 0; i < tail; i++)\n            out[off + i] = word >>> (8 * i);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Return a copy so callers do not alias the instance scratch buffer used during finalization.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        const { buffer, length, finished, destroyed, outputLen, pos } = this;\n        // Recreate only `dkLen`; key/salt/personalization are already absorbed into the copied state.\n        to ||= new this.constructor({ dkLen: outputLen });\n        to.set(...this.get());\n        to.buffer.set(buffer);\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        // @ts-ignore\n        to.outputLen = outputLen;\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/** Internal blake2b hash class with state stored as LE u32 low/high halves. */\nexport class _BLAKE2b extends _BLAKE2 {\n    // Same IV words as SHA-512 / BLAKE2b, encoded as LE u32 low/high halves.\n    v0l = B2B_IV[0] | 0;\n    v0h = B2B_IV[1] | 0;\n    v1l = B2B_IV[2] | 0;\n    v1h = B2B_IV[3] | 0;\n    v2l = B2B_IV[4] | 0;\n    v2h = B2B_IV[5] | 0;\n    v3l = B2B_IV[6] | 0;\n    v3h = B2B_IV[7] | 0;\n    v4l = B2B_IV[8] | 0;\n    v4h = B2B_IV[9] | 0;\n    v5l = B2B_IV[10] | 0;\n    v5h = B2B_IV[11] | 0;\n    v6l = B2B_IV[12] | 0;\n    v6h = B2B_IV[13] | 0;\n    v7l = B2B_IV[14] | 0;\n    v7h = B2B_IV[15] | 0;\n    constructor(opts = {}) {\n        const olen = opts.dkLen === undefined ? 64 : opts.dkLen;\n        super(128, olen);\n        checkBlake2Opts(olen, opts, 64, 16, 16);\n        let { key, personalization, salt } = opts;\n        let keyLength = 0;\n        if (key !== undefined) {\n            abytes(key, undefined, 'key');\n            keyLength = key.length;\n        }\n        // RFC 7693 §2.5: xor `p[0] = 0x0101kknn` into the low 32 bits of `h[0]`;\n        // the high 32 bits stay at `IV[0]`.\n        this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);\n        if (salt !== undefined) {\n            abytes(salt, undefined, 'salt');\n            const slt = u32(salt);\n            this.v4l ^= swap8IfBE(slt[0]);\n            this.v4h ^= swap8IfBE(slt[1]);\n            this.v5l ^= swap8IfBE(slt[2]);\n            this.v5h ^= swap8IfBE(slt[3]);\n        }\n        if (personalization !== undefined) {\n            abytes(personalization, undefined, 'personalization');\n            const pers = u32(personalization);\n            this.v6l ^= swap8IfBE(pers[0]);\n            this.v6h ^= swap8IfBE(pers[1]);\n            this.v7l ^= swap8IfBE(pers[2]);\n            this.v7h ^= swap8IfBE(pers[3]);\n        }\n        if (key !== undefined) {\n            // Pad to blockLen and update\n            const tmp = new Uint8Array(this.blockLen);\n            tmp.set(key);\n            this.update(tmp);\n        }\n    }\n    // prettier-ignore\n    get() {\n        let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;\n        return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];\n    }\n    // prettier-ignore\n    set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {\n        this.v0l = v0l | 0;\n        this.v0h = v0h | 0;\n        this.v1l = v1l | 0;\n        this.v1h = v1h | 0;\n        this.v2l = v2l | 0;\n        this.v2h = v2h | 0;\n        this.v3l = v3l | 0;\n        this.v3h = v3h | 0;\n        this.v4l = v4l | 0;\n        this.v4h = v4h | 0;\n        this.v5l = v5l | 0;\n        this.v5h = v5h | 0;\n        this.v6l = v6l | 0;\n        this.v6h = v6h | 0;\n        this.v7l = v7l | 0;\n        this.v7h = v7h | 0;\n    }\n    compress(msg, offset, isLast) {\n        this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.\n        BBUF.set(B2B_IV, 16); // Second half from IV.\n        let { h, l } = u64.fromBig(BigInt(this.length));\n        BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.\n        BBUF[25] = B2B_IV[9] ^ h; // High word.\n        // Invert all bits for last block\n        if (isLast) {\n            BBUF[28] = ~BBUF[28];\n            BBUF[29] = ~BBUF[29];\n        }\n        let j = 0;\n        const s = BSIGMA;\n        // SIGMA selects 64-bit message words; multiply by 2 because `msg` stores\n        // each word as [low32, high32].\n        for (let i = 0; i < 12; i++) {\n            G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);\n            G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);\n            G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);\n            G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);\n            G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);\n            G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);\n            G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);\n            G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);\n            G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);\n            G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);\n            G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);\n            G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);\n            G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);\n            G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);\n            G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);\n            G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);\n        }\n        this.v0l ^= BBUF[0] ^ BBUF[16];\n        this.v0h ^= BBUF[1] ^ BBUF[17];\n        this.v1l ^= BBUF[2] ^ BBUF[18];\n        this.v1h ^= BBUF[3] ^ BBUF[19];\n        this.v2l ^= BBUF[4] ^ BBUF[20];\n        this.v2h ^= BBUF[5] ^ BBUF[21];\n        this.v3l ^= BBUF[6] ^ BBUF[22];\n        this.v3h ^= BBUF[7] ^ BBUF[23];\n        this.v4l ^= BBUF[8] ^ BBUF[24];\n        this.v4h ^= BBUF[9] ^ BBUF[25];\n        this.v5l ^= BBUF[10] ^ BBUF[26];\n        this.v5h ^= BBUF[11] ^ BBUF[27];\n        this.v6l ^= BBUF[12] ^ BBUF[28];\n        this.v6h ^= BBUF[13] ^ BBUF[29];\n        this.v7l ^= BBUF[14] ^ BBUF[30];\n        this.v7h ^= BBUF[15] ^ BBUF[31];\n        clean(BBUF);\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer32);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/**\n * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.\n * @param msg - message that would be hashed\n * @param opts - Optional output, MAC, salt, and personalization settings.\n *   `dkLen` must be 1..64 bytes; `salt` and `personalization`, if present,\n *   must be 16 bytes each. See {@link Blake2Opts}.\n * @returns Digest bytes.\n * @example\n * Hash a message with Blake2b.\n * ```ts\n * blake2b(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const blake2b = /* @__PURE__ */ createHasher((opts) => new _BLAKE2b(opts));\n/**\n * BLAKE2-compress core method.\n * Runs only the round function over a caller-supplied local vector; callers initialize `v0..v15`\n * and apply the final `h[i] ^= v[i] ^ v[i + 8]` fold themselves.\n * @param s - flattened sigma schedule bytes\n * @param offset - starting word offset inside `msg`, not a byte offset\n * @param msg - message words\n * @param rounds - round count to execute\n * @param v0 - state word 0\n * @param v1 - state word 1\n * @param v2 - state word 2\n * @param v3 - state word 3\n * @param v4 - state word 4\n * @param v5 - state word 5\n * @param v6 - state word 6\n * @param v7 - state word 7\n * @param v8 - state word 8\n * @param v9 - state word 9\n * @param v10 - state word 10\n * @param v11 - state word 11\n * @param v12 - state word 12\n * @param v13 - state word 13\n * @param v14 - state word 14\n * @param v15 - state word 15\n * @returns Updated compression state words.\n * @example\n * Run the BLAKE2 compression core on zeroed state and message words.\n * ```ts\n * import { compress } from '@noble/hashes/blake2.js';\n * const state = compress(\n *   new Uint8Array(16),\n *   0,\n *   new Uint32Array(16),\n *   1,\n *   0, 0, 0, 0, 0, 0, 0, 0,\n *   0, 0, 0, 0, 0, 0, 0, 0\n * );\n * state.v0;\n * ```\n */\n// prettier-ignore\nexport function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {\n    let j = 0;\n    for (let i = 0; i < rounds; i++) {\n        ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));\n        ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));\n        ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));\n        ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));\n        ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));\n        ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));\n        ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));\n        ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));\n        ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));\n        ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));\n        ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));\n        ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));\n        ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));\n        ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));\n        ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));\n        ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));\n    }\n    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };\n}\n// Blake2s reuses the SHA-256 IV words as-is.\nconst B2S_IV = /* @__PURE__ */ SHA256_IV.slice();\n/** Internal blake2s hash class. */\nexport class _BLAKE2s extends _BLAKE2 {\n    // Internal state, same as SHA-256\n    v0 = B2S_IV[0] | 0;\n    v1 = B2S_IV[1] | 0;\n    v2 = B2S_IV[2] | 0;\n    v3 = B2S_IV[3] | 0;\n    v4 = B2S_IV[4] | 0;\n    v5 = B2S_IV[5] | 0;\n    v6 = B2S_IV[6] | 0;\n    v7 = B2S_IV[7] | 0;\n    constructor(opts = {}) {\n        const olen = opts.dkLen === undefined ? 32 : opts.dkLen;\n        super(64, olen);\n        checkBlake2Opts(olen, opts, 32, 8, 8);\n        let { key, personalization, salt } = opts;\n        let keyLength = 0;\n        if (key !== undefined) {\n            abytes(key, undefined, 'key');\n            keyLength = key.length;\n        }\n        // RFC 7693 §2.5: xor `p[0] = 0x0101kknn` directly into `h[0]`, since\n        // BLAKE2s stores each state word as one `u32`.\n        this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);\n        if (salt !== undefined) {\n            abytes(salt, undefined, 'salt');\n            const slt = u32(salt);\n            this.v4 ^= swap8IfBE(slt[0]);\n            this.v5 ^= swap8IfBE(slt[1]);\n        }\n        if (personalization !== undefined) {\n            abytes(personalization, undefined, 'personalization');\n            const pers = u32(personalization);\n            this.v6 ^= swap8IfBE(pers[0]);\n            this.v7 ^= swap8IfBE(pers[1]);\n        }\n        if (key !== undefined) {\n            // Pad to blockLen and update\n            const tmp = new Uint8Array(this.blockLen);\n            tmp.set(key);\n            this.update(tmp);\n        }\n    }\n    get() {\n        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;\n        return [v0, v1, v2, v3, v4, v5, v6, v7];\n    }\n    // prettier-ignore\n    set(v0, v1, v2, v3, v4, v5, v6, v7) {\n        this.v0 = v0 | 0;\n        this.v1 = v1 | 0;\n        this.v2 = v2 | 0;\n        this.v3 = v3 | 0;\n        this.v4 = v4 | 0;\n        this.v5 = v5 | 0;\n        this.v6 = v6 | 0;\n        this.v7 = v7 | 0;\n    }\n    compress(msg, offset, isLast) {\n        const { h, l } = u64.fromBig(BigInt(this.length));\n        // Seed v8..v15 from the IV, xor the low/high 32-bit byte counter into\n        // v12/v13, and invert v14 on the final block.\n        // prettier-ignore\n        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(BSIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);\n        this.v0 ^= v0 ^ v8;\n        this.v1 ^= v1 ^ v9;\n        this.v2 ^= v2 ^ v10;\n        this.v3 ^= v3 ^ v11;\n        this.v4 ^= v4 ^ v12;\n        this.v5 ^= v5 ^ v13;\n        this.v6 ^= v6 ^ v14;\n        this.v7 ^= v7 ^ v15;\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer32);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/**\n * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. 1.5x faster than blake2b in JS.\n * @param msg - message that would be hashed\n * @param opts - Optional output, MAC, salt, and personalization settings.\n *   `dkLen` must be 1..32 bytes; `salt` and `personalization`, if present,\n *   must be 8 bytes each. See {@link Blake2Opts}.\n * @returns Digest bytes.\n * @example\n * Hash a message with Blake2s.\n * ```ts\n * blake2s(new Uint8Array([97, 98, 99]));\n * ```\n */\nexport const blake2s = /* @__PURE__ */ createHasher((opts) => new _BLAKE2s(opts));\n//# sourceMappingURL=blake2.js.map","/**\n * Blake3 fast hash is Blake2 with reduced security (round count). Can also be used as MAC & KDF.\n *\n * It is advertised as \"the fastest cryptographic hash\". However, it isn't true in JS.\n * Why is this so slow? While it must be 6x faster than blake2b, perf diff is only 20%:\n *\n * * There is only 30% reduction in number of rounds from blake2s\n * * Speed-up comes from tree structure, which is parallelized using SIMD & threading.\n *   These features are not present in JS, so we only get overhead from trees.\n * * Parallelization only happens on 1024-byte chunks: there is no benefit for small inputs.\n * * It is still possible to make it faster using: a) loop unrolling b) web workers c) wasm\n * @module\n */\nimport { SHA256_IV } from \"./_md.js\";\nimport { fromBig } from \"./_u64.js\";\nimport { _BLAKE2, compress } from \"./blake2.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, clean, copyBytes, createHasher, swap32IfBE, u32, u8 } from \"./utils.js\";\n// Constructor-time mode flags (`KEYED_HASH`, `DERIVE_*`) plus per-node tree\n// flags (`CHUNK_*`, `PARENT`, `ROOT`).\nconst B3_Flags = {\n    CHUNK_START: 0b1,\n    CHUNK_END: 0b10,\n    PARENT: 0b100,\n    ROOT: 0b1000,\n    KEYED_HASH: 0b10000,\n    DERIVE_KEY_CONTEXT: 0b100000,\n    DERIVE_KEY_MATERIAL: 0b1000000,\n};\n// Default BLAKE3 IV, cloned from the shared BLAKE2s / SHA-256 IV basis.\nconst B3_IV = /* @__PURE__ */ SHA256_IV.slice();\n// Seven 16-word rounds of BLAKE3 message schedule, generated by repeatedly\n// permuting the identity row.\nconst B3_SIGMA = /* @__PURE__ */ (() => {\n    const Id = Array.from({ length: 16 }, (_, i) => i);\n    const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);\n    const res = [];\n    for (let i = 0, v = Id; i < 7; i++, v = permute(v))\n        res.push(...v);\n    return Uint8Array.from(res);\n})();\n/** Blake3 hash. Can be used as MAC and KDF with caller-encoded context bytes. */\nexport class _BLAKE3 extends _BLAKE2 {\n    canXOF = true;\n    chunkPos = 0; // Position of current block in chunk\n    // How many chunks we already have; exact while this stays within\n    // JS's safe-integer range.\n    chunksDone = 0;\n    flags = 0 | 0;\n    IV;\n    state;\n    stack = [];\n    // Output\n    posOut = 0;\n    bufferOut32 = new Uint32Array(16);\n    bufferOut;\n    // Index of output chunk; exact while this stays within JS's\n    // safe-integer range.\n    chunkOut = 0;\n    enableXOF = true;\n    constructor(opts = {}, flags = 0) {\n        super(64, opts.dkLen === undefined ? 32 : opts.dkLen);\n        const { key, context } = opts;\n        const hasContext = context !== undefined;\n        if (key !== undefined) {\n            if (hasContext)\n                throw new Error('Only \"key\" or \"context\" can be specified at same time');\n            abytes(key, 32, 'key');\n            const k = copyBytes(key);\n            this.IV = u32(k);\n            swap32IfBE(this.IV);\n            this.flags = flags | B3_Flags.KEYED_HASH;\n        }\n        else if (hasContext) {\n            abytes(context, undefined, 'context');\n            const ctx = context;\n            const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)\n                .update(ctx)\n                .digest();\n            this.IV = u32(contextKey);\n            swap32IfBE(this.IV);\n            this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;\n        }\n        else {\n            this.IV = B3_IV.slice();\n            this.flags = flags;\n        }\n        this.state = this.IV.slice();\n        this.bufferOut = u8(this.bufferOut32);\n    }\n    // _BLAKE2's scalar-state hooks are unused here: BLAKE3 keeps its tree/XOF state in arrays and\n    // copies it directly in _cloneInto().\n    get() {\n        return [];\n    }\n    set() { }\n    // Truncated chunk/parent compression: seed v8..v15 as IV[0..3], t0, t1,\n    // block length, and flags, then keep only the first 8 output words.\n    b2Compress(counter, flags, buf, bufPos = 0) {\n        const { state: s, pos } = this;\n        const { h, l } = fromBig(BigInt(counter), true);\n        // prettier-ignore\n        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);\n        s[0] = v0 ^ v8;\n        s[1] = v1 ^ v9;\n        s[2] = v2 ^ v10;\n        s[3] = v3 ^ v11;\n        s[4] = v4 ^ v12;\n        s[5] = v5 ^ v13;\n        s[6] = v6 ^ v14;\n        s[7] = v7 ^ v15;\n    }\n    compress(buf, bufPos = 0, isLast = false) {\n        // Compress last block\n        let flags = this.flags;\n        if (!this.chunkPos)\n            flags |= B3_Flags.CHUNK_START;\n        if (this.chunkPos === 15 || isLast)\n            flags |= B3_Flags.CHUNK_END;\n        if (!isLast)\n            this.pos = this.blockLen;\n        this.b2Compress(this.chunksDone, flags, buf, bufPos);\n        this.chunkPos += 1;\n        // If current block is last in chunk (16 blocks), then compress chunks\n        if (this.chunkPos === 16 || isLast) {\n            let chunk = this.state;\n            this.state = this.IV.slice();\n            // If not the last one, compress only when there are trailing zeros in chunk counter\n            // Chunks are used as a binary tree where the current stack is the path.\n            // Zero means the current leaf is finished and can be compressed.\n            // 1 (001) - leaf not finished (just push current chunk to stack)\n            // 2 (010) - leaf finished at depth=1 (merge with last elm on stack and push back)\n            // 3 (011) - last leaf not finished\n            // 4 (100) - leafs finished at depth=1 and depth=2\n            for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {\n                if (!(last = this.stack.pop()))\n                    break;\n                this.buffer32.set(last, 0);\n                this.buffer32.set(chunk, 8);\n                this.pos = this.blockLen;\n                this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);\n                chunk = this.state;\n                this.state = this.IV.slice();\n            }\n            this.chunksDone++;\n            this.chunkPos = 0;\n            this.stack.push(chunk);\n        }\n        this.pos = 0;\n    }\n    _cloneInto(to) {\n        to = super._cloneInto(to);\n        const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;\n        to.state.set(state.slice());\n        // Clone each CV stack entry by value so extending or destroying the clone\n        // cannot alias the source tree state.\n        to.stack = stack.map((i) => Uint32Array.from(i));\n        to.IV.set(IV);\n        to.flags = flags;\n        to.chunkPos = chunkPos;\n        to.chunksDone = chunksDone;\n        to.posOut = posOut;\n        to.chunkOut = chunkOut;\n        to.enableXOF = this.enableXOF;\n        to.bufferOut32.set(this.bufferOut32);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.state, this.buffer32, this.IV, this.bufferOut32);\n        clean(...this.stack);\n    }\n    // Root/XOF compression: rerun the same ROOT inputs with incrementing output\n    // counter `t` and materialize all 16 output words.\n    // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)\n    b2CompressOut() {\n        const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;\n        const { h, l } = fromBig(BigInt(this.chunkOut++));\n        swap32IfBE(buffer32);\n        // prettier-ignore\n        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);\n        out32[0] = v0 ^ v8;\n        out32[1] = v1 ^ v9;\n        out32[2] = v2 ^ v10;\n        out32[3] = v3 ^ v11;\n        out32[4] = v4 ^ v12;\n        out32[5] = v5 ^ v13;\n        out32[6] = v6 ^ v14;\n        out32[7] = v7 ^ v15;\n        out32[8] = s[0] ^ v8;\n        out32[9] = s[1] ^ v9;\n        out32[10] = s[2] ^ v10;\n        out32[11] = s[3] ^ v11;\n        out32[12] = s[4] ^ v12;\n        out32[13] = s[5] ^ v13;\n        out32[14] = s[6] ^ v14;\n        out32[15] = s[7] ^ v15;\n        swap32IfBE(buffer32);\n        swap32IfBE(out32);\n        this.posOut = 0;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        // Padding\n        clean(this.buffer.subarray(this.pos));\n        // Process last chunk\n        let flags = this.flags | B3_Flags.ROOT;\n        if (this.stack.length) {\n            // Finalize the current chunk first, then rerun the last parent\n            // compression as ROOT with t = 0 and b = 64.\n            flags |= B3_Flags.PARENT;\n            swap32IfBE(this.buffer32);\n            this.compress(this.buffer32, 0, true);\n            swap32IfBE(this.buffer32);\n            this.chunksDone = 0;\n            this.pos = this.blockLen;\n        }\n        else {\n            flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;\n        }\n        this.flags = flags;\n        this.b2CompressOut();\n    }\n    writeInto(out) {\n        aexists(this, false);\n        abytes(out);\n        this.finish();\n        const { blockLen, bufferOut } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.b2CompressOut();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible after digest call');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        anumber(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        aoutput(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.enableXOF = false;\n        // `aoutput(...)` allows oversized buffers; digestInto() must fill only the configured digest.\n        this.writeInto(out.subarray(0, this.outputLen));\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n}\n/**\n * BLAKE3 hash function. Can be used as MAC and KDF.\n * @param msg - message that would be hashed\n * @param opts - Optional output, MAC, or KDF configuration. `key` must be\n *   exactly 32 bytes, `context` is caller-encoded bytes, and `dkLen` can be\n *   0..2^64-1 via the XOF-backed output path. See {@link Blake3Opts}.\n * @returns Digest bytes.\n * @example\n * Hash, MAC, or derive key material with BLAKE3.\n * ```ts\n * import { blake3 } from '@noble/hashes/blake3.js';\n * import { utf8ToBytes } from '@noble/hashes/utils.js';\n * const data = new Uint8Array(32);\n * const hash = blake3(data);\n * const mac = blake3(data, { key: new Uint8Array(32) });\n * const kdf = blake3(data, { context: utf8ToBytes('application name') });\n * ```\n */\nexport const blake3 = /* @__PURE__ */ createHasher((opts = {}) => new _BLAKE3(opts));\n//# sourceMappingURL=blake3.js.map","// Some numerical data is initialized as -1 even when it doesn't need initialization to help the JIT infer types\n// aliases for shorter compressed code (most minifers don't do this)\nvar ab = ArrayBuffer, u8 = Uint8Array, u16 = Uint16Array, i16 = Int16Array, u32 = Uint32Array, i32 = Int32Array;\nvar slc = function (v, s, e) {\n    if (u8.prototype.slice)\n        return u8.prototype.slice.call(v, s, e);\n    if (s == null || s < 0)\n        s = 0;\n    if (e == null || e > v.length)\n        e = v.length;\n    var n = new u8(e - s);\n    n.set(v.subarray(s, e));\n    return n;\n};\nvar fill = function (v, n, s, e) {\n    if (u8.prototype.fill)\n        return u8.prototype.fill.call(v, n, s, e);\n    if (s == null || s < 0)\n        s = 0;\n    if (e == null || e > v.length)\n        e = v.length;\n    for (; s < e; ++s)\n        v[s] = n;\n    return v;\n};\nvar cpw = function (v, t, s, e) {\n    if (u8.prototype.copyWithin)\n        return u8.prototype.copyWithin.call(v, t, s, e);\n    if (s == null || s < 0)\n        s = 0;\n    if (e == null || e > v.length)\n        e = v.length;\n    while (s < e) {\n        v[t++] = v[s++];\n    }\n};\n/**\n * Codes for errors generated within this library\n */\nexport var ZstdErrorCode = {\n    InvalidData: 0,\n    WindowSizeTooLarge: 1,\n    InvalidBlockType: 2,\n    FSEAccuracyTooHigh: 3,\n    DistanceTooFarBack: 4,\n    UnexpectedEOF: 5\n};\n// error codes\nvar ec = [\n    'invalid zstd data',\n    'window size too large (>2046MB)',\n    'invalid block type',\n    'FSE accuracy too high',\n    'match distance too far back',\n    'unexpected EOF'\n];\nvar err = function (ind, msg, nt) {\n    var e = new Error(msg || ec[ind]);\n    e.code = ind;\n    if (Error.captureStackTrace)\n        Error.captureStackTrace(e, err);\n    if (!nt)\n        throw e;\n    return e;\n};\nvar rb = function (d, b, n) {\n    var i = 0, o = 0;\n    for (; i < n; ++i)\n        o |= d[b++] << (i << 3);\n    return o;\n};\nvar b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };\n// read Zstandard frame header\nvar rzfh = function (dat, w) {\n    var n3 = dat[0] | (dat[1] << 8) | (dat[2] << 16);\n    if (n3 == 0x2FB528 && dat[3] == 253) {\n        // Zstandard\n        var flg = dat[4];\n        //    single segment       checksum             dict flag     frame content flag\n        var ss = (flg >> 5) & 1, cc = (flg >> 2) & 1, df = flg & 3, fcf = flg >> 6;\n        if (flg & 8)\n            err(0);\n        // byte\n        var bt = 6 - ss;\n        // dict bytes\n        var db = df == 3 ? 4 : df;\n        // dictionary id\n        var di = rb(dat, bt, db);\n        bt += db;\n        // frame size bytes\n        var fsb = fcf ? (1 << fcf) : ss;\n        // frame source size\n        var fss = rb(dat, bt, fsb) + ((fcf == 1) && 256);\n        // window size\n        var ws = fss;\n        if (!ss) {\n            // window descriptor\n            var wb = 1 << (10 + (dat[5] >> 3));\n            ws = wb + (wb >> 3) * (dat[5] & 7);\n        }\n        if (ws > 2145386496)\n            err(1);\n        var buf = new u8((w == 1 ? (fss || ws) : w ? 0 : ws) + 12);\n        buf[0] = 1, buf[4] = 4, buf[8] = 8;\n        return {\n            b: bt + fsb,\n            y: 0,\n            l: 0,\n            d: di,\n            w: (w && w != 1) ? w : buf.subarray(12),\n            e: ws,\n            o: new i32(buf.buffer, 0, 3),\n            u: fss,\n            c: cc,\n            m: Math.min(131072, ws)\n        };\n    }\n    else if (((n3 >> 4) | (dat[3] << 20)) == 0x184D2A5) {\n        // skippable\n        return b4(dat, 4) + 8;\n    }\n    err(0);\n};\n// most significant bit for nonzero\nvar msb = function (val) {\n    var bits = 0;\n    for (; (1 << bits) <= val; ++bits)\n        ;\n    return bits - 1;\n};\n// read finite state entropy\nvar rfse = function (dat, bt, mal) {\n    // table pos\n    var tpos = (bt << 3) + 4;\n    // accuracy log\n    var al = (dat[bt] & 15) + 5;\n    if (al > mal)\n        err(3);\n    // size\n    var sz = 1 << al;\n    // probabilities symbols  repeat   index   high threshold\n    var probs = sz, sym = -1, re = -1, i = -1, ht = sz;\n    // optimization: single allocation is much faster\n    var buf = new ab(512 + (sz << 2));\n    var freq = new i16(buf, 0, 256);\n    // same view as freq\n    var dstate = new u16(buf, 0, 256);\n    var nstate = new u16(buf, 512, sz);\n    var bb1 = 512 + (sz << 1);\n    var syms = new u8(buf, bb1, sz);\n    var nbits = new u8(buf, bb1 + sz);\n    while (sym < 255 && probs > 0) {\n        var bits = msb(probs + 1);\n        var cbt = tpos >> 3;\n        // mask\n        var msk = (1 << (bits + 1)) - 1;\n        var val = ((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (tpos & 7)) & msk;\n        // mask (1 fewer bit)\n        var msk1fb = (1 << bits) - 1;\n        // max small value\n        var msv = msk - probs - 1;\n        // small value\n        var sval = val & msk1fb;\n        if (sval < msv)\n            tpos += bits, val = sval;\n        else {\n            tpos += bits + 1;\n            if (val > msk1fb)\n                val -= msv;\n        }\n        freq[++sym] = --val;\n        if (val == -1) {\n            probs += val;\n            syms[--ht] = sym;\n        }\n        else\n            probs -= val;\n        if (!val) {\n            do {\n                // repeat byte\n                var rbt = tpos >> 3;\n                re = ((dat[rbt] | (dat[rbt + 1] << 8)) >> (tpos & 7)) & 3;\n                tpos += 2;\n                sym += re;\n            } while (re == 3);\n        }\n    }\n    if (sym > 255 || probs)\n        err(0);\n    var sympos = 0;\n    // sym step (coprime with sz - formula from zstd source)\n    var sstep = (sz >> 1) + (sz >> 3) + 3;\n    // sym mask\n    var smask = sz - 1;\n    for (var s = 0; s <= sym; ++s) {\n        var sf = freq[s];\n        if (sf < 1) {\n            dstate[s] = -sf;\n            continue;\n        }\n        // This is split into two loops in zstd to avoid branching, but as JS is higher-level that is unnecessary\n        for (i = 0; i < sf; ++i) {\n            syms[sympos] = s;\n            do {\n                sympos = (sympos + sstep) & smask;\n            } while (sympos >= ht);\n        }\n    }\n    // After spreading symbols, should be zero again\n    if (sympos)\n        err(0);\n    for (i = 0; i < sz; ++i) {\n        // next state\n        var ns = dstate[syms[i]]++;\n        // num bits\n        var nb = nbits[i] = al - msb(ns);\n        nstate[i] = (ns << nb) - sz;\n    }\n    return [(tpos + 7) >> 3, {\n            b: al,\n            s: syms,\n            n: nbits,\n            t: nstate\n        }];\n};\n// read huffman\nvar rhu = function (dat, bt) {\n    //  index  weight count\n    var i = 0, wc = -1;\n    //    buffer             header byte\n    var buf = new u8(292), hb = dat[bt];\n    // huffman weights\n    var hw = buf.subarray(0, 256);\n    // rank count\n    var rc = buf.subarray(256, 268);\n    // rank index\n    var ri = new u16(buf.buffer, 268);\n    // NOTE: at this point bt is 1 less than expected\n    if (hb < 128) {\n        // end byte, fse decode table\n        var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];\n        bt += hb;\n        var epos = ebt << 3;\n        // last byte\n        var lb = dat[bt];\n        if (!lb)\n            err(0);\n        //  state1   state2   state1 bits   state2 bits\n        var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;\n        // fse pos\n        // pre-increment to account for original deficit of 1\n        var fpos = (++bt << 3) - 8 + msb(lb);\n        for (;;) {\n            fpos -= btr1;\n            if (fpos < epos)\n                break;\n            var cbt = fpos >> 3;\n            st1 += ((dat[cbt] | (dat[cbt + 1] << 8)) >> (fpos & 7)) & ((1 << btr1) - 1);\n            hw[++wc] = fdt.s[st1];\n            fpos -= btr2;\n            if (fpos < epos)\n                break;\n            cbt = fpos >> 3;\n            st2 += ((dat[cbt] | (dat[cbt + 1] << 8)) >> (fpos & 7)) & ((1 << btr2) - 1);\n            hw[++wc] = fdt.s[st2];\n            btr1 = fdt.n[st1];\n            st1 = fdt.t[st1];\n            btr2 = fdt.n[st2];\n            st2 = fdt.t[st2];\n        }\n        if (++wc > 255)\n            err(0);\n    }\n    else {\n        wc = hb - 127;\n        for (; i < wc; i += 2) {\n            var byte = dat[++bt];\n            hw[i] = byte >> 4;\n            hw[i + 1] = byte & 15;\n        }\n        ++bt;\n    }\n    // weight exponential sum\n    var wes = 0;\n    for (i = 0; i < wc; ++i) {\n        var wt = hw[i];\n        // bits must be at most 11, same as weight\n        if (wt > 11)\n            err(0);\n        wes += wt && (1 << (wt - 1));\n    }\n    // max bits\n    var mb = msb(wes) + 1;\n    // table size\n    var ts = 1 << mb;\n    // remaining sum\n    var rem = ts - wes;\n    // must be power of 2\n    if (rem & (rem - 1))\n        err(0);\n    hw[wc++] = msb(rem) + 1;\n    for (i = 0; i < wc; ++i) {\n        var wt = hw[i];\n        ++rc[hw[i] = wt && (mb + 1 - wt)];\n    }\n    // huf buf\n    var hbuf = new u8(ts << 1);\n    //    symbols                      num bits\n    var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);\n    ri[mb] = 0;\n    for (i = mb; i > 0; --i) {\n        var pv = ri[i];\n        fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << (mb - i)));\n    }\n    if (ri[0] != ts)\n        err(0);\n    for (i = 0; i < wc; ++i) {\n        var bits = hw[i];\n        if (bits) {\n            var code = ri[bits];\n            fill(syms, i, code, ri[bits] = code + (1 << (mb - bits)));\n        }\n    }\n    return [bt, {\n            n: nb,\n            b: mb,\n            s: syms\n        }];\n};\n// Tables generated using this:\n// https://gist.github.com/101arrowz/a979452d4355992cbf8f257cbffc9edd\n// default literal length table\nvar dllt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([\n    81, 16, 99, 140, 49, 198, 24, 99, 12, 33, 196, 24, 99, 102, 102, 134, 70, 146, 4\n]), 0, 6)[1];\n// default match length table\nvar dmlt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([\n    33, 20, 196, 24, 99, 140, 33, 132, 16, 66, 8, 33, 132, 16, 66, 8, 33, 68, 68, 68, 68, 68, 68, 68, 68, 36, 9\n]), 0, 6)[1];\n// default offset code table\nvar doct = /*#__PURE__ */ rfse(/*#__PURE__*/ new u8([\n    32, 132, 16, 66, 102, 70, 68, 68, 68, 68, 36, 73, 2\n]), 0, 5)[1];\n// bits to baseline\nvar b2bl = function (b, s) {\n    var len = b.length, bl = new i32(len);\n    for (var i = 0; i < len; ++i) {\n        bl[i] = s;\n        s += 1 << b[i];\n    }\n    return bl;\n};\n// literal length bits\nvar llb = /*#__PURE__ */ new u8(( /*#__PURE__ */new i32([\n    0, 0, 0, 0, 16843009, 50528770, 134678020, 202050057, 269422093\n])).buffer, 0, 36);\n// literal length baseline\nvar llbl = /*#__PURE__ */ b2bl(llb, 0);\n// match length bits\nvar mlb = /*#__PURE__ */ new u8(( /*#__PURE__ */new i32([\n    0, 0, 0, 0, 0, 0, 0, 0, 16843009, 50528770, 117769220, 185207048, 252579084, 16\n])).buffer, 0, 53);\n// match length baseline\nvar mlbl = /*#__PURE__ */ b2bl(mlb, 3);\n// decode huffman stream\nvar dhu = function (dat, out, hu) {\n    var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;\n    if (!lb)\n        err(0);\n    var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;\n    for (; pos > eb && i < ss;) {\n        var cbt = pos >> 3;\n        var val = (dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (pos & 7);\n        st = ((st << btr) | val) & msk;\n        out[++i] = hu.s[st];\n        pos -= (btr = hu.n[st]);\n    }\n    if (pos != eb || i + 1 != ss)\n        err(0);\n};\n// decode huffman stream 4x\n// TODO: use workers to parallelize\nvar dhu4 = function (dat, out, hu) {\n    var bt = 6;\n    var ss = out.length, sz1 = (ss + 3) >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;\n    dhu(dat.subarray(bt, bt += dat[0] | (dat[1] << 8)), out.subarray(0, sz1), hu);\n    dhu(dat.subarray(bt, bt += dat[2] | (dat[3] << 8)), out.subarray(sz1, sz2), hu);\n    dhu(dat.subarray(bt, bt += dat[4] | (dat[5] << 8)), out.subarray(sz2, sz3), hu);\n    dhu(dat.subarray(bt), out.subarray(sz3), hu);\n};\n// read Zstandard block\nvar rzb = function (dat, st, out) {\n    var _a;\n    var bt = st.b;\n    //    byte 0        block type\n    var b0 = dat[bt], btype = (b0 >> 1) & 3;\n    st.l = b0 & 1;\n    var sz = (b0 >> 3) | (dat[bt + 1] << 5) | (dat[bt + 2] << 13);\n    // end byte for block\n    var ebt = (bt += 3) + sz;\n    if (btype == 1) {\n        if (bt >= dat.length)\n            return;\n        st.b = bt + 1;\n        if (out) {\n            fill(out, dat[bt], st.y, st.y += sz);\n            return out;\n        }\n        return fill(new u8(sz), dat[bt]);\n    }\n    if (ebt > dat.length)\n        return;\n    if (btype == 0) {\n        st.b = ebt;\n        if (out) {\n            out.set(dat.subarray(bt, ebt), st.y);\n            st.y += sz;\n            return out;\n        }\n        return slc(dat, bt, ebt);\n    }\n    if (btype == 2) {\n        //    byte 3        lit btype     size format\n        var b3 = dat[bt], lbt = b3 & 3, sf = (b3 >> 2) & 3;\n        // lit src size  lit cmp sz 4 streams\n        var lss = b3 >> 4, lcs = 0, s4 = 0;\n        if (lbt < 2) {\n            if (sf & 1)\n                lss |= (dat[++bt] << 4) | ((sf & 2) && (dat[++bt] << 12));\n            else\n                lss = b3 >> 3;\n        }\n        else {\n            s4 = sf;\n            if (sf < 2)\n                lss |= ((dat[++bt] & 63) << 4), lcs = (dat[bt] >> 6) | (dat[++bt] << 2);\n            else if (sf == 2)\n                lss |= (dat[++bt] << 4) | ((dat[++bt] & 3) << 12), lcs = (dat[bt] >> 2) | (dat[++bt] << 6);\n            else\n                lss |= (dat[++bt] << 4) | ((dat[++bt] & 63) << 12), lcs = (dat[bt] >> 6) | (dat[++bt] << 2) | (dat[++bt] << 10);\n        }\n        ++bt;\n        // add literals to end - can never overlap with backreferences because unused literals always appended\n        var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);\n        // starting point for literals\n        var spl = buf.length - lss;\n        if (lbt == 0)\n            buf.set(dat.subarray(bt, bt += lss), spl);\n        else if (lbt == 1)\n            fill(buf, dat[bt++], spl);\n        else {\n            // huffman table\n            var hu = st.h;\n            if (lbt == 2) {\n                var hud = rhu(dat, bt);\n                // subtract description length\n                lcs += bt - (bt = hud[0]);\n                st.h = hu = hud[1];\n            }\n            else if (!hu)\n                err(0);\n            (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);\n        }\n        // num sequences\n        var ns = dat[bt++];\n        if (ns) {\n            if (ns == 255)\n                ns = (dat[bt++] | (dat[bt++] << 8)) + 0x7F00;\n            else if (ns > 127)\n                ns = ((ns - 128) << 8) | dat[bt++];\n            // symbol compression modes\n            var scm = dat[bt++];\n            if (scm & 3)\n                err(0);\n            var dts = [dmlt, doct, dllt];\n            for (var i = 2; i > -1; --i) {\n                var md = (scm >> ((i << 1) + 2)) & 3;\n                if (md == 1) {\n                    // rle buf\n                    var rbuf = new u8([0, 0, dat[bt++]]);\n                    dts[i] = {\n                        s: rbuf.subarray(2, 3),\n                        n: rbuf.subarray(0, 1),\n                        t: new u16(rbuf.buffer, 0, 1),\n                        b: 0\n                    };\n                }\n                else if (md == 2) {\n                    // accuracy log 8 for offsets, 9 for others\n                    _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];\n                }\n                else if (md == 3) {\n                    if (!st.t)\n                        err(0);\n                    dts[i] = st.t[i];\n                }\n            }\n            var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];\n            var lb = dat[ebt - 1];\n            if (!lb)\n                err(0);\n            var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;\n            var lst = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << llt.b) - 1);\n            cbt = (spos -= oct.b) >> 3;\n            var ost = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << oct.b) - 1);\n            cbt = (spos -= mlt.b) >> 3;\n            var mst = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << mlt.b) - 1);\n            for (++ns; --ns;) {\n                var llc = llt.s[lst];\n                var lbtr = llt.n[lst];\n                var mlc = mlt.s[mst];\n                var mbtr = mlt.n[mst];\n                var ofc = oct.s[ost];\n                var obtr = oct.n[ost];\n                cbt = (spos -= ofc) >> 3;\n                var ofp = 1 << ofc;\n                var off = ofp + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16) | (dat[cbt + 3] << 24)) >>> (spos & 7)) & (ofp - 1));\n                cbt = (spos -= mlb[mlc]) >> 3;\n                var ml = mlbl[mlc] + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (spos & 7)) & ((1 << mlb[mlc]) - 1));\n                cbt = (spos -= llb[llc]) >> 3;\n                var ll = llbl[llc] + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (spos & 7)) & ((1 << llb[llc]) - 1));\n                cbt = (spos -= lbtr) >> 3;\n                lst = llt.t[lst] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << lbtr) - 1));\n                cbt = (spos -= mbtr) >> 3;\n                mst = mlt.t[mst] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << mbtr) - 1));\n                cbt = (spos -= obtr) >> 3;\n                ost = oct.t[ost] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << obtr) - 1));\n                if (off > 3) {\n                    st.o[2] = st.o[1];\n                    st.o[1] = st.o[0];\n                    st.o[0] = off -= 3;\n                }\n                else {\n                    var idx = off - (ll != 0);\n                    if (idx) {\n                        off = idx == 3 ? st.o[0] - 1 : st.o[idx];\n                        if (idx > 1)\n                            st.o[2] = st.o[1];\n                        st.o[1] = st.o[0];\n                        st.o[0] = off;\n                    }\n                    else\n                        off = st.o[0];\n                }\n                for (var i = 0; i < ll; ++i) {\n                    buf[oubt + i] = buf[spl + i];\n                }\n                oubt += ll, spl += ll;\n                var stin = oubt - off;\n                if (stin < 0) {\n                    var len = -stin;\n                    var bs = st.e + stin;\n                    if (len > ml)\n                        len = ml;\n                    for (var i = 0; i < len; ++i) {\n                        buf[oubt + i] = st.w[bs + i];\n                    }\n                    oubt += len, ml -= len, stin = 0;\n                }\n                for (var i = 0; i < ml; ++i) {\n                    buf[oubt + i] = buf[stin + i];\n                }\n                oubt += ml;\n            }\n            if (oubt != spl) {\n                while (spl < buf.length) {\n                    buf[oubt++] = buf[spl++];\n                }\n            }\n            else\n                oubt = buf.length;\n            if (out)\n                st.y += oubt;\n            else\n                buf = slc(buf, 0, oubt);\n        }\n        else if (out) {\n            st.y += lss;\n            if (spl) {\n                for (var i = 0; i < lss; ++i) {\n                    buf[i] = buf[spl + i];\n                }\n            }\n        }\n        else if (spl)\n            buf = slc(buf, spl);\n        st.b = ebt;\n        return buf;\n    }\n    err(2);\n};\n// concat\nvar cct = function (bufs, ol) {\n    if (bufs.length == 1)\n        return bufs[0];\n    var buf = new u8(ol);\n    for (var i = 0, b = 0; i < bufs.length; ++i) {\n        var chk = bufs[i];\n        buf.set(chk, b);\n        b += chk.length;\n    }\n    return buf;\n};\n/**\n * Decompresses Zstandard data\n * @param dat The input data\n * @param buf The output buffer. If unspecified, the function will allocate\n *            exactly enough memory to fit the decompressed data. If your\n *            data has multiple frames and you know the output size, specifying\n *            it will yield better performance.\n * @returns The decompressed data\n */\nexport function decompress(dat, buf) {\n    var bufs = [], nb = +!buf;\n    var bt = 0, ol = 0;\n    for (; dat.length;) {\n        var st = rzfh(dat, nb || buf);\n        if (typeof st == 'object') {\n            if (nb) {\n                buf = null;\n                if (st.w.length == st.u) {\n                    bufs.push(buf = st.w);\n                    ol += st.u;\n                }\n            }\n            else {\n                bufs.push(buf);\n                st.e = 0;\n            }\n            for (; !st.l;) {\n                var blk = rzb(dat, st, buf);\n                if (!blk)\n                    err(5);\n                if (buf)\n                    st.e = st.y;\n                else {\n                    bufs.push(blk);\n                    ol += blk.length;\n                    cpw(st.w, 0, blk.length);\n                    st.w.set(blk, st.w.length - blk.length);\n                }\n            }\n            bt = st.b + (st.c * 4);\n        }\n        else\n            bt = st;\n        dat = dat.subarray(bt);\n    }\n    return cct(bufs, ol);\n}\n/**\n * Decompressor for Zstandard streamed data\n */\nvar Decompress = /*#__PURE__*/ (function () {\n    /**\n     * Creates a Zstandard decompressor\n     * @param ondata The handler for stream data\n     */\n    function Decompress(ondata) {\n        this.ondata = ondata;\n        this.c = [];\n        this.l = 0;\n        this.z = 0;\n    }\n    /**\n     * Pushes data to be decompressed\n     * @param chunk The chunk of data to push\n     * @param final Whether or not this is the last chunk in the stream\n     */\n    Decompress.prototype.push = function (chunk, final) {\n        if (typeof this.s == 'number') {\n            var sub = Math.min(chunk.length, this.s);\n            chunk = chunk.subarray(sub);\n            this.s -= sub;\n        }\n        var sl = chunk.length;\n        var ncs = sl + this.l;\n        if (!this.s) {\n            if (final) {\n                if (!ncs) {\n                    this.ondata(new u8(0), true);\n                    return;\n                }\n                // min for frame + one block\n                if (ncs < 5)\n                    err(5);\n            }\n            else if (ncs < 18) {\n                this.c.push(chunk);\n                this.l = ncs;\n                return;\n            }\n            if (this.l) {\n                this.c.push(chunk);\n                chunk = cct(this.c, ncs);\n                this.c = [];\n                this.l = 0;\n            }\n            if (typeof (this.s = rzfh(chunk)) == 'number')\n                return this.push(chunk, final);\n        }\n        if (typeof this.s != 'number') {\n            if (ncs < (this.z || 3)) {\n                if (final)\n                    err(5);\n                this.c.push(chunk);\n                this.l = ncs;\n                return;\n            }\n            if (this.l) {\n                this.c.push(chunk);\n                chunk = cct(this.c, ncs);\n                this.c = [];\n                this.l = 0;\n            }\n            if (!this.z && ncs < (this.z = (chunk[this.s.b] & 2) ? 4 : 3 + ((chunk[this.s.b] >> 3) | (chunk[this.s.b + 1] << 5) | (chunk[this.s.b + 2] << 13)))) {\n                if (final)\n                    err(5);\n                this.c.push(chunk);\n                this.l = ncs;\n                return;\n            }\n            else\n                this.z = 0;\n            for (;;) {\n                var blk = rzb(chunk, this.s);\n                if (!blk) {\n                    if (final)\n                        err(5);\n                    var adc = chunk.subarray(this.s.b);\n                    this.s.b = 0;\n                    this.c.push(adc), this.l += adc.length;\n                    return;\n                }\n                else {\n                    this.ondata(blk, false);\n                    cpw(this.s.w, 0, blk.length);\n                    this.s.w.set(blk, this.s.w.length - blk.length);\n                }\n                if (this.s.l) {\n                    var rest = chunk.subarray(this.s.b);\n                    this.s = this.s.c * 4;\n                    this.push(rest, final);\n                    return;\n                }\n            }\n        }\n        else if (final)\n            err(5);\n    };\n    return Decompress;\n}());\nexport { Decompress };\n","// Growable little/big-endian byte buffer primitives for the brdb codecs.\n// msgpack multi-byte values are big-endian; brdb flat arrays are little-endian.\n\nexport class ByteWriter {\n  private buf = new Uint8Array(256);\n  private view = new DataView(this.buf.buffer);\n  private len = 0;\n\n  private ensure(n: number) {\n    if (this.len + n <= this.buf.length) return;\n    let size = this.buf.length * 2;\n    while (size < this.len + n) size *= 2;\n    const next = new Uint8Array(size);\n    next.set(this.buf.subarray(0, this.len));\n    this.buf = next;\n    this.view = new DataView(next.buffer);\n  }\n\n  get length(): number {\n    return this.len;\n  }\n\n  u8(v: number) {\n    this.ensure(1);\n    this.buf[this.len++] = v & 0xff;\n  }\n\n  i8(v: number) {\n    this.ensure(1);\n    this.view.setInt8(this.len, v);\n    this.len += 1;\n  }\n\n  bytes(v: Uint8Array | number[]) {\n    const arr = v instanceof Uint8Array ? v : Uint8Array.from(v);\n    this.ensure(arr.length);\n    this.buf.set(arr, this.len);\n    this.len += arr.length;\n  }\n\n  u16be(v: number) {\n    this.ensure(2);\n    this.view.setUint16(this.len, v, false);\n    this.len += 2;\n  }\n  u32be(v: number) {\n    this.ensure(4);\n    this.view.setUint32(this.len, v, false);\n    this.len += 4;\n  }\n  u64be(v: bigint) {\n    this.ensure(8);\n    this.view.setBigUint64(this.len, v, false);\n    this.len += 8;\n  }\n  i16be(v: number) {\n    this.ensure(2);\n    this.view.setInt16(this.len, v, false);\n    this.len += 2;\n  }\n  i32be(v: number) {\n    this.ensure(4);\n    this.view.setInt32(this.len, v, false);\n    this.len += 4;\n  }\n  i64be(v: bigint) {\n    this.ensure(8);\n    this.view.setBigInt64(this.len, v, false);\n    this.len += 8;\n  }\n  f32be(v: number) {\n    this.ensure(4);\n    this.view.setFloat32(this.len, v, false);\n    this.len += 4;\n  }\n  f64be(v: number) {\n    this.ensure(8);\n    this.view.setFloat64(this.len, v, false);\n    this.len += 8;\n  }\n\n  u16le(v: number) {\n    this.ensure(2);\n    this.view.setUint16(this.len, v, true);\n    this.len += 2;\n  }\n  u32le(v: number) {\n    this.ensure(4);\n    this.view.setUint32(this.len, v, true);\n    this.len += 4;\n  }\n  u64le(v: bigint) {\n    this.ensure(8);\n    this.view.setBigUint64(this.len, v, true);\n    this.len += 8;\n  }\n  i16le(v: number) {\n    this.ensure(2);\n    this.view.setInt16(this.len, v, true);\n    this.len += 2;\n  }\n  i32le(v: number) {\n    this.ensure(4);\n    this.view.setInt32(this.len, v, true);\n    this.len += 4;\n  }\n  i64le(v: bigint) {\n    this.ensure(8);\n    this.view.setBigInt64(this.len, v, true);\n    this.len += 8;\n  }\n  f32le(v: number) {\n    this.ensure(4);\n    this.view.setFloat32(this.len, v, true);\n    this.len += 4;\n  }\n  f64le(v: number) {\n    this.ensure(8);\n    this.view.setFloat64(this.len, v, true);\n    this.len += 8;\n  }\n\n  toBytes(): Uint8Array {\n    return this.buf.slice(0, this.len);\n  }\n}\n\nexport class ByteReader {\n  private view: DataView;\n  offset: number;\n\n  constructor(public data: Uint8Array, offset = 0) {\n    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n    this.offset = offset;\n  }\n\n  get remaining(): number {\n    return this.data.length - this.offset;\n  }\n\n  private need(n: number) {\n    if (this.offset + n > this.data.length)\n      throw new RangeError(\n        `brdb: unexpected end of data (need ${n} bytes at offset ${this.offset} of ${this.data.length})`\n      );\n  }\n\n  peek(): number {\n    this.need(1);\n    return this.data[this.offset];\n  }\n\n  u8(): number {\n    this.need(1);\n    return this.data[this.offset++];\n  }\n  i8(): number {\n    this.need(1);\n    return this.view.getInt8(this.offset++);\n  }\n\n  bytes(n: number): Uint8Array {\n    this.need(n);\n    const out = this.data.subarray(this.offset, this.offset + n);\n    this.offset += n;\n    return out;\n  }\n\n  u16be(): number {\n    this.need(2);\n    const v = this.view.getUint16(this.offset, false);\n    this.offset += 2;\n    return v;\n  }\n  u32be(): number {\n    this.need(4);\n    const v = this.view.getUint32(this.offset, false);\n    this.offset += 4;\n    return v;\n  }\n  u64be(): bigint {\n    this.need(8);\n    const v = this.view.getBigUint64(this.offset, false);\n    this.offset += 8;\n    return v;\n  }\n  i16be(): number {\n    this.need(2);\n    const v = this.view.getInt16(this.offset, false);\n    this.offset += 2;\n    return v;\n  }\n  i32be(): number {\n    this.need(4);\n    const v = this.view.getInt32(this.offset, false);\n    this.offset += 4;\n    return v;\n  }\n  i64be(): bigint {\n    this.need(8);\n    const v = this.view.getBigInt64(this.offset, false);\n    this.offset += 8;\n    return v;\n  }\n  f32be(): number {\n    this.need(4);\n    const v = this.view.getFloat32(this.offset, false);\n    this.offset += 4;\n    return v;\n  }\n  f64be(): number {\n    this.need(8);\n    const v = this.view.getFloat64(this.offset, false);\n    this.offset += 8;\n    return v;\n  }\n\n  u16le(): number {\n    this.need(2);\n    const v = this.view.getUint16(this.offset, true);\n    this.offset += 2;\n    return v;\n  }\n  u32le(): number {\n    this.need(4);\n    const v = this.view.getUint32(this.offset, true);\n    this.offset += 4;\n    return v;\n  }\n  u64le(): bigint {\n    this.need(8);\n    const v = this.view.getBigUint64(this.offset, true);\n    this.offset += 8;\n    return v;\n  }\n  i16le(): number {\n    this.need(2);\n    const v = this.view.getInt16(this.offset, true);\n    this.offset += 2;\n    return v;\n  }\n  i32le(): number {\n    this.need(4);\n    const v = this.view.getInt32(this.offset, true);\n    this.offset += 4;\n    return v;\n  }\n  i64le(): bigint {\n    this.need(8);\n    const v = this.view.getBigInt64(this.offset, true);\n    this.offset += 8;\n    return v;\n  }\n  f32le(): number {\n    this.need(4);\n    const v = this.view.getFloat32(this.offset, true);\n    this.offset += 4;\n    return v;\n  }\n  f64le(): number {\n    this.need(8);\n    const v = this.view.getFloat64(this.offset, true);\n    this.offset += 8;\n    return v;\n  }\n}\n","// .brz container serializer/deserializer, byte-compatible with the game's\n// archive format.\nimport { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\nimport { decompress as zstdDecompress } from 'fzstd';\nimport { ByteReader, ByteWriter } from './bytes';\nimport type { FoundFile, WorldFs } from './fs';\nimport { PendingEntry, PendingNode } from './pending';\n\nexport type Compressor = (data: Uint8Array) => Uint8Array | null;\n\nexport interface BrzContainerOptions {\n  /** zstd compressor (e.g. node:zlib zstdCompressSync); return null to skip.\n   * Omitted -> every blob stored raw (still a valid archive, and what the\n   * byte-parity gates compare against). */\n  compress?: Compressor;\n}\n\nexport function writeBrzContainer(\n  root: PendingEntry[],\n  options: BrzContainerOptions = {}\n): Uint8Array {\n  interface QueueItem {\n    parentId: number;\n    name: string;\n    node: PendingNode;\n  }\n  // BFS; ids are assigned when an entry is dequeued\n  const queue: QueueItem[] = root.map(([name, node]) => ({\n    parentId: -1,\n    name,\n    node,\n  }));\n\n  const folderParentIds: number[] = [];\n  const folderNames: string[] = [];\n  const fileParentIds: number[] = [];\n  const fileContentIds: number[] = [];\n  const fileNames: string[] = [];\n  const methods: number[] = [];\n  const sizesUncompressed: number[] = [];\n  const sizesCompressed: number[] = [];\n  const blobHashes: Uint8Array[] = [];\n  const blobChunks: Uint8Array[] = [];\n  const hashToBlobId = new Map<string, number>();\n\n  for (let head = 0; head < queue.length; head++) {\n    const { parentId, name, node } = queue[head];\n    if (node.type === 'folder') {\n      const folderId = folderParentIds.length;\n      folderParentIds.push(parentId);\n      folderNames.push(name);\n      for (const [childName, child] of node.children)\n        queue.push({ parentId: folderId, name: childName, node: child });\n    } else {\n      fileParentIds.push(parentId);\n      fileNames.push(name);\n      const content = node.content;\n      let contentId: number;\n      if (content.length === 0) {\n        contentId = -1; // empty file: no blob\n      } else {\n        const hash = blake3(content);\n        const hex = bytesToHex(hash);\n        const existing = hashToBlobId.get(hex);\n        if (existing !== undefined) {\n          contentId = existing; // dedup by hash of uncompressed content\n        } else {\n          contentId = blobHashes.length;\n          hashToBlobId.set(hex, contentId);\n          blobHashes.push(hash);\n          sizesUncompressed.push(content.length);\n          const compressed = options.compress\n            ? options.compress(content)\n            : null;\n          if (compressed && compressed.length < content.length) {\n            methods.push(1); // GenericZstd, only when strictly smaller\n            sizesCompressed.push(compressed.length);\n            blobChunks.push(compressed);\n          } else {\n            methods.push(0);\n            sizesCompressed.push(content.length);\n            blobChunks.push(content);\n          }\n        }\n      }\n      fileContentIds.push(contentId);\n    }\n  }\n\n  const utf8 = new TextEncoder();\n  const iw = new ByteWriter();\n  iw.i32le(folderNames.length);\n  iw.i32le(fileNames.length);\n  iw.i32le(blobHashes.length);\n  for (const id of folderParentIds) iw.i32le(id);\n  const folderNameBytes = folderNames.map(n => utf8.encode(n));\n  for (const n of folderNameBytes) iw.u16le(n.length);\n  for (const n of folderNameBytes) iw.bytes(n);\n  for (const id of fileParentIds) iw.i32le(id);\n  for (const id of fileContentIds) iw.i32le(id);\n  const fileNameBytes = fileNames.map(n => utf8.encode(n));\n  for (const n of fileNameBytes) iw.u16le(n.length);\n  for (const n of fileNameBytes) iw.bytes(n);\n  for (const m of methods) iw.u8(m);\n  for (const s of sizesUncompressed) iw.i32le(s);\n  for (const s of sizesCompressed) iw.i32le(s);\n  for (const h of blobHashes) iw.bytes(h);\n  const index = iw.toBytes();\n\n  const out = new ByteWriter();\n  out.bytes([0x42, 0x52, 0x5a]); // \"BRZ\"\n  out.u8(0); // version: Initial\n  // The index is always stored uncompressed — the format's reference writer\n  // never compresses it, and byte parity requires matching that. Readers\n  // still accept a compressed index.\n  out.u8(0); // index_method: None\n  out.i32le(index.length);\n  out.i32le(index.length); // compressed size mirrors uncompressed when raw\n  out.bytes(blake3(index)); // BLAKE3 of the uncompressed index\n  out.bytes(index);\n  for (const chunk of blobChunks) out.bytes(chunk);\n  return out.toBytes();\n}\n\ninterface BlobInfo {\n  method: number;\n  sizeUncompressed: number;\n  sizeCompressed: number;\n  hash: Uint8Array;\n  start: number;\n  end: number;\n}\n\nexport class BrzReader implements WorldFs {\n  private folderLut = new Map<string, number>();\n  private fileLut = new Map<string, number>();\n  private pathCache: string[] | null = null;\n\n  private constructor(\n    readonly folderParentIds: number[],\n    readonly folderNames: string[],\n    readonly fileParentIds: number[],\n    readonly fileContentIds: number[],\n    readonly fileNames: string[],\n    private blobs: BlobInfo[],\n    private blobData: Uint8Array\n  ) {\n    for (let i = 0; i < folderNames.length; i++)\n      this.folderLut.set(`${folderParentIds[i]} ${folderNames[i]}`, i);\n    for (let i = 0; i < fileNames.length; i++)\n      this.fileLut.set(`${fileParentIds[i]} ${fileNames[i]}`, i);\n  }\n\n  static from(data: Uint8Array): BrzReader {\n    const r = new ByteReader(data);\n    const magic = r.bytes(3);\n    if (magic[0] !== 0x42 || magic[1] !== 0x52 || magic[2] !== 0x5a)\n      throw new Error('brdb: invalid .brz magic');\n    const version = r.u8();\n    if (version !== 0)\n      throw new Error(`brdb: unsupported .brz version ${version}`);\n    const method = r.u8();\n    if (method !== 0 && method !== 1)\n      throw new Error(`brdb: invalid index compression method ${method}`);\n    const sizeUncompressed = r.i32le();\n    const sizeCompressed = r.i32le();\n    if (sizeUncompressed < 0 || sizeCompressed < 0)\n      throw new Error('brdb: negative index size');\n    const headerHash = r.bytes(32);\n    let index: Uint8Array;\n    if (method === 0) {\n      index = r.bytes(sizeUncompressed);\n    } else {\n      index = zstdDecompress(\n        r.bytes(sizeCompressed),\n        new Uint8Array(sizeUncompressed)\n      );\n      if (index.length !== sizeUncompressed)\n        throw new Error('brdb: index decompressed to the wrong size');\n    }\n    if (bytesToHex(blake3(index)) !== bytesToHex(headerHash))\n      throw new Error('brdb: index hash mismatch');\n    const blobData = r.bytes(r.remaining);\n\n    const ir = new ByteReader(index);\n    const numFolders = ir.i32le();\n    const numFiles = ir.i32le();\n    const numBlobs = ir.i32le();\n    if (numFolders < 0 || numFiles < 0 || numBlobs < 0)\n      throw new Error('brdb: negative index count');\n    const readArray = <T>(n: number, fn: () => T): T[] =>\n      Array.from({ length: n }, fn);\n    const folderParentIds = readArray(numFolders, () => ir.i32le());\n    const folderNameLens = readArray(numFolders, () => ir.u16le());\n    const utf8 = new TextDecoder('utf-8', { fatal: true });\n    const folderNames = folderNameLens.map(len => utf8.decode(ir.bytes(len)));\n    const fileParentIds = readArray(numFiles, () => ir.i32le());\n    const fileContentIds = readArray(numFiles, () => ir.i32le());\n    const fileNameLens = readArray(numFiles, () => ir.u16le());\n    const fileNames = fileNameLens.map(len => utf8.decode(ir.bytes(len)));\n    const methods = readArray(numBlobs, () => ir.u8());\n    const sizesUncompressed = readArray(numBlobs, () => ir.i32le());\n    const sizesCompressed = readArray(numBlobs, () => ir.i32le());\n    const hashes = readArray(numBlobs, () => ir.bytes(32).slice());\n    if (ir.remaining !== 0) throw new Error('brdb: trailing bytes in index');\n\n    // blob byte ranges are not stored: reconstruct by accumulating on-disk sizes\n    const blobs: BlobInfo[] = [];\n    let offset = 0;\n    for (let i = 0; i < numBlobs; i++) {\n      if (sizesUncompressed[i] < 0 || sizesCompressed[i] < 0)\n        throw new Error('brdb: negative blob size');\n      const length =\n        methods[i] === 0 ? sizesUncompressed[i] : sizesCompressed[i];\n      blobs.push({\n        method: methods[i],\n        sizeUncompressed: sizesUncompressed[i],\n        sizeCompressed: sizesCompressed[i],\n        hash: hashes[i],\n        start: offset,\n        end: offset + length,\n      });\n      offset += length;\n    }\n    return new BrzReader(\n      folderParentIds,\n      folderNames,\n      fileParentIds,\n      fileContentIds,\n      fileNames,\n      blobs,\n      blobData\n    );\n  }\n\n  /** parentId -1 = root */\n  findFolder(parentId: number, name: string): number | null {\n    return this.folderLut.get(`${parentId} ${name}`) ?? null;\n  }\n\n  findFile(parentId: number, name: string): { contentId: number } | null {\n    const i = this.fileLut.get(`${parentId} ${name}`);\n    return i === undefined ? null : { contentId: this.fileContentIds[i] };\n  }\n\n  private folderIdOf(path: string): number | null {\n    if (path === '') return -1;\n    let id = -1;\n    for (const part of path.split('/')) {\n      const next = this.findFolder(id, part);\n      if (next === null) return null;\n      id = next;\n    }\n    return id;\n  }\n\n  /** Names of the subfolders of a folder path ('' = root), in id order.\n   * A missing path yields []. */\n  childFolders(path: string): string[] {\n    const parent = this.folderIdOf(path);\n    if (parent === null) return [];\n    const out: string[] = [];\n    for (let i = 0; i < this.folderNames.length; i++)\n      if (this.folderParentIds[i] === parent) out.push(this.folderNames[i]);\n    return out;\n  }\n\n  /** Names of the files directly inside a folder path ('' = root), in id\n   * order. A missing path yields []. */\n  childFiles(path: string): string[] {\n    const parent = this.folderIdOf(path);\n    if (parent === null) return [];\n    const out: string[] = [];\n    for (let i = 0; i < this.fileNames.length; i++)\n      if (this.fileParentIds[i] === parent) out.push(this.fileNames[i]);\n    return out;\n  }\n\n  blobMethod(contentId: number): number {\n    return this.blob(contentId).method;\n  }\n\n  private blob(contentId: number): BlobInfo {\n    if (contentId < 0 || contentId >= this.blobs.length)\n      throw new Error(`brdb: blob ${contentId} not found`);\n    return this.blobs[contentId];\n  }\n\n  /** Decompress (if needed) and verify size + BLAKE3. */\n  readBlob(contentId: number): Uint8Array {\n    const blob = this.blob(contentId);\n    const raw = this.blobData.subarray(blob.start, blob.end);\n    let content: Uint8Array;\n    if (blob.method === 0) {\n      content = raw;\n    } else {\n      if (raw.length !== blob.sizeCompressed)\n        throw new Error('brdb: blob compressed size mismatch');\n      content = zstdDecompress(raw, new Uint8Array(blob.sizeUncompressed));\n    }\n    if (content.length !== blob.sizeUncompressed)\n      throw new Error('brdb: blob uncompressed size mismatch');\n    if (bytesToHex(blake3(content)) !== bytesToHex(blob.hash))\n      throw new Error('brdb: blob hash mismatch');\n    return content;\n  }\n\n  /** '/'-separated path from the root. An empty file (contentId -1) returns\n   * an empty buffer (the reference reader treats empty files as unfindable\n   * — deliberate, documented deviation for usability). */\n  readFile(path: string): Uint8Array {\n    if (path.startsWith('/'))\n      throw new Error('brdb: absolute paths not allowed');\n    const parts = path.split('/');\n    let parentId = -1;\n    for (let i = 0; i < parts.length - 1; i++) {\n      const next = this.findFolder(parentId, parts[i]);\n      if (next === null)\n        throw new Error(`brdb: folder not found: ${parts[i]} in ${path}`);\n      parentId = next;\n    }\n    const found = this.findFile(parentId, parts[parts.length - 1]);\n    if (!found) throw new Error(`brdb: file not found: ${path}`);\n    return found.contentId === -1\n      ? new Uint8Array(0)\n      : this.readBlob(found.contentId);\n  }\n\n  /** Path lookup returning the WorldFs FoundFile shape. createdAt is always\n   * 0: a .brz archive holds exactly one revision. */\n  findFileByPath(path: string): FoundFile | null {\n    if (path.startsWith('/'))\n      throw new Error('brdb: absolute paths not allowed');\n    const slash = path.lastIndexOf('/');\n    const parentId = this.folderIdOf(slash === -1 ? '' : path.slice(0, slash));\n    if (parentId === null) return null;\n    const found = this.findFile(parentId, path.slice(slash + 1));\n    return found === null ? null : { contentId: found.contentId, createdAt: 0 };\n  }\n\n  findFileByPathAtRevision(path: string, _date: number): FoundFile | null {\n    return this.findFileByPath(path);\n  }\n\n  /** All file paths in file-id (BFS) order. */\n  listPaths(): string[] {\n    if (this.pathCache) return this.pathCache;\n    const folderPaths: string[] = [];\n    for (let i = 0; i < this.folderNames.length; i++) {\n      const parent = this.folderParentIds[i];\n      // parents always precede children in BFS id order\n      folderPaths.push(\n        parent === -1\n          ? this.folderNames[i]\n          : `${folderPaths[parent]}/${this.folderNames[i]}`\n      );\n    }\n    this.pathCache = this.fileNames.map((name, i) => {\n      const parent = this.fileParentIds[i];\n      return parent === -1 ? name : `${folderPaths[parent]}/${name}`;\n    });\n    return this.pathCache;\n  }\n}\n","// GENERATED by scripts/syncBrdbData.mjs — do not edit by hand.\n// Regenerate with: just sync-brdb-data\n\nexport const BASIC_BRICK_ASSETS: readonly string[] = [\n  'B_1x1_Reroute_Node',\n  'B_1x1_Gate_AND',\n  'B_1x1_Gate_OR',\n  'B_1x1_Gate_XOR',\n  'B_1x1_Gate_NAND',\n  'B_1x1_Gate_NOR',\n  'B_1x1_NOT_Gate',\n  'B_1x1_Gate_AND_Bitwise',\n  'B_1x1_Gate_OR_Bitwise',\n  'B_1x1_Gate_XOR_Bitwise',\n  'B_1x1_Gate_NAND_Bitwise',\n  'B_1x1_Gate_NOR_Bitwise',\n  'B_1x1_Gate_NOT_Bitwise',\n  'B_1x1_Gate_ShiftLeft_Bitwise',\n  'B_1x1_Gate_ShiftRight_Bitwise',\n  'B_1x1_Gate_Add',\n  'B_1x1_Gate_Subtract',\n  'B_1x1_Gate_Multiply',\n  'B_1x1_Gate_ModFloored',\n  'B_1x1_Gate_Mod',\n  'B_1x1_Gate_Divide',\n  'B_1x1_Gate_Equal',\n  'B_1x1_Gate_NotEqual',\n  'B_1x1_Gate_LessThan',\n  'B_1x1_Gate_LessThanEqual',\n  'B_1x1_Gate_GreaterThan',\n  'B_1x1_Gate_GreaterThanEqual',\n  'B_1x1_Gate_Ceiling',\n  'B_1x1_Gate_Floor',\n  'B_1x1_Gate_Constant',\n  'B_1x1_Gate_Blend',\n  'B_1x1_Gate_EdgeDetector',\n  'B_1x1_Gate_Timer',\n  'B_1x1_Gate_Timer_Tick',\n  'B_1x1_Microchip',\n  'B_1x1_Gate_MicrochipInput',\n  'B_1x1_Gate_MicrochipOutput',\n  'B_2x2_Overhang',\n  'B_1x4_Brick_Side',\n  'B_1x2_Overhang',\n  'B_1x1_Brick_Side_Lip',\n  'B_1x1_Brick_Side',\n  'B_Jar',\n  'B_Chalice',\n  'B_Cauldron',\n  'B_Small_Flower',\n  'B_Pine_Tree',\n  'B_Leaf_Bush',\n  'B_Hedge_1x4',\n  'B_Hedge_1x2',\n  'B_Hedge_1x1_Corner',\n  'B_Hedge_1x1',\n  'B_Flower',\n  'B_Fern',\n  'B_Branch',\n  'B_2x4_Door_Frame',\n  'B_Turkey_Leg',\n  'B_Turkey_Body',\n  'B_Swirl_Plate',\n  'B_Sausage',\n  'B_Pumpkin_Carved',\n  'B_Pumpkin',\n  'B_Ladder',\n  'B_Inverted_Cone',\n  'B_Handle',\n  'B_Gravestone',\n  'B_Frog_Small',\n  'B_Frog',\n  'B_Flame',\n  'B_Coffin_Lid',\n  'B_Coffin',\n  'B_BoneStraight',\n  'B_Bone',\n  'B_1x1_Coin_Diagonal',\n  'B_1x1_Coin',\n  'B_Spoon',\n  'B_Fork',\n  'B_2x2_Corner',\n  'B_2x2f_Plate_Center_Inv',\n  'B_2x2f_Plate_Center',\n  'B_1x2f_Plate_Center_Inv',\n  'B_4x4_Round',\n  'B_2x2_Round',\n  'B_2x2F_Round',\n  'B_2x_Octo_T_Inv',\n  'B_2x_Octo_T',\n  'B_2x2F_Octo_Converter_Inv',\n  'B_2x2F_Octo_Converter',\n  'B_2x2F_Octo',\n  'B_8x8_Lattice_Plate',\n  'B_1x2_MetalIngot',\n  'B_1x1f_Tile_Corner',\n  'B_1x1f_Inverse_Tile_Corner',\n  'B_Rook',\n  'B_Queen',\n  'B_Pawn',\n  'B_Knight',\n  'B_King',\n  'B_Bishop',\n  'B_1x2f_Plate_Center',\n  'B_2x2_Cone',\n  'B_1x1_Round',\n  'B_1x1_Cone',\n  'B_1x1F_Round',\n  'B_2x_Octo_Cone',\n  'B_2x_Octo_90Deg_Inv',\n  'B_2x_Octo_90Deg',\n  'B_2x_Octo',\n  'B_1x_Octo_T_Inv',\n  'B_1x_Octo_T',\n  'B_1x_Octo_90Deg_Inv',\n  'B_1x_Octo_90Deg',\n  'B_1x_Octo',\n  'B_1x1F_Octo',\n  'B_2x2_Slipper',\n  'B_2x1_Slipper',\n  'B_Joint_Wheel_Micro',\n  'B_Joint_Wheel',\n  'B_Joint_Socket_Micro',\n  'B_Joint_Servo_Micro',\n  'B_Joint_Servo',\n  'B_Joint_Motor_Micro',\n  'B_Joint_Motor',\n  'B_Joint_Coupler',\n  'B_Joint_Bearing_Micro',\n  'B_Joint_Bearing',\n  'B_1x1_SoundEmitter',\n  'B_1x1_Gate_Teleport',\n  'B_1x1_Gate_RelativeTeleport',\n  'B_1x1_EntityGate_SetVelocity',\n  'B_1x1_EntityGate_SetLocationAndRotation',\n  'B_1x1_EntityGate_SetLocation',\n  'B_1x1_EntityGate_ReadBrickGrid',\n  'B_1x1_EntityGate_PlayAudioAt',\n  'B_1x1_EntityGate_AddVelocity',\n  'B_1x1_EntityGate_AddLocationAndRotation',\n  'B_1x1_CharacterGate_SetGravityDirection',\n  'B_Vehicle_Engine',\n  'B_Switch_Test',\n  'B_SpawnPoint',\n  'B_Seat',\n  'B_GoalPoint',\n  'B_DestinationPoint',\n  'B_CheckPoint',\n  'B_Button_Square',\n  'B_Button',\n  'B_Bot_Spawn_Point',\n  'B_2x2F_Target',\n  'B_2x2F_Speaker',\n  'B_1x1_Gate_WheelEngineSlim',\n  'B_1x1F_Speaker',\n];\n\nexport const PROCEDURAL_BRICK_ASSETS: readonly string[] = [\n  'PB_DefaultBrick',\n  'PB_DefaultStudded',\n  'PB_DefaultRampInnerCornerInverted',\n  'PB_DefaultRampCrestEnd',\n  'PB_DefaultRampCrestCorner',\n  'PB_DefaultRampCrest',\n  'PB_DefaultRamp',\n  'PB_PicketFence',\n  'BP_LatticeThin',\n  'PB_DefaultWedge',\n  'PB_DefaultTile',\n  'PB_DefaultSmoothTile',\n  'PB_DefaultSideWedge',\n  'PB_DefaultRampInverted',\n  'PB_DefaultRampInnerCorner',\n  'PB_DefaultRampCornerInverted',\n  'PB_DefaultRampCorner',\n  'PB_DefaultPole',\n  'PB_DefaultMicroWedgeTriangleCorner',\n  'PB_DefaultMicroWedgeOuterCorner',\n  'PB_DefaultMicroWedgeInnerCorner',\n  'PB_DefaultMicroWedgeHalfOuterCorner',\n  'PB_DefaultMicroWedgeHalfInnerCornerInverted',\n  'PB_DefaultMicroWedgeHalfInnerCorner',\n  'PB_DefaultMicroWedgeCorner',\n  'PB_DefaultMicroWedge',\n  'PB_DefaultMicroRamp',\n  'PB_DefaultMicroBrick',\n  'PB_DefaultArch',\n  'BP_SquarePlate',\n  'BP_SpikePlate',\n  'PB_Spike',\n  'PB_SliderJoint',\n  'PB_ServoSliderJoint',\n  'PB_MotorSliderJoint',\n  'BP_RoundPlate',\n  'PB_RoundedCap',\n  'PB_Baguette',\n];\n\nconst BASIC = new Set(BASIC_BRICK_ASSETS);\nconst PROCEDURAL = new Set(PROCEDURAL_BRICK_ASSETS);\n\n/** Classify a brick asset as procedural (parametric, carries a size) or basic. */\nexport function isProceduralAsset(name: string): boolean {\n  if (PROCEDURAL.has(name)) return true;\n  if (BASIC.has(name)) return false;\n  // Fallback for assets not in the catalog: PB_*/BP_* families are procedural.\n  return name.startsWith('PB_') || name.startsWith('BP_');\n}\n","// GENERATED by scripts/syncBrdbData.mjs — do not edit by hand.\n// Regenerate with: just sync-brdb-data\n\n/** Component type name -> data struct name (\"None\" = no data struct). */\nexport const COMPONENT_TYPE_STRUCTS: ReadonlyMap<string, string> = new Map([\n  [\n    'BrickComponentType_Internal_CharacterZoneEvent_Entered',\n    'BrickComponentData_Internal_CharacterZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_CharacterZoneEvent_Left',\n    'BrickComponentData_Internal_CharacterZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_EntityZoneEvent_Entered',\n    'BrickComponentData_Internal_EntityZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_EntityZoneEvent_Left',\n    'BrickComponentData_Internal_EntityZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_MicrochipInput',\n    'BrickComponentData_Internal_MicrochipInput',\n  ],\n  [\n    'BrickComponentType_Internal_MicrochipOutput',\n    'BrickComponentData_Internal_MicrochipOutput',\n  ],\n  [\n    'BrickComponentType_Internal_ProjectileZoneEvent_Entered',\n    'BrickComponentData_Internal_ProjectileZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_ProjectileZoneEvent_Left',\n    'BrickComponentData_Internal_ProjectileZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_ReadBrickGrid',\n    'BrickComponentData_Internal_ReadBrickGrid',\n  ],\n  [\n    'BrickComponentType_Internal_TeleportDestination',\n    'BrickComponentData_TeleportDestination',\n  ],\n  [\n    'BrickComponentType_Internal_ZoneEvent_BrickChanged',\n    'BrickComponentData_Internal_ZoneEvent',\n  ],\n  [\n    'BrickComponentType_Internal_ZoneEvent_BrickRemoved',\n    'BrickComponentData_Internal_ZoneEvent',\n  ],\n  ['BrickComponentType_PrefabSpawn', 'BrickComponentData_PrefabSpawn'],\n  [\n    'BrickComponentType_WireGraphPseudo_ArrayVar',\n    'BrickComponentData_WireGraphPseudo_ArrayVar',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_BufferSeconds',\n    'BrickComponentData_WireGraphPseudo_BufferSeconds',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_BufferTicks',\n    'BrickComponentData_WireGraphPseudo_BufferTicks',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_Dampen',\n    'BrickComponentData_WireGraphPseudo_Dampen',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_QueueSeconds',\n    'BrickComponentData_WireGraphPseudo_QueueSeconds',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_QueueTicks',\n    'BrickComponentData_WireGraphPseudo_QueueTicks',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_Timer',\n    'BrickComponentData_WireGraphPseudo_Timer',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_Tween',\n    'BrickComponentData_WireGraphPseudo_Tween',\n  ],\n  [\n    'BrickComponentType_WireGraphPseudo_Var',\n    'BrickComponentData_WireGraphPseudo_Var',\n  ],\n  [\n    'BrickComponentType_WireGraph_AudioReference',\n    'BrickComponentData_WireGraph_AudioReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_BrickAssetReference',\n    'BrickComponentData_WireGraph_BrickAssetReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_DeltaTime',\n    'BrickComponentData_WireGraph_DeltaTime',\n  ],\n  [\n    'BrickComponentType_WireGraph_EntityTypeReference',\n    'BrickComponentData_WireGraph_EntityTypeReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Append',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_DualRef',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Average',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Average',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Clear',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Base',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_CopyFrom',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_DualRef',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Fill',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Push',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Find',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Find',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Get',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Get',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_GetLength',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_GetLength',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Insert',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Insert',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Max',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_MinMax',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Min',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_MinMax',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Pop',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Pop',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Push',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Push',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_RemoveAtIndex',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_RemoveAtIndex',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Resize',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Resize',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Reverse',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Base',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_SetAtIndex',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_ElementOp',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Shuffle',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Base',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Slice',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Slice',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Sort',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Sort',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Sum',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Sum',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ArrayVar_Swap',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Swap',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Branch',\n    'BrickComponentData_WireGraph_ExecBranch',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_AddInventoryBrick',\n    'BrickComponentData_WireGraph_Exec_Character_AddInventoryBrick',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_AddInventoryEntity',\n    'BrickComponentData_WireGraph_Exec_Character_AddInventoryEntity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_AddInventoryEntry',\n    'BrickComponentData_WireGraph_Exec_Character_AddInventoryEntry',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_AddInventoryItem',\n    'BrickComponentData_WireGraph_Exec_Character_AddInventoryItem',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_GetAim',\n    'BrickComponentData_WireGraph_Exec_Character_GetAim',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_GetDamage',\n    'BrickComponentData_WireGraph_Exec_Character_GetDamage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_GetFromController',\n    'BrickComponentData_WireGraph_Exec_Character_GetFromController',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_IncDamage',\n    'BrickComponentData_WireGraph_Exec_Character_IncDamage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetDamage',\n    'BrickComponentData_WireGraph_Exec_Character_SetDamage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetInventoryBrick',\n    'BrickComponentData_WireGraph_Exec_Character_SetInventoryBrick',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetInventoryEntity',\n    'BrickComponentData_WireGraph_Exec_Character_SetInventoryEntity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetInventoryEntry',\n    'BrickComponentData_WireGraph_Exec_Character_SetInventoryEntry',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetInventoryItem',\n    'BrickComponentData_WireGraph_Exec_Character_SetInventoryItem',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_SetTempPermission',\n    'BrickComponentData_WireGraph_Exec_Character_SetTempPermission',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Character_ShowHint',\n    'BrickComponentData_WireGraph_Exec_Character_ShowHint',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_ChatCommand',\n    'BrickComponentData_WireGraph_Exec_ChatCommand',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_DisplayText',\n    'BrickComponentData_WireGraph_Exec_Controller_DisplayText',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_GetDisplayName',\n    'BrickComponentData_WireGraph_Exec_Controller_GetDisplayName',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_GetFromEntity',\n    'BrickComponentData_WireGraph_Exec_Controller_GetFromEntity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_GetUserId',\n    'BrickComponentData_WireGraph_Exec_Controller_GetUserId',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_GetUserName',\n    'BrickComponentData_WireGraph_Exec_Controller_GetUserName',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_HasPermission',\n    'BrickComponentData_WireGraph_Exec_Controller_HasPermission',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_HasRole',\n    'BrickComponentData_WireGraph_Exec_Controller_HasRole',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_IsTrustedByBrickOwner',\n    'BrickComponentData_WireGraph_Exec_Controller_IsTrustedByBrickOwner',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_SetCanRespawn',\n    'BrickComponentData_WireGraph_Exec_Controller_SetCanRespawn',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_ShowChatMessage',\n    'BrickComponentData_WireGraph_Exec_Controller_ShowChatMessage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Controller_ShowStatusMessage',\n    'BrickComponentData_WireGraph_Exec_Controller_ShowStatusMessage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Cycle',\n    'BrickComponentData_WireGraph_Exec_Cycle',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_AddLocationRotation',\n    'BrickComponentData_WireGraph_Exec_Entity_AddLocationRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_AddVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_AddVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetAngularVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_GetAngularVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetLinearVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_GetLinearVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetLocation',\n    'BrickComponentData_WireGraph_Exec_Entity_GetLocation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetLocationRotation',\n    'BrickComponentData_WireGraph_Exec_Entity_GetLocationRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetRotation',\n    'BrickComponentData_WireGraph_Exec_Entity_GetRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetTag',\n    'BrickComponentData_WireGraph_Exec_Entity_GetTag',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_GetVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_GetVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_RelativeTeleport',\n    'BrickComponentData_WireGraph_Exec_Entity_RelativeTeleport',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetAngularVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_SetAngularVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetFrozen',\n    'BrickComponentData_WireGraph_Exec_Entity_SetFrozen',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetGravityDirection',\n    'BrickComponentData_WireGraph_Exec_Entity_SetGravityDirection',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetLinearVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_SetLinearVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetLocation',\n    'BrickComponentData_WireGraph_Exec_Entity_SetLocation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetLocationRotation',\n    'BrickComponentData_WireGraph_Exec_Entity_SetLocationRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetRotation',\n    'BrickComponentData_WireGraph_Exec_Entity_SetRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetTag',\n    'BrickComponentData_WireGraph_Exec_Entity_SetTag',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_SetVelocity',\n    'BrickComponentData_WireGraph_Exec_Entity_SetVelocity',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Entity_Teleport',\n    'BrickComponentData_WireGraph_Exec_Entity_Teleport',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_BroadcastChatMessage',\n    'BrickComponentData_WireGraph_Exec_Gamemode_BroadcastChatMessage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_BroadcastStatusMessage',\n    'BrickComponentData_WireGraph_Exec_Gamemode_BroadcastStatusMessage',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_FillArrayFromPlayers',\n    'BrickComponentData_WireGraph_Exec_ArrayVar_Base',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers',\n    'BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetCurrentRound',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetCurrentRound',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetLeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetTeam',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetTeam',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetTeamByName',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetTeamByName',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_GetTeamName',\n    'BrickComponentData_WireGraph_Exec_Gamemode_GetTeamName',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_IncrementLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_IncrementTeamLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_PlayerWins',\n    'BrickComponentData_WireGraph_Exec_Gamemode_PlayerWins',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_SetLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_SetTeam',\n    'BrickComponentData_WireGraph_Exec_Gamemode_SetTeam',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_SetTeamLeaderboardValue',\n    'BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_SetTeamPinned',\n    'BrickComponentData_WireGraph_Exec_Gamemode_SetTeamPinned',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Gamemode_TeamWins',\n    'BrickComponentData_WireGraph_Exec_Gamemode_TeamWins',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_PlayGlobalAudio',\n    'BrickComponentData_WireGraph_Exec_PlayGlobalAudio',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_PrefabSpawner',\n    'BrickComponentData_WireGraph_Exec_PrefabSpawner',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_PrintToConsole',\n    'BrickComponentData_WireGraph_Exec_PrintToConsole',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Random',\n    'BrickComponentData_WireGraph_Exec_Random',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Sweep',\n    'BrickComponentData_WireGraph_Exec_Sweep',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Toggle',\n    'BrickComponentData_WireGraph_Exec_Toggle',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Union',\n    'BrickComponentData_WireGraph_ExecUnion',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Var_Get',\n    'BrickComponentData_WireGraph_Exec_Var_Get',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Var_Increment',\n    'BrickComponentData_WireGraph_Exec_Var_EditOrGet',\n  ],\n  [\n    'BrickComponentType_WireGraph_Exec_Var_Set',\n    'BrickComponentData_WireGraph_Exec_Var_EditOrGet',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseAND',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseBitCount',\n    'BrickComponentData_WireGraph_Expr_Int_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseNAND',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseNOR',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseNOT',\n    'BrickComponentData_WireGraph_Expr_Int_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseOR',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseShiftLeft',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseShiftRight',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_BitwiseXOR',\n    'BrickComponentData_WireGraph_Expr_IntInt_Int',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Ceil',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_ColorBlend',\n    'BrickComponentData_WireGraph_Expr_ColorBlend',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_ColorConvert',\n    'BrickComponentData_WireGraph_Expr_ColorConvert',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_ColorToHex',\n    'BrickComponentData_WireGraph_Expr_ColorToHex',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareEqual',\n    'BrickComponentData_WireGraph_Expr_Compare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareGreater',\n    'BrickComponentData_WireGraph_Expr_MathCompare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareGreaterOrEqual',\n    'BrickComponentData_WireGraph_Expr_MathCompare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareLess',\n    'BrickComponentData_WireGraph_Expr_MathCompare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareLessOrEqual',\n    'BrickComponentData_WireGraph_Expr_MathCompare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_CompareNotEqual',\n    'BrickComponentData_WireGraph_Expr_Compare',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Convert',\n    'BrickComponentData_WireGraph_Expr_Convert',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_DirectionToRotation',\n    'BrickComponentData_WireGraph_Expr_DirectionToRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_EdgeDetector',\n    'BrickComponentData_WireGraph_Expr_EdgeDetector',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Floor',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_InvertRotation',\n    'BrickComponentData_WireGraph_Expr_InvertRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalAND',\n    'BrickComponentData_WireGraph_Expr_BoolBool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalNAND',\n    'BrickComponentData_WireGraph_Expr_BoolBool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalNOR',\n    'BrickComponentData_WireGraph_Expr_BoolBool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalNOT',\n    'BrickComponentData_WireGraph_Expr_Bool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalOR',\n    'BrickComponentData_WireGraph_Expr_BoolBool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_LogicalXOR',\n    'BrickComponentData_WireGraph_Expr_BoolBool_Bool',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeColor',\n    'BrickComponentData_WireGraph_Expr_MakeColor',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeColorHex',\n    'BrickComponentData_WireGraph_Expr_MakeColorHex',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeColorSRGB',\n    'BrickComponentData_WireGraph_Expr_MakeColorSRGB',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeQuaternion',\n    'BrickComponentData_WireGraph_Expr_MakeQuaternion',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeRotation',\n    'BrickComponentData_WireGraph_Expr_MakeRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MakeVector',\n    'BrickComponentData_WireGraph_Expr_MakeVector',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAbs',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAcos',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAcosh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAdd',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAsin',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAsinh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAtan',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAtan2',\n    'BrickComponentData_WireGraph_Expr_MathAtan2',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathAtanh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathBlend',\n    'BrickComponentData_WireGraph_Expr_MathBlend',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathClamp',\n    'BrickComponentData_WireGraph_Expr_MathClamp',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathCos',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathCosh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathDegreesToRadians',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathDivide',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathEasing',\n    'BrickComponentData_WireGraph_Expr_MathEasing',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathExp',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathLn',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathLogBase',\n    'BrickComponentData_WireGraph_Expr_MathLogBase',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathMax',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathMin',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathModulo',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathModuloFloored',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathMultiply',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathNegate',\n    'BrickComponentData_WireGraph_Expr_Variant_Variant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathPow',\n    'BrickComponentData_WireGraph_Expr_MathPow',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathRadiansToDegrees',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathSign',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathSin',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathSinh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathSqrt',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathSubtract',\n    'BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathTan',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_MathTanh',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_NearlyEqual',\n    'BrickComponentData_WireGraph_Expr_NearlyEqual',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatAngleBetween',\n    'BrickComponentData_WireGraph_Expr_QuatAngleBetween',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatBetween',\n    'BrickComponentData_WireGraph_Expr_QuatBetween',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatDotProduct',\n    'BrickComponentData_WireGraph_Expr_QuatDotProduct',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatFromAxisAngle',\n    'BrickComponentData_WireGraph_Expr_QuatFromAxisAngle',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatSlerp',\n    'BrickComponentData_WireGraph_Expr_QuatSlerp',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_QuatToAxisAngle',\n    'BrickComponentData_WireGraph_Expr_QuatToAxisAngle',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_RotateVector',\n    'BrickComponentData_WireGraph_Expr_RotateVector',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_RotationToDirection',\n    'BrickComponentData_WireGraph_Expr_RotationToDirection',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Round',\n    'BrickComponentData_WireGraph_Expr_Float_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Select',\n    'BrickComponentData_WireGraph_Expr_Select',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_SplitColor',\n    'BrickComponentData_WireGraph_Expr_SplitColor',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_SplitColorSRGB',\n    'BrickComponentData_WireGraph_Expr_SplitColorSRGB',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_SplitQuaternion',\n    'BrickComponentData_WireGraph_Expr_SplitQuaternion',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_SplitRotation',\n    'BrickComponentData_WireGraph_Expr_SplitRotation',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_SplitVector',\n    'BrickComponentData_WireGraph_Expr_SplitVector',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Concatenate',\n    'BrickComponentData_WireGraph_Expr_String_Concatenate',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Contains',\n    'BrickComponentData_WireGraph_Expr_String_Contains',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_EndsWith',\n    'BrickComponentData_WireGraph_Expr_String_EndsWith',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Find',\n    'BrickComponentData_WireGraph_Expr_String_Find',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_FormatText',\n    'BrickComponentData_WireGraph_Expr_String_FormatText',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Length',\n    'BrickComponentData_WireGraph_Expr_String_Length',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_ParseInt',\n    'BrickComponentData_WireGraph_Expr_String_ParseInt',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_ParseNumber',\n    'BrickComponentData_WireGraph_Expr_String_ParseNumber',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Replace',\n    'BrickComponentData_WireGraph_Expr_String_Replace',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Split',\n    'BrickComponentData_WireGraph_Expr_String_Split',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_StartsWith',\n    'BrickComponentData_WireGraph_Expr_String_StartsWith',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Substring',\n    'BrickComponentData_WireGraph_Expr_String_Substring',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_ToLower',\n    'BrickComponentData_WireGraph_Expr_String_ToLower',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_ToUpper',\n    'BrickComponentData_WireGraph_Expr_String_ToUpper',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_String_Trim',\n    'BrickComponentData_WireGraph_Expr_String_Trim',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_Swap',\n    'BrickComponentData_WireGraph_Expr_Swap',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecCrossProduct',\n    'BrickComponentData_WireGraph_Expr_VecVec_Vec',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecDistance',\n    'BrickComponentData_WireGraph_Expr_VecVec_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecDistanceSquared',\n    'BrickComponentData_WireGraph_Expr_VecVec_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecDotProduct',\n    'BrickComponentData_WireGraph_Expr_VecVec_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecMagnitude',\n    'BrickComponentData_WireGraph_Expr_Vec_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecMagnitudeSquared',\n    'BrickComponentData_WireGraph_Expr_Vec_Float',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecNormalize',\n    'BrickComponentData_WireGraph_Expr_Vec_Vec',\n  ],\n  [\n    'BrickComponentType_WireGraph_Expr_VecScale',\n    'BrickComponentData_WireGraph_Expr_VecFloat_Vec',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_CharacterDamagedEvent',\n    'BrickComponentData_WireGraph_Fake_CharacterDamageEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_CharacterDiedEvent',\n    'BrickComponentData_WireGraph_Fake_CharacterDeathEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_CharacterSpawnedEvent',\n    'BrickComponentData_WireGraph_Fake_CharacterEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_ControllerJoinedEvent',\n    'BrickComponentData_WireGraph_Fake_ControllerEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_ControllerLeftEvent',\n    'BrickComponentData_WireGraph_Fake_ControllerEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_RoundEndEvent',\n    'BrickComponentData_WireGraph_Fake_RoundEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_Fake_Gamemode_RoundStartEvent',\n    'BrickComponentData_WireGraph_Fake_RoundEvent',\n  ],\n  [\n    'BrickComponentType_WireGraph_FindPlayer',\n    'BrickComponentData_WireGraph_FindPlayer',\n  ],\n  [\n    'BrickComponentType_WireGraph_FontReference',\n    'BrickComponentData_WireGraph_FontReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_ItemReference',\n    'BrickComponentData_WireGraph_ItemReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_OneShotAudioReference',\n    'BrickComponentData_WireGraph_OneShotAudioReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_ParticleReference',\n    'BrickComponentData_WireGraph_ParticleReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_PickupReference',\n    'BrickComponentData_WireGraph_PickupReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_ProjectileReference',\n    'BrickComponentData_WireGraph_ProjectileReference',\n  ],\n  [\n    'BrickComponentType_WireGraph_ServerUptime',\n    'BrickComponentData_WireGraph_ServerUptime',\n  ],\n  [\n    'BrickComponentType_WireGraph_WheelEngineAudioReference',\n    'BrickComponentData_WireGraph_WheelEngineAudioReference',\n  ],\n  ['Component_AudioEmitter', 'BrickComponentData_AudioEmitter'],\n  ['Component_BotSpawn', 'BrickComponentData_BotSpawn'],\n  ['Component_BrickPropertyChanger', 'BrickComponentData_BrickPropertyChanger'],\n  ['Component_Button', 'BrickComponentData_Button'],\n  ['Component_CheckPoint', 'BrickComponentData_CheckPoint'],\n  ['Component_Damage', 'BrickComponentData_Damage'],\n  ['Component_Interact', 'BrickComponentData_Interact'],\n  ['Component_Internal_AnimatedButton', 'BrickComponentData_Button'],\n  ['Component_Internal_AnimatedPressurePlate', 'BrickComponentData_Touch'],\n  ['Component_Internal_AnimatedSwitch', 'BrickComponentData_Switch'],\n  [\n    'Component_Internal_AttachedZone',\n    'BrickComponentData_Internal_AttachedZone',\n  ],\n  ['Component_Internal_Bearing', 'BrickComponentData_Bearing'],\n  ['Component_Internal_Gyroscope', 'BrickComponentData_Gyroscope'],\n  [\n    'Component_Internal_InputSplitter',\n    'BrickComponentData_Internal_InputSplitter_V2',\n  ],\n  ['Component_Internal_Joint_Wheel', 'BrickComponentData_Joint_Wheel'],\n  [\n    'Component_Internal_Joint_Wheel_Suspension',\n    'BrickComponentData_Joint_Wheel_Suspension',\n  ],\n  ['Component_Internal_Microchip', 'BrickComponentData_Internal_Microchip'],\n  ['Component_Internal_Motor', 'BrickComponentData_Motor'],\n  ['Component_Internal_MotorSlider', 'BrickComponentData_MotorSlider'],\n  [\n    'Component_Internal_ProjectileSpawner_Cannon',\n    'BrickComponentData_ProjectileSpawner',\n  ],\n  ['Component_Internal_Rerouter', 'BrickComponentData_Rerouter'],\n  ['Component_Internal_RigidBearing', 'BrickComponentData_RigidBearing'],\n  ['Component_Internal_RigidSlider', 'BrickComponentData_RigidSlider'],\n  ['Component_Internal_Seat', 'BrickComponentData_Seat_V2'],\n  ['Component_Internal_Servo', 'BrickComponentData_Servo'],\n  ['Component_Internal_ServoSlider', 'BrickComponentData_ServoSlider'],\n  ['Component_Internal_Slider', 'BrickComponentData_Slider'],\n  ['Component_Internal_Thruster', 'BrickComponentData_Thruster'],\n  ['Component_Internal_WeightBrick', 'BrickComponentData_WeightBrick'],\n  ['Component_Internal_WheelEngine', 'BrickComponentData_WheelEngine_V2'],\n  ['Component_ItemSpawn', 'BrickComponentData_ItemSpawn'],\n  ['Component_OneShotAudioEmitter', 'BrickComponentData_OneShotAudioEmitter'],\n  ['Component_PointLight', 'BrickComponentData_PointLight'],\n  ['Component_ProjectileSpawner', 'BrickComponentData_ProjectileSpawner'],\n  ['Component_SpawnPoint', 'BrickComponentData_SpawnPoint'],\n  ['Component_SpotLight', 'BrickComponentData_SpotLight'],\n  ['Component_Switch', 'BrickComponentData_Switch'],\n  ['Component_Target', 'BrickComponentData_Target'],\n  ['Component_TextDisplay', 'BrickComponentData_TextDisplay'],\n  ['Component_Touch', 'BrickComponentData_Touch'],\n  [\n    'Component_WireGraph_PlayAudioAt',\n    'BrickComponentData_WireGraph_Exec_Entity_PlayAudioAt',\n  ],\n]);\n\n/** Known wire port names (a save's port registry is built from the ports\n * its wires actually use, but names must come from this vocabulary). */\nexport const WIRE_PORT_NAMES: readonly string[] = [\n  'A',\n  'ActiveDamping',\n  'AdditionalIgnoredEntities',\n  'AggroRange',\n  'Agression',\n  'Alpha',\n  'Amount',\n  'Anchor',\n  'Anchor.X',\n  'Anchor.Y',\n  'AnchorX',\n  'AnchorY',\n  'Angle',\n  'AngularVelocity',\n  'AngularVelocity.X',\n  'AngularVelocity.Y',\n  'AngularVelocity.Z',\n  'Arguments',\n  'ArrayVarRef',\n  'Arrived',\n  'AttackDamageMultiplier',\n  'AttackMovementAmount',\n  'Attacker',\n  'AttackerWeapon',\n  'AttackerWeaponName',\n  'AudioDescriptor',\n  'Axis',\n  'Axis.X',\n  'Axis.Y',\n  'Axis.Z',\n  'B',\n  'Base',\n  'BeginTouchSound',\n  'Billboard',\n  'Blend',\n  'BotName',\n  'BotWeapon',\n  'BrickAsset',\n  'BrickGrid',\n  'Brightness',\n  'CenterOfSteering',\n  'Character',\n  'CharacterThatJustHit',\n  'Color',\n  'Color.A',\n  'Color.B',\n  'Color.G',\n  'Color.R',\n  'ColorA',\n  'ColorA.A',\n  'ColorA.B',\n  'ColorA.G',\n  'ColorA.R',\n  'ColorB',\n  'ColorB.A',\n  'ColorB.B',\n  'ColorB.G',\n  'ColorB.R',\n  'ConsoleTag',\n  'Control_DriveAndSteer',\n  'Controller',\n  'CorpseTimeout',\n  'Count',\n  'CurrentAngle',\n  'CurrentPosition',\n  'CustomMass',\n  'CustomMassVerticalOffset',\n  'Damage',\n  'DamageLimit',\n  'DamageMultiplier',\n  'Damping',\n  'DataIn1',\n  'DataIn2',\n  'DataIn3',\n  'DataIn4',\n  'DataIn5',\n  'DataIn6',\n  'DataIn7',\n  'DataIn8',\n  'DataOut1',\n  'DataOut2',\n  'DataOut3',\n  'DataOut4',\n  'DataOut5',\n  'DataOut6',\n  'DataOut7',\n  'DataOut8',\n  'Delimiter',\n  'DeltaTime',\n  'Destination',\n  'DestroyAll',\n  'Direction',\n  'Direction.X',\n  'Direction.Y',\n  'Direction.Z',\n  'DisplayName',\n  'Distance',\n  'DistanceToTarget',\n  'DriveAcceleratingPowerMultiplier',\n  'DriveBrakingPowerMultiplier',\n  'DriveDampingMultiplier',\n  'DriveInterpSpeed',\n  'DrivePower',\n  'DriveSpeed',\n  'Duration',\n  'EndTouchSound',\n  'Entity',\n  'EntityType',\n  'Exec',\n  'ExecA',\n  'ExecB',\n  'ExecDown',\n  'ExecIn',\n  'ExecOut',\n  'ExecOutA',\n  'ExecOutB',\n  'ExecOutDown',\n  'ExitOffset',\n  'ExitOffset.X',\n  'ExitOffset.Y',\n  'ExitOffset.Z',\n  'Expired',\n  'Exponent',\n  'Face',\n  'FireRate',\n  'FireSound',\n  'FocusAzimuth',\n  'FocusCharacter',\n  'Font',\n  'FontColor',\n  'FontColor.A',\n  'FontColor.B',\n  'FontColor.G',\n  'FontColor.R',\n  'Force',\n  'ForceLimit',\n  'FormatString',\n  'From',\n  'From.X',\n  'From.Y',\n  'From.Z',\n  'Function',\n  'G',\n  'GraffitiAngleLimit',\n  'GraffitiDepthLimit',\n  'GraffitiLayer',\n  'GunSkill',\n  'HealthMultiplier',\n  'Hex',\n  'Hit',\n  'HitDistance',\n  'HitEntity',\n  'HitLocation',\n  'HitNormal',\n  'IgnoreEntity',\n  'Index',\n  'IndexA',\n  'IndexB',\n  'InnerConeAngle',\n  'InnerRadius',\n  'Input',\n  'Input.A',\n  'Input.B',\n  'Input.G',\n  'Input.Pitch',\n  'Input.R',\n  'Input.Roll',\n  'Input.W',\n  'Input.X',\n  'Input.Y',\n  'Input.Yaw',\n  'Input.Z',\n  'InputA',\n  'InputA.W',\n  'InputA.X',\n  'InputA.Y',\n  'InputA.Z',\n  'InputB',\n  'InputB.W',\n  'InputB.X',\n  'InputB.Y',\n  'InputB.Z',\n  'InputC',\n  'InputD',\n  'InputE',\n  'InputF',\n  'InputForward',\n  'InputG',\n  'InputRight',\n  'Instigator',\n  'InteractSound',\n  'InterpMode',\n  'Item',\n  'ItemNameOverride',\n  'JointDistance',\n  'Jumpyness',\n  'Kerning',\n  'Key',\n  'Killer',\n  'KillerWeapon',\n  'KillerWeaponName',\n  'Left',\n  'Length',\n  'Lifetime',\n  'Limit',\n  'LimitAngle',\n  'LineHeight',\n  'LineOffset',\n  'LinearVelocity',\n  'LinearVelocity.X',\n  'LinearVelocity.Y',\n  'LinearVelocity.Z',\n  'ManualInput_Drive',\n  'ManualInput_Steer',\n  'Mass',\n  'MassOffset',\n  'MassOffset.X',\n  'MassOffset.Y',\n  'MassOffset.Z',\n  'MassSize',\n  'MassSize.X',\n  'MassSize.Y',\n  'MassSize.Z',\n  'Material',\n  'MaterialAlpha',\n  'MaterialSlider',\n  'Max',\n  'MaxDistance',\n  'MaxForce',\n  'Message',\n  'Min',\n  'Miss',\n  'MoveTarget',\n  'MoveTarget.X',\n  'MoveTarget.Y',\n  'MoveTarget.Z',\n  'MovementAmount',\n  'MovementGoalDummy',\n  'MovementRandomness',\n  'Name',\n  'NonFocusAzimuth',\n  'NonFocusVolumeAttenuation',\n  'NumberOfShots',\n  'OccupantCount',\n  'Offset',\n  'Offset.X',\n  'Offset.Y',\n  'Offset.Z',\n  'OnFired',\n  'OnTime',\n  'Origin',\n  'Origin.X',\n  'Origin.Y',\n  'Origin.Z',\n  'OuterConeAngle',\n  'Outline',\n  'OutlineColor',\n  'OutlineColor.A',\n  'OutlineColor.B',\n  'OutlineColor.G',\n  'OutlineColor.R',\n  'OutlineSize',\n  'OutlineWidth',\n  'Output',\n  'OutputB',\n  'Pause',\n  'PickupAnimationAxis',\n  'PickupAnimationPhase',\n  'PickupBobHeight',\n  'PickupBobSpeed',\n  'PickupClass',\n  'PickupMeshColors',\n  'PickupMinigameResetRespawnDelay',\n  'PickupOffsetDirection',\n  'PickupOffsetDistance',\n  'PickupRespawnTime',\n  'PickupRotation',\n  'PickupRotation.Pitch',\n  'PickupRotation.Roll',\n  'PickupRotation.Yaw',\n  'PickupScale',\n  'PickupSpinSpeed',\n  'Pitch',\n  'PitchMultiplier',\n  'Play',\n  'Player',\n  'PositionX',\n  'PositionY',\n  'Power',\n  'Prefab',\n  'Prefab.Path',\n  'Prefix',\n  'PressCount',\n  'PressSound',\n  'ProceduralSize',\n  'ProceduralSize.X',\n  'ProceduralSize.Y',\n  'ProceduralSize.Z',\n  'Projectile',\n  'ProjectileClass',\n  'ProjectileOverride',\n  'PromptCustomLabel',\n  'Query',\n  'R',\n  'RER_Input',\n  'RER_Output',\n  'Radius',\n  'ReactionTime',\n  'ReleaseSound',\n  'RepeatCount',\n  'RepeatDelay',\n  'RepeatTime',\n  'RepeatVariance',\n  'Replacement',\n  'RespawnTime',\n  'Restart',\n  'Resume',\n  'Right',\n  'Roll',\n  'Rotation',\n  'Rotation.Pitch',\n  'Rotation.Roll',\n  'Rotation.W',\n  'Rotation.X',\n  'Rotation.Y',\n  'Rotation.Yaw',\n  'Rotation.Z',\n  'RoundNumber',\n  'RunSpeed',\n  'Scalar',\n  'ScaleMultiplier',\n  'ScaleX',\n  'ScaleY',\n  'ScuffWidth',\n  'Search',\n  'SecondsToWait',\n  'Separator',\n  'Shading',\n  'ShadingWidth',\n  'SittingCharacter',\n  'Size',\n  'Skew',\n  'Skin',\n  'Skin.Parts',\n  'Slot',\n  'SmoothTime',\n  'Source',\n  'SourceRef',\n  'SpawnLocation',\n  'SpawnMargin',\n  'SpawnOffset',\n  'SpawnOffset.X',\n  'SpawnOffset.Y',\n  'SpawnOffset.Z',\n  'SpawnOffsetRotation',\n  'SpawnOffsetRotation.Pitch',\n  'SpawnOffsetRotation.Roll',\n  'SpawnOffsetRotation.Yaw',\n  'SpawnVelocity',\n  'SpawnVelocity.X',\n  'SpawnVelocity.Y',\n  'SpawnVelocity.Z',\n  'SpawnedCharacter',\n  'SpawnedEntity',\n  'Speed',\n  'SpeedMultiplier',\n  'SpreadConeAngle',\n  'Start',\n  'Steer',\n  'SteerInterpSpeed',\n  'SteerLimitDegree',\n  'SteerLimitSpeedFalloff',\n  'SteerPower',\n  'SteerPowerMultiplier',\n  'Stop',\n  'Strength',\n  'Suffix',\n  'SuspensionDamping',\n  'SuspensionLength',\n  'SuspensionOffset',\n  'SuspensionStiffness',\n  'Tag',\n  'TagFilter',\n  'TankSteerSpeedMultiplier',\n  'Target',\n  'TargetAngle',\n  'TargetAxis',\n  'TargetAxis.X',\n  'TargetAxis.Y',\n  'TargetAxis.Z',\n  'TargetPosition',\n  'Team',\n  'TeamCollisionChannel',\n  'TeamName',\n  'Text',\n  'TextId',\n  'TextIdOut',\n  'ThisDestination',\n  'Throttle',\n  'TicksToWait',\n  'Time',\n  'To',\n  'To.X',\n  'To.Y',\n  'To.Z',\n  'Tolerance',\n  'TopSpeed',\n  'TouchCount',\n  'Transition',\n  'Typeface',\n  'Uptime',\n  'UserId',\n  'UserName',\n  'Value',\n  'VarRef',\n  'Vector',\n  'Vector.X',\n  'Vector.Y',\n  'Vector.Z',\n  'VolumeMultiplier',\n  'W',\n  'WaterDriveForce',\n  'WaterSteeringForce',\n  'Weapon',\n  'WeaponName',\n  'WeaponNameThatJustHit',\n  'WeaponSpeedMultiplier',\n  'WeaponThatJustHit',\n  'WheelFrictionMultiplier',\n  'X',\n  'Y',\n  'Yaw',\n  'Z',\n  'ZeroSecondsToWait',\n  'ZeroTicksToWait',\n  'Zone',\n  'ZoneEndDistance',\n  'ZoneRef',\n  'ZoneStartDistance',\n  'bActiveBot',\n  'bAlignToWedge',\n  'bAllowEngineSteerCorrect',\n  'bAllowNearbyInteraction',\n  'bAnglesArePercentages',\n  'bAutoRight',\n  'bBackVision',\n  'bCanBrake',\n  'bCanJump',\n  'bCanRespawn',\n  'bCanTargetBots',\n  'bCanTargetPlayers',\n  'bCaseSensitive',\n  'bCastShadows',\n  'bCollisionEnabled',\n  'bCollisionEnabled_Interaction',\n  'bCollisionEnabled_Physics',\n  'bCollisionEnabled_Player',\n  'bCollisionEnabled_Player1',\n  'bCollisionEnabled_Player2',\n  'bCollisionEnabled_Player3',\n  'bCollisionEnabled_Weapon',\n  'bCond',\n  'bDeleteBot',\n  'bDescending',\n  'bDetectBricks',\n  'bDetectEntities',\n  'bDetectMap',\n  'bDetectPhysics',\n  'bDetectPlayers',\n  'bDetectPlayers1',\n  'bDetectPlayers2',\n  'bDetectPlayers3',\n  'bDetectPlayers4',\n  'bDetectProjectiles',\n  'bDriveWhenNotAttachedToEngine',\n  'bEnable',\n  'bEnableManualControl',\n  'bEnableRepeat',\n  'bEnabled',\n  'bFlashIfUnchanged',\n  'bFlipShading',\n  'bForeground',\n  'bFound',\n  'bFrozen',\n  'bHasPermission',\n  'bHasRole',\n  'bHeld',\n  'bHiddenInteraction',\n  'bIgnoreOwningGrid',\n  'bInput',\n  'bInputA',\n  'bInputB',\n  'bIsBuildingZone',\n  'bIsEmpty',\n  'bIsLooseZone',\n  'bIsOccupied',\n  'bIsShareZone',\n  'bIsTrusted',\n  'bJustHit',\n  'bLimitAngle',\n  'bManualInput_Brake',\n  'bMatchBrickShape',\n  'bOccupied',\n  'bOutOfBounds',\n  'bOutput',\n  'bOverrideColor',\n  'bOverrideOutlineColor',\n  'bOverridePickupColors',\n  'bPermissionEnable',\n  'bPickupAnimationAxisLocal',\n  'bPickupAnimationEnabled',\n  'bPickupAutoDisableOnPickup',\n  'bPickupEnabled',\n  'bPickupRespawnOnMinigameReset',\n  'bPinPlayerToTeam',\n  'bPinned',\n  'bPositionsArePercentages',\n  'bPressedJump',\n  'bPulseOnFallingEdge',\n  'bPulseOnRisingEdge',\n  'bRelative',\n  'bRenderTranslucentWhenDisabled',\n  'bReversed',\n  'bRollCameraInThirdPerson',\n  'bRotatePlayerGravityOnSpawn',\n  'bSelectB',\n  'bSharpCorners',\n  'bSharpOutlines',\n  'bShowPickupEnabled',\n  'bSpatialization',\n  'bSpawnEnable',\n  'bSpawnLight',\n  'bSpreadBiasedTowardsCenter',\n  'bSteerEnabled',\n  'bStopped',\n  'bSuccess',\n  'bSuspensionEnabled',\n  'bSwap',\n  'bTankSteering',\n  'bTeamCollision',\n  'bTeamCollision1',\n  'bTeamCollision2',\n  'bTeamCollision3',\n  'bTeamWinsInstead',\n  'bTouching',\n  'bUseBrickColor',\n  'bVisibility',\n  'bVisionRaycasting',\n  'bWelded',\n];\n\n/** Entity type name -> data class name. */\nexport const ENTITY_TYPE_STRUCTS: ReadonlyMap<string, string> = new Map([\n  ['Entity_DynamicBrickGrid', 'BrickGridDynamicActor'],\n  ['Entity_MicrochipDynamicBrickGrid', 'BP_MicrochipBrickGridDynamicActor_C'],\n]);\n","// brdb Guids are four u32s (A,B,C,D) = the uuid's u128 split into\n// big-endian quarters. Flat-serialized as\n// BRGuid { A,B,C,D: u32 } with each u32 little-endian on disk — the\n// value walkers handle the LE part; this module only maps strings.\nimport { uuidParse, uuidStringify } from '../uuid';\n\nexport interface BrGuid {\n  A: number;\n  B: number;\n  C: number;\n  D: number;\n}\n\n/** Owner-table row 0 sentinel (the PUBLIC owner). */\nexport const PUBLIC_GUID: BrGuid = {\n  A: 0xffffffff,\n  B: 0xffffffff,\n  C: 0xffffffff,\n  D: 0xffffffff,\n};\n\nexport function uuidToGuid(uuid: string): BrGuid {\n  const bytes = uuidParse(uuid);\n  const view = new DataView(bytes.buffer, bytes.byteOffset, 16);\n  return {\n    A: view.getUint32(0, false),\n    B: view.getUint32(4, false),\n    C: view.getUint32(8, false),\n    D: view.getUint32(12, false),\n  };\n}\n\nexport function guidToUuid(guid: BrGuid): string {\n  const bytes = new Uint8Array(16);\n  const view = new DataView(bytes.buffer);\n  view.setUint32(0, guid.A, false);\n  view.setUint32(4, guid.B, false);\n  view.setUint32(8, guid.C, false);\n  view.setUint32(12, guid.D, false);\n  return uuidStringify(Array.from(bytes));\n}\n","// Pending virtual-filesystem tree: the interchange type between the world\n// serializer and the container writers.\n// Children are ordered; that order determines archive ids (BFS, Task 4).\nexport type PendingEntry = [name: string, node: PendingNode];\nexport type PendingNode =\n  | { type: 'folder'; children: PendingEntry[] }\n  | { type: 'file'; content: Uint8Array };\n\nexport const folder = (children: PendingEntry[]): PendingNode => ({\n  type: 'folder',\n  children,\n});\n\nexport const file = (content: Uint8Array): PendingNode => ({\n  type: 'file',\n  content,\n});\n","// msgpack primitives for the brdb msgpack-schema encoding. This is NOT standard\n// msgpack: see the u8 negative-fixint band and the float shrink predicates.\nimport { ByteReader, ByteWriter } from './bytes';\n\nconst utf8Encoder = new TextEncoder();\nconst utf8Decoder = new TextDecoder('utf-8', { fatal: true });\n\nconst checkSafe = (v: number, what: string) => {\n  if (!Number.isSafeInteger(v))\n    throw new RangeError(`brdb: ${what} ${v} is not a safe integer`);\n};\n\nexport const mpNil = (w: ByteWriter) => w.u8(0xc0);\nexport const mpBool = (w: ByteWriter, v: boolean) => w.u8(v ? 0xc3 : 0xc2);\n\n// The 'u8' schema type only. 0..=127 pfix; 225..=255 negative fixint\n// (0xe1..0xff); 128..=224 u8 marker.\nexport function mpU8(w: ByteWriter, v: number) {\n  if (v < 0 || v > 255 || !Number.isInteger(v))\n    throw new RangeError(`brdb: u8 value out of range: ${v}`);\n  if (v <= 127) w.u8(v);\n  // reinterpreted as negative fixint on the wire\n  else if (v > 224) w.u8(v);\n  else {\n    w.u8(0xcc);\n    w.u8(v);\n  }\n}\n\n// u16/u32/u64 schema types.\nexport function mpUint(w: ByteWriter, v: number) {\n  checkSafe(v, 'uint');\n  if (v < 0) throw new RangeError(`brdb: uint value negative: ${v}`);\n  if (v <= 127) w.u8(v);\n  else if (v <= 0xff) {\n    w.u8(0xcc);\n    w.u8(v);\n  } else if (v <= 0xffff) {\n    w.u8(0xcd);\n    w.u16be(v);\n  } else if (v <= 0xffffffff) {\n    w.u8(0xce);\n    w.u32be(v);\n  } else {\n    w.u8(0xcf);\n    w.u64be(BigInt(v));\n  }\n}\n\n// i8..i64 schema types. Positive values use SIGNED markers (never 0xcc+),\n// and positives 128..=32767 skip i8 and go straight to i16.\nexport function mpInt(w: ByteWriter, v: number) {\n  checkSafe(v, 'int');\n  if (v >= 0) {\n    if (v < 128) w.u8(v);\n    else if (v <= 32767) {\n      w.u8(0xd1);\n      w.i16be(v);\n    } else if (v <= 2147483647) {\n      w.u8(0xd2);\n      w.i32be(v);\n    } else {\n      w.u8(0xd3);\n      w.i64be(BigInt(v));\n    }\n  } else {\n    // negative fixint 0xe1..0xff\n    if (v > -32) w.u8(0x100 + v);\n    else if (v >= -128) {\n      w.u8(0xd0);\n      w.i8(v);\n    } else if (v >= -32768) {\n      w.u8(0xd1);\n      w.i16be(v);\n    } else if (v >= -2147483648) {\n      w.u8(0xd2);\n      w.i32be(v);\n    } else {\n      w.u8(0xd3);\n      w.i64be(BigInt(v));\n    }\n  }\n}\n\n// Whole f32 shrinks to int when (v as u16) < 65535 && (v as i16) > -32768.\n// With saturating casts this reduces to v < 65535 && v > -32768.\nexport function mpF32(w: ByteWriter, v: number) {\n  if (v === Math.round(v) && v < 65535 && v > -32768) mpInt(w, v === 0 ? 0 : v);\n  else {\n    w.u8(0xca);\n    w.f32be(v);\n  }\n}\n\n// Whole f64 shrinks when (v as u32) < 4294967295 && (v as i32) > -2147483648.\nexport function mpF64(w: ByteWriter, v: number) {\n  if (v === Math.round(v) && v < 4294967295 && v > -2147483648)\n    mpInt(w, v === 0 ? 0 : v);\n  else {\n    w.u8(0xcb);\n    w.f64be(v);\n  }\n}\n\nexport function mpStr(w: ByteWriter, s: string) {\n  const bytes = utf8Encoder.encode(s);\n  const len = bytes.length;\n  if (len < 32) w.u8(0xa0 | len);\n  else if (len < 256) {\n    w.u8(0xd9);\n    w.u8(len);\n  } else if (len <= 0xffff) {\n    w.u8(0xda);\n    w.u16be(len);\n  } else {\n    w.u8(0xdb);\n    w.u32be(len);\n  }\n  w.bytes(bytes);\n}\n\nexport function mpBinHeader(w: ByteWriter, len: number) {\n  if (len < 256) {\n    w.u8(0xc4);\n    w.u8(len);\n  } else if (len <= 0xffff) {\n    w.u8(0xc5);\n    w.u16be(len);\n  } else {\n    w.u8(0xc6);\n    w.u32be(len);\n  }\n}\n\nexport function mpArrayHeader(w: ByteWriter, len: number) {\n  if (len < 16) w.u8(0x90 | len);\n  else if (len <= 0xffff) {\n    w.u8(0xdc);\n    w.u16be(len);\n  } else {\n    w.u8(0xdd);\n    w.u32be(len);\n  }\n}\n\nexport function mpMapHeader(w: ByteWriter, len: number) {\n  if (len < 16) w.u8(0x80 | len);\n  else if (len <= 0xffff) {\n    w.u8(0xde);\n    w.u16be(len);\n  } else {\n    w.u8(0xdf);\n    w.u32be(len);\n  }\n}\n\n// ---- readers ----\n\nconst fromBigint = (v: bigint): number => {\n  if (\n    v > BigInt(Number.MAX_SAFE_INTEGER) ||\n    v < BigInt(Number.MIN_SAFE_INTEGER)\n  )\n    throw new RangeError(\n      `brdb: 64-bit value ${v} exceeds JS safe integer range`\n    );\n  return Number(v);\n};\n\nconst badMarker = (marker: number, expected: string): never => {\n  throw new TypeError(\n    `brdb: unexpected marker 0x${marker.toString(16)} for ${expected}`\n  );\n};\n\nconst isFixPos = (m: number) => (m & 0x80) === 0;\nconst isFixNeg = (m: number) => (m & 0xe0) === 0xe0;\n\n// Accepts every int marker, signed and unsigned.\nexport function rdInt(r: ByteReader): number {\n  const m = r.u8();\n  if (isFixPos(m)) return m;\n  if (isFixNeg(m)) return m - 256;\n  switch (m) {\n    case 0xcc:\n      return r.u8();\n    case 0xcd:\n      return r.u16be();\n    case 0xce:\n      return r.u32be();\n    case 0xcf:\n      return fromBigint(r.u64be());\n    case 0xd0:\n      return r.i8();\n    case 0xd1:\n      return r.i16be();\n    case 0xd2:\n      return r.i32be();\n    case 0xd3:\n      return fromBigint(r.i64be());\n    default:\n      return badMarker(m, 'integer');\n  }\n}\n\n// Negative fixint bytes are unsigned 224..255 in this format (256+v), and\n// an explicit I8 marker's payload is likewise reinterpreted as 0..255: the\n// game's encoder casts u8 to i8 before writing, so u8 values 128..=224\n// arrive as d0 XX in real saves (e.g. MaterialAlpha=128 is d0 80). The\n// reference decoder sign-extends the i8 to u64 and its u8 field cast\n// truncates back to the same byte.\nexport function rdUint(r: ByteReader): number {\n  const m = r.u8();\n  if (isFixPos(m)) return m;\n  if (isFixNeg(m)) return m; // 0xe0..0xff read back as 224..255\n  switch (m) {\n    case 0xcc:\n    case 0xd0:\n      return r.u8();\n    case 0xcd:\n      return r.u16be();\n    case 0xce:\n      return r.u32be();\n    case 0xcf:\n      return fromBigint(r.u64be());\n    default:\n      return badMarker(m, 'uint');\n  }\n}\n\n// f32 accepts FixPos/FixNeg/I8/I16/U8/U16/F32 only.\nexport function rdF32(r: ByteReader): number {\n  const m = r.u8();\n  if (isFixPos(m)) return m;\n  if (isFixNeg(m)) return m - 256;\n  switch (m) {\n    case 0xcc:\n      return r.u8();\n    case 0xcd:\n      return r.u16be();\n    case 0xd0:\n      return r.i8();\n    case 0xd1:\n      return r.i16be();\n    case 0xca:\n      return r.f32be();\n    default:\n      return badMarker(m, 'float32');\n  }\n}\n\n// f64 additionally accepts I32/U32/F32/F64.\nexport function rdF64(r: ByteReader): number {\n  const m = r.u8();\n  if (isFixPos(m)) return m;\n  if (isFixNeg(m)) return m - 256;\n  switch (m) {\n    case 0xcc:\n      return r.u8();\n    case 0xcd:\n      return r.u16be();\n    case 0xce:\n      return r.u32be();\n    case 0xd0:\n      return r.i8();\n    case 0xd1:\n      return r.i16be();\n    case 0xd2:\n      return r.i32be();\n    case 0xca:\n      return r.f32be();\n    case 0xcb:\n      return r.f64be();\n    default:\n      return badMarker(m, 'float64');\n  }\n}\n\nexport function rdBool(r: ByteReader): boolean {\n  const m = r.u8();\n  if (m === 0xc3) return true;\n  if (m === 0xc2) return false;\n  return badMarker(m, 'bool');\n}\n\nexport function rdStr(r: ByteReader): string {\n  const m = r.u8();\n  let len: number;\n  if ((m & 0xe0) === 0xa0) len = m & 0x1f;\n  else if (m === 0xd9) len = r.u8();\n  else if (m === 0xda) len = r.u16be();\n  else if (m === 0xdb) len = r.u32be();\n  else return badMarker(m, 'str');\n  return utf8Decoder.decode(r.bytes(len));\n}\n\nexport function rdBinLen(r: ByteReader): number {\n  const m = r.u8();\n  if (m === 0xc4) return r.u8();\n  if (m === 0xc5) return r.u16be();\n  if (m === 0xc6) return r.u32be();\n  return badMarker(m, 'bin');\n}\n\nexport function rdArrayLen(r: ByteReader): number {\n  const m = r.u8();\n  if ((m & 0xf0) === 0x90) return m & 0x0f;\n  if (m === 0xdc) return r.u16be();\n  if (m === 0xdd) return r.u32be();\n  return badMarker(m, 'array');\n}\n\nexport function rdMapLen(r: ByteReader): number {\n  const m = r.u8();\n  if ((m & 0xf0) === 0x80) return m & 0x0f;\n  if (m === 0xde) return r.u16be();\n  if (m === 0xdf) return r.u32be();\n  return badMarker(m, 'map');\n}\n\nexport function rdNil(r: ByteReader): void {\n  const m = r.u8();\n  if (m !== 0xc0) badMarker(m, 'nil');\n}\n","// Parser for the plaintext .schema sources: enum, variant, and struct\n// declarations. Enum keys are qualified (\"EFoo::Bar\"); enum values accept\n// decimal, 0b binary, and 0x hex literals with optional underscores.\nimport type { PropDesc } from './schema';\n\nexport interface SchemaData {\n  enums: Map<string, Map<string, number>>;\n  variants: Map<string, string[]>;\n  structs: Map<string, Map<string, PropDesc>>;\n}\n\nconst stripComments = (text: string): string =>\n  text\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, ' ')\n    .replace(/\\/\\/[^\\n]*/g, ' ')\n    .replace(/#[^\\n]*/g, ' ');\n\n// Identifier, optionally qualified: EBRColorSpace::Linear\nconst IDENT = String.raw`[A-Za-z_]\\w*(?:::\\w+)*`;\n\nfunction parseIntLiteral(raw: string): number {\n  const t = raw.replace(/_/g, '');\n  if (t.startsWith('0b')) return parseInt(t.slice(2), 2);\n  if (t.startsWith('0x')) return parseInt(t.slice(2), 16);\n  return parseInt(t, 10);\n}\n\nexport function parseSchemaText(text: string): SchemaData {\n  const src = stripComments(text);\n  const enums = new Map<string, Map<string, number>>();\n  const variants = new Map<string, string[]>();\n  const structs = new Map<string, Map<string, PropDesc>>();\n  const declRe = /\\b(enum|variant|struct)\\s+([A-Za-z0-9_]+)\\s*\\{([^{}]*)\\}/g;\n  const enumEntryRe = new RegExp(\n    String.raw`^(${IDENT})\\s*=\\s*(-?\\d+(?:_\\d+)*|0b[01]+(?:_[01]+)*|0x[0-9a-fA-F]+(?:_[0-9a-fA-F]+)*)$`\n  );\n  const memberRe = new RegExp(String.raw`^${IDENT}$`);\n  const propRe = new RegExp(\n    String.raw`^(\\w+)\\s*:\\s*(\\w+)\\s*(\\[\\s*(flat)?\\s*\\])?$`\n  );\n\n  let lastEnd = 0;\n  let match: RegExpExecArray | null;\n  while ((match = declRe.exec(src))) {\n    if (src.slice(lastEnd, match.index).trim() !== '')\n      throw new Error(`brdb: unexpected schema text before ${match[2]}`);\n    lastEnd = declRe.lastIndex;\n    const [, keyword, name, body] = match;\n    const items = body\n      .split(',')\n      .map(s => s.trim())\n      .filter(s => s !== '');\n\n    if (keyword === 'enum') {\n      const values = new Map<string, number>();\n      for (const item of items) {\n        const m = enumEntryRe.exec(item);\n        if (!m)\n          throw new Error(`brdb: cannot parse enum entry '${item}' in ${name}`);\n        values.set(m[1], parseIntLiteral(m[2]));\n      }\n      enums.set(name, values);\n    } else if (keyword === 'variant') {\n      const members: string[] = [];\n      for (const item of items) {\n        if (!memberRe.test(item))\n          throw new Error(\n            `brdb: cannot parse variant member '${item}' in ${name}`\n          );\n        members.push(item);\n      }\n      variants.set(name, members);\n    } else {\n      const props = new Map<string, PropDesc>();\n      for (const item of items) {\n        const m = propRe.exec(item);\n        if (!m)\n          throw new Error(\n            `brdb: cannot parse struct property '${item}' in ${name}`\n          );\n        const [, prop, ty, isArray, isFlat] = m;\n        props.set(\n          prop,\n          isArray\n            ? { kind: isFlat ? 'flatarray' : 'array', type: ty }\n            : { kind: 'type', type: ty }\n        );\n      }\n      structs.set(name, props);\n    }\n  }\n  if (src.slice(lastEnd).trim() !== '')\n    throw new Error('brdb: trailing unparsed schema text');\n  return { enums, variants, structs };\n}\n","// GENERATED by scripts/syncBrdbData.mjs — do not edit by hand.\n// Regenerate with: just sync-brdb-data\n\nimport type { SchemaSource } from './schema';\n\nexport type EmbeddedSchemaName =\n  | 'BRSavedGlobalDataSoA'\n  | 'BRSavedOwnerTableSoA'\n  | 'BRSavedBrickChunkIndexSoA'\n  | 'BRSavedBrickChunkSoA'\n  | 'BRSavedWireChunkSoA'\n  | 'BRSavedComponentChunkSoA'\n  | 'BRSavedComponentChunkSoA_max'\n  | 'BRSavedEntityChunkIndexSoA'\n  | 'BRSavedEntityChunkSoA';\n\nexport const SCHEMAS: Record<EmbeddedSchemaName, SchemaSource> = {\n  BRSavedGlobalDataSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedPrimaryAssetId: {\n        PrimaryAssetType: 'str',\n        PrimaryAssetName: 'str',\n      },\n      BRSavedGlobalDataSoA: {\n        EntityTypeNames: ['str'],\n        EntityDataClassNames: ['str'],\n        BasicBrickAssetNames: ['str'],\n        ProceduralBrickAssetNames: ['str'],\n        MaterialAssetNames: ['str'],\n        ComponentTypeNames: ['str'],\n        ComponentDataStructNames: ['str'],\n        ComponentWirePortNames: ['str'],\n        ExternalAssetReferences: ['BRSavedPrimaryAssetId'],\n        GlobalGridEntityTypeIndex: 'i32',\n      },\n    },\n  },\n  BRSavedOwnerTableSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRGuid: {\n        A: 'u32',\n        B: 'u32',\n        C: 'u32',\n        D: 'u32',\n      },\n      BRSavedOwnerTableSoA: {\n        UserIds: ['BRGuid', null],\n        UserNames: ['str'],\n        DisplayNames: ['str'],\n        EntityCounts: ['u32'],\n        BrickCounts: ['u32'],\n        ComponentCounts: ['u32'],\n        WireCounts: ['u32'],\n      },\n    },\n  },\n  BRSavedBrickChunkIndexSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedChunk3DIndex: {\n        X: 'i16',\n        Y: 'i16',\n        Z: 'i16',\n      },\n      IntVector: {\n        X: 'i32',\n        Y: 'i32',\n        Z: 'i32',\n      },\n      BRSavedBrickChunkIndexSoA: {\n        Chunk3DIndices: ['BRSavedChunk3DIndex'],\n        ChunkOffsets: ['IntVector'],\n        ChunkSizes: ['i32'],\n        NumBricks: ['u32'],\n        NumComponents: ['u32'],\n        NumWires: ['u32'],\n      },\n    },\n  },\n  BRSavedBrickChunkSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedBitFlags: {\n        Flags: ['u8', null],\n      },\n      BRSavedBrickColor: {\n        R: 'u8',\n        G: 'u8',\n        B: 'u8',\n        A: 'u8',\n      },\n      BRSavedBrickSize: {\n        X: 'u16',\n        Y: 'u16',\n        Z: 'u16',\n      },\n      BRSavedBrickSizeCounter: {\n        AssetIndex: 'u32',\n        NumSizes: 'u32',\n      },\n      BRSavedRelativeBrickPosition: {\n        X: 'i16',\n        Y: 'i16',\n        Z: 'i16',\n      },\n      BRSavedBrickChunkSoA: {\n        ProceduralBrickStartingIndex: 'u32',\n        BrickSizeCounters: ['BRSavedBrickSizeCounter'],\n        BrickSizes: ['BRSavedBrickSize'],\n        BrickTypeIndices: ['u32'],\n        OwnerIndices: ['u32'],\n        OriginalOwnerIndices: ['u32'],\n        RelativePositions: ['BRSavedRelativeBrickPosition', null],\n        Orientations: ['u8', null],\n        CollisionFlags_Player: 'BRSavedBitFlags',\n        CollisionFlags_Player1: 'BRSavedBitFlags',\n        CollisionFlags_Player2: 'BRSavedBitFlags',\n        CollisionFlags_Player3: 'BRSavedBitFlags',\n        CollisionFlags_Weapon: 'BRSavedBitFlags',\n        CollisionFlags_Interaction: 'BRSavedBitFlags',\n        CollisionFlags_Physics: 'BRSavedBitFlags',\n        VisibilityFlags: 'BRSavedBitFlags',\n        MaterialIndices: ['u8', null],\n        ColorsAndAlphas: ['BRSavedBrickColor', null],\n        bColorsAreLinear: 'bool',\n      },\n    },\n  },\n  BRSavedWireChunkSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedBitFlags: {\n        Flags: ['u8', null],\n      },\n      BRSavedChunk3DIndex: {\n        X: 'i16',\n        Y: 'i16',\n        Z: 'i16',\n      },\n      BRSavedLocalWirePortSource: {\n        BrickIndexInChunk: 'u32',\n        ComponentTypeIndex: 'u16',\n        PortIndex: 'u16',\n      },\n      BRSavedWirePortTarget: {\n        BrickIndexInChunk: 'u32',\n        ComponentTypeIndex: 'u16',\n        PortIndex: 'u16',\n      },\n      BRSavedRemoteWirePortSource: {\n        GridPersistentIndex: 'u32',\n        ChunkIndex: 'BRSavedChunk3DIndex',\n        BrickIndexInChunk: 'u32',\n        ComponentTypeIndex: 'u16',\n        PortIndex: 'u16',\n      },\n      BRSavedWireChunkSoA: {\n        RemoteWireSources: ['BRSavedRemoteWirePortSource'],\n        LocalWireSources: ['BRSavedLocalWirePortSource'],\n        RemoteWireTargets: ['BRSavedWirePortTarget'],\n        LocalWireTargets: ['BRSavedWirePortTarget'],\n        PendingPropagationFlags: 'BRSavedBitFlags',\n      },\n    },\n  },\n  BRSavedComponentChunkSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedBrickComponentTypeCounter: {\n        TypeIndex: 'u32',\n        NumInstances: 'u32',\n      },\n      Quat4f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n        W: 'f32',\n      },\n      Vector3f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n      },\n      BRSavedComponentChunkSoA: {\n        ComponentTypeCounters: ['BRSavedBrickComponentTypeCounter'],\n        ComponentBrickIndices: ['u32'],\n        JointBrickIndices: ['u32'],\n        JointEntityReferences: ['u32'],\n        JointInitialRelativeOffsets: ['Vector3f', null],\n        JointInitialRelativeRotations: ['Quat4f', null],\n        MicrochipBrickIndices: ['u32'],\n        MicrochipBrickGridReferences: ['u32'],\n      },\n    },\n  },\n  BRSavedComponentChunkSoA_max: {\n    enums: {\n      EBRColorSpace: {\n        'EBRColorSpace::Linear': 0,\n        'EBRColorSpace::Srgb': 1,\n        'EBRColorSpace::Oklab': 2,\n        'EBRColorSpace::Hsv': 3,\n        'EBRColorSpace::EBRColorSpace_MAX': 4,\n      },\n      EBRDisplayTextEasing: {\n        'EBRDisplayTextEasing::Linear': 0,\n        'EBRDisplayTextEasing::EaseIn': 1,\n        'EBRDisplayTextEasing::EaseOut': 2,\n        'EBRDisplayTextEasing::EaseInOut': 3,\n        'EBRDisplayTextEasing::EBRDisplayTextEasing_MAX': 4,\n      },\n      EBRDisplayTextJustification: {\n        'EBRDisplayTextJustification::Left': 0,\n        'EBRDisplayTextJustification::Center': 1,\n        'EBRDisplayTextJustification::Right': 2,\n        'EBRDisplayTextJustification::EBRDisplayTextJustification_MAX': 3,\n      },\n      EBREasingDirection: {\n        'EBREasingDirection::In': 0,\n        'EBREasingDirection::Out': 1,\n        'EBREasingDirection::InOut': 2,\n        'EBREasingDirection::EBREasingDirection_MAX': 3,\n      },\n      EBREasingFunction: {\n        'EBREasingFunction::Linear': 0,\n        'EBREasingFunction::Sine': 1,\n        'EBREasingFunction::Quad': 2,\n        'EBREasingFunction::Cubic': 3,\n        'EBREasingFunction::Quart': 4,\n        'EBREasingFunction::Quint': 5,\n        'EBREasingFunction::Expo': 6,\n        'EBREasingFunction::Circ': 7,\n        'EBREasingFunction::Back': 8,\n        'EBREasingFunction::Elastic': 9,\n        'EBREasingFunction::Bounce': 10,\n        'EBREasingFunction::EBREasingFunction_MAX': 11,\n      },\n      EBrickAxis: {\n        'EBrickAxis::X': 0,\n        'EBrickAxis::Y': 1,\n        'EBrickAxis::Z': 2,\n        'EBrickAxis::MAX': 3,\n      },\n      EBrickDirection: {\n        'EBrickDirection::X_Positive': 0,\n        'EBrickDirection::X_Negative': 1,\n        'EBrickDirection::Y_Positive': 2,\n        'EBrickDirection::Y_Negative': 3,\n        'EBrickDirection::Z_Positive': 4,\n        'EBrickDirection::Z_Negative': 5,\n        'EBrickDirection::MAX': 6,\n      },\n      EBrickMaterial: {\n        'EBrickMaterial::Plastic': 0,\n        'EBrickMaterial::Glass': 1,\n        'EBrickMaterial::TranslucentPlastic': 2,\n        'EBrickMaterial::Glow': 3,\n        'EBrickMaterial::Metal': 4,\n        'EBrickMaterial::Hologram': 5,\n        'EBrickMaterial::EBrickMaterial_MAX': 6,\n      },\n      EBrickRigidJointInterpMode: {\n        'EBrickRigidJointInterpMode::Snap': 0,\n        'EBrickRigidJointInterpMode::Linear': 1,\n        'EBrickRigidJointInterpMode::Smooth': 2,\n        'EBrickRigidJointInterpMode::EBrickRigidJointInterpMode_MAX': 3,\n      },\n      EBRInventoryEntryPlanType: {\n        'EBRInventoryEntryPlanType::Nothing': 0,\n        'EBRInventoryEntryPlanType::Brick': 1,\n        'EBRInventoryEntryPlanType::Entity': 2,\n        'EBRInventoryEntryPlanType::Item': 3,\n        'EBRInventoryEntryPlanType::EBRInventoryEntryPlanType_MAX': 4,\n      },\n      EBRPawnCollisionChannel: {\n        'EBRPawnCollisionChannel::Channel1': 0,\n        'EBRPawnCollisionChannel::Channel2': 1,\n        'EBRPawnCollisionChannel::Channel3': 2,\n        'EBRPawnCollisionChannel::Channel4': 3,\n        'EBRPawnCollisionChannel::EBRPawnCollisionChannel_MAX': 4,\n      },\n      EBRTextFacing: {\n        'EBRTextFacing::None': 0,\n        'EBRTextFacing::Full': 1,\n        'EBRTextFacing::InPlane': 2,\n        'EBRTextFacing::EBRTextFacing_MAX': 3,\n      },\n      EBRTextMaterial: {\n        'EBRTextMaterial::Unlit': 0,\n        'EBRTextMaterial::Graffiti': 1,\n        'EBRTextMaterial::Plastic': 2,\n        'EBRTextMaterial::Metallic': 3,\n        'EBRTextMaterial::Glow': 4,\n        'EBRTextMaterial::TranslucentPlastic': 5,\n        'EBRTextMaterial::Glass': 6,\n        'EBRTextMaterial::EBRTextMaterial_MAX': 7,\n      },\n      EBRTextOutline: {\n        'EBRTextOutline::None': 0,\n        'EBRTextOutline::Inlined': 1,\n        'EBRTextOutline::Outlined': 2,\n        'EBRTextOutline::HollowInlined': 3,\n        'EBRTextOutline::HollowOutlined': 4,\n        'EBRTextOutline::EBRTextOutline_MAX': 5,\n      },\n      EBRTextShading: {\n        'EBRTextShading::None': 0,\n        'EBRTextShading::Chamfer': 1,\n        'EBRTextShading::Fillet': 2,\n        'EBRTextShading::DoubleChamfer': 3,\n        'EBRTextShading::DoubleFillet': 4,\n        'EBRTextShading::Rounded': 5,\n        'EBRTextShading::EBRTextShading_MAX': 6,\n      },\n      EBRTextTypeface: {\n        'EBRTextTypeface::Regular': 0,\n        'EBRTextTypeface::Bold': 1,\n        'EBRTextTypeface::Italic': 2,\n        'EBRTextTypeface::BoldItalic': 3,\n        'EBRTextTypeface::EBRTextTypeface_MAX': 4,\n      },\n      EProjectileSpawnLocation: {\n        'EProjectileSpawnLocation::FaceCenter': 0,\n        'EProjectileSpawnLocation::RandomPointInFace': 1,\n        'EProjectileSpawnLocation::EProjectileSpawnLocation_MAX': 2,\n      },\n    },\n    variants: {\n      WireGraphArrayVariant: [\n        'WireGraphDoubleArray',\n        'WireGraphInt64Array',\n        'WireGraphBoolArray',\n        'WireGraphObjectArray',\n        'WireGraphVectorArray',\n        'WireGraphRotatorArray',\n        'WireGraphQuatArray',\n        'WireGraphStringArray',\n        'WireGraphLinearColorArray',\n        'WireGraphEnumArrayWrapper',\n      ],\n      WireGraphEnumArrayVariant: [\n        'WireGraphEnumArray_EBrickDirection',\n        'WireGraphEnumArray_EBrickAxis',\n        'WireGraphEnumArray_EBRPawnCollisionChannel',\n        'WireGraphEnumArray_EBRTextShading',\n        'WireGraphEnumArray_EBRTextOutline',\n        'WireGraphEnumArray_EBRTextMaterial',\n        'WireGraphEnumArray_EBRTextTypeface',\n        'WireGraphEnumArray_EBRTextFacing',\n        'WireGraphEnumArray_EBREasingFunction',\n        'WireGraphEnumArray_EBREasingDirection',\n        'WireGraphEnumArray_EBRColorSpace',\n        'WireGraphEnumArray_EProjectileSpawnLocation',\n        'WireGraphEnumArray_EBrickRigidJointInterpMode',\n        'WireGraphEnumArray_EBRDisplayTextJustification',\n        'WireGraphEnumArray_EBRDisplayTextEasing',\n        'WireGraphEnumArray_EBrickMaterial',\n      ],\n      WireGraphEnumVariant: [\n        'EBrickDirection',\n        'EBrickAxis',\n        'EBrickMaterial',\n        'EBRPawnCollisionChannel',\n        'EBRTextShading',\n        'EBRTextOutline',\n        'EBRTextMaterial',\n        'EBRTextTypeface',\n        'EBRTextFacing',\n        'EBREasingFunction',\n        'EBREasingDirection',\n        'EBRColorSpace',\n        'EProjectileSpawnLocation',\n        'EBrickRigidJointInterpMode',\n        'EBRDisplayTextJustification',\n        'EBRDisplayTextEasing',\n      ],\n      WireGraphPrimMathVariant: [\n        'f64',\n        'i64',\n        'Vector',\n        'Rotator',\n        'Quat',\n        'LinearColor',\n      ],\n      WireGraphVariant: [\n        'f64',\n        'i64',\n        'bool',\n        'weak_object',\n        'WireGraphExec',\n        'Vector',\n        'Rotator',\n        'Quat',\n        'str',\n        'LinearColor',\n        'WireGraphEnumWrapper',\n      ],\n    },\n    structs: {\n      BrickComponentData_AudioEmitter: {\n        bEnabled: 'bool',\n        AudioDescriptor: 'object',\n        VolumeMultiplier: 'f32',\n        PitchMultiplier: 'f32',\n        InnerRadius: 'f32',\n        MaxDistance: 'f32',\n        bSpatialization: 'bool',\n        FocusAzimuth: 'f32',\n        NonFocusAzimuth: 'f32',\n        NonFocusVolumeAttenuation: 'f32',\n      },\n      BrickComponentData_Bearing: {\n        bLimitAngle: 'bool',\n        LimitAngle: 'f32',\n        bAnglesArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_Button: {\n        PressSound: 'object',\n        ReleaseSound: 'object',\n        bAllowNearbyInteraction: 'bool',\n        bHiddenInteraction: 'bool',\n        PromptCustomLabel: 'str',\n      },\n      BrickComponentData_CheckPoint: {\n        bRotatePlayerGravityOnSpawn: 'bool',\n      },\n      BrickComponentData_Damage: {\n        Damage: 'f32',\n        RepeatDelay: 'f32',\n        Message: 'str',\n        ConsoleTag: 'str',\n      },\n      BrickComponentData_Interact: {\n        InteractSound: 'object',\n        Message: 'str',\n        ConsoleTag: 'str',\n        bAllowNearbyInteraction: 'bool',\n        bHiddenInteraction: 'bool',\n        PromptCustomLabel: 'str',\n      },\n      BrickComponentData_Internal_AttachedZone: {\n        ZoneStartDistance: 'i32',\n        ZoneEndDistance: 'i32',\n        bIsBuildingZone: 'bool',\n        bIsLooseZone: 'bool',\n        bIsShareZone: 'bool',\n        bDetectPlayers: 'bool',\n        bDetectPlayers1: 'bool',\n        bDetectPlayers2: 'bool',\n        bDetectPlayers3: 'bool',\n        bDetectEntities: 'bool',\n        bDetectProjectiles: 'bool',\n        TagFilter: 'str',\n      },\n      BrickComponentData_Internal_CharacterZoneEvent: {\n        bCollisionEnabled_Player: 'bool',\n        bCollisionEnabled_Player1: 'bool',\n        bCollisionEnabled_Player2: 'bool',\n        bCollisionEnabled_Player3: 'bool',\n      },\n      BrickComponentData_Internal_EntityZoneEvent: {},\n      BrickComponentData_Internal_InputSplitter_V2: {},\n      BrickComponentData_Internal_Microchip: {},\n      BrickComponentData_Internal_MicrochipInput: {\n        PortLabel: 'str',\n      },\n      BrickComponentData_Internal_MicrochipOutput: {\n        PortLabel: 'str',\n      },\n      BrickComponentData_Internal_ProjectileZoneEvent: {},\n      BrickComponentData_Internal_ReadBrickGrid: {},\n      BrickComponentData_Internal_ZoneEvent: {},\n      BrickComponentData_Motor: {\n        bEnabled: 'bool',\n        Speed: 'f32',\n        Power: 'f32',\n        bLimitAngle: 'bool',\n        LimitAngle: 'f32',\n        bAnglesArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_MotorSlider: {\n        bEnabled: 'bool',\n        Speed: 'f32',\n        Power: 'f32',\n        bPositionsArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_OneShotAudioEmitter: {\n        AudioDescriptor: 'object',\n        VolumeMultiplier: 'f32',\n        PitchMultiplier: 'f32',\n        InnerRadius: 'f32',\n        MaxDistance: 'f32',\n        bSpatialization: 'bool',\n        bEnableRepeat: 'bool',\n        RepeatTime: 'f32',\n        RepeatVariance: 'f32',\n        RepeatCount: 'i32',\n      },\n      BrickComponentData_ProjectileSpawner: {\n        ProjectileClass: 'class',\n        FireSound: 'object',\n        Direction: 'EBrickDirection',\n        SpawnLocation: 'EProjectileSpawnLocation',\n        SpawnMargin: 'f32',\n        bEnabled: 'bool',\n        NumberOfShots: 'i32',\n        SpreadConeAngle: 'f32',\n        bSpreadBiasedTowardsCenter: 'bool',\n        FireRate: 'f32',\n        DamageMultiplier: 'f32',\n        SpeedMultiplier: 'f32',\n        ScaleMultiplier: 'f32',\n      },\n      BrickComponentData_Rerouter: {},\n      BrickComponentData_RigidBearing: {\n        TargetAngle: 'f32',\n        bAnglesArePercentages: 'bool',\n        bReversed: 'bool',\n        InterpMode: 'EBrickRigidJointInterpMode',\n        SmoothTime: 'f32',\n        TopSpeed: 'f32',\n      },\n      BrickComponentData_RigidSlider: {\n        TargetPosition: 'f32',\n        bPositionsArePercentages: 'bool',\n        bReversed: 'bool',\n        InterpMode: 'EBrickRigidJointInterpMode',\n        SmoothTime: 'f32',\n        TopSpeed: 'f32',\n      },\n      BrickComponentData_Servo: {\n        bEnabled: 'bool',\n        TargetAngle: 'f32',\n        Power: 'f32',\n        ActiveDamping: 'f32',\n        ForceLimit: 'f32',\n        bLimitAngle: 'bool',\n        LimitAngle: 'f32',\n        bAnglesArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_ServoSlider: {\n        bEnabled: 'bool',\n        TargetPosition: 'f32',\n        Power: 'f32',\n        TopSpeed: 'f32',\n        Exponent: 'f32',\n        bPositionsArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_Slider: {\n        bPositionsArePercentages: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_SpawnPoint: {\n        bRotatePlayerGravityOnSpawn: 'bool',\n        bEnable: 'bool',\n      },\n      BrickComponentData_Switch: {\n        bEnabled: 'bool',\n        InteractSound: 'object',\n        bAllowNearbyInteraction: 'bool',\n        bHiddenInteraction: 'bool',\n        PromptCustomLabel: 'str',\n      },\n      BrickComponentData_Target: {\n        OnTime: 'f32',\n      },\n      BrickComponentData_TeleportDestination: {},\n      BrickComponentData_Thruster: {\n        bEnabled: 'bool',\n        Force: 'f32',\n        Throttle: 'f32',\n        Pitch: 'f32',\n        Yaw: 'f32',\n        bSpawnLight: 'bool',\n      },\n      BrickComponentData_Touch: {\n        BeginTouchSound: 'object',\n        EndTouchSound: 'object',\n        bCollisionEnabled_Player: 'bool',\n        bCollisionEnabled_Player1: 'bool',\n        bCollisionEnabled_Player2: 'bool',\n        bCollisionEnabled_Player3: 'bool',\n      },\n      BrickComponentData_WireGraph_AudioReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraph_BrickAssetReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraph_DeltaTime: {},\n      BrickComponentData_WireGraph_EntityTypeReference: {\n        Asset: 'class',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Average: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Base: {},\n      BrickComponentData_WireGraph_Exec_ArrayVar_DualRef: {},\n      BrickComponentData_WireGraph_Exec_ArrayVar_ElementOp: {\n        Index: 'i64',\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Find: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Get: {\n        Index: 'i64',\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_GetLength: {},\n      BrickComponentData_WireGraph_Exec_ArrayVar_Insert: {\n        Index: 'i64',\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_MinMax: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Pop: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Push: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_RemoveAtIndex: {\n        Index: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Resize: {\n        Size: 'i64',\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Slice: {\n        Start: 'i64',\n        Count: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Sort: {\n        bDescending: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Sum: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_ArrayVar_Swap: {\n        IndexA: 'i64',\n        IndexB: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_Character_AddInventoryEntity: {},\n      BrickComponentData_WireGraph_Exec_Character_AddInventoryItem: {},\n      BrickComponentData_WireGraph_Exec_Character_GetAim: {},\n      BrickComponentData_WireGraph_Exec_Character_GetDamage: {},\n      BrickComponentData_WireGraph_Exec_Character_GetFromController: {},\n      BrickComponentData_WireGraph_Exec_Character_IncDamage: {\n        Amount: 'f64',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetDamage: {\n        Damage: 'f64',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetInventoryEntity: {\n        Slot: 'i32',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetInventoryItem: {\n        Slot: 'i32',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetTempPermission: {\n        PermissionTagStr: 'str',\n        bPermissionEnable: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Character_ShowHint: {\n        HintTitle: 'str',\n        HintText: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_ChatCommand: {\n        CommandName: 'str',\n        HelpText: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_GetDisplayName: {},\n      BrickComponentData_WireGraph_Exec_Controller_GetFromEntity: {},\n      BrickComponentData_WireGraph_Exec_Controller_GetUserId: {},\n      BrickComponentData_WireGraph_Exec_Controller_GetUserName: {},\n      BrickComponentData_WireGraph_Exec_Controller_HasPermission: {\n        PermissionName: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_HasRole: {\n        RoleName: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_IsTrustedByBrickOwner: {},\n      BrickComponentData_WireGraph_Exec_Controller_SetCanRespawn: {\n        bCanRespawn: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_ShowChatMessage: {\n        Message: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_ShowStatusMessage: {},\n      BrickComponentData_WireGraph_Exec_Cycle: {\n        Count: 'i64',\n        Value: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_GetAngularVelocity: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetLinearVelocity: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetLocation: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetLocationRotation: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetRotation: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetTag: {},\n      BrickComponentData_WireGraph_Exec_Entity_GetVelocity: {},\n      BrickComponentData_WireGraph_Exec_Entity_PlayAudioAt: {\n        AudioDescriptor: 'object',\n        VolumeMultiplier: 'f32',\n        PitchMultiplier: 'f32',\n        InnerRadius: 'f32',\n        MaxDistance: 'f32',\n        bSpatialization: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetFrozen: {\n        bFrozen: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetTag: {\n        Tag: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_BroadcastChatMessage: {\n        Message: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_BroadcastStatusMessage: {\n        Message: 'str',\n        bFlashIfUnchanged: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_FillArrayFromTeamMembers: {},\n      BrickComponentData_WireGraph_Exec_Gamemode_GetCurrentRound: {},\n      BrickComponentData_WireGraph_Exec_Gamemode_GetLeaderboardValue: {\n        Key: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_GetTeam: {},\n      BrickComponentData_WireGraph_Exec_Gamemode_GetTeamByName: {\n        TeamName: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_GetTeamLeaderboardValue: {\n        Key: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_GetTeamName: {},\n      BrickComponentData_WireGraph_Exec_Gamemode_LeaderboardValue: {\n        Key: 'str',\n        Value: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_PlayerWins: {\n        bTeamWinsInstead: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_SetTeam: {\n        bPinPlayerToTeam: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_SetTeamPinned: {\n        bPinned: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_TeamLeaderboardValue: {\n        Key: 'str',\n        Value: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_Gamemode_TeamWins: {},\n      BrickComponentData_WireGraph_Exec_PlayGlobalAudio: {\n        AudioDescriptor: 'object',\n        VolumeMultiplier: 'f32',\n        PitchMultiplier: 'f32',\n      },\n      BrickComponentData_WireGraph_Exec_PrintToConsole: {\n        Text: 'str',\n      },\n      BrickComponentData_WireGraph_Exec_Random: {\n        Min: 'WireGraphPrimMathVariant',\n        Max: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Exec_Toggle: {\n        Value: 'bool',\n      },\n      BrickComponentData_WireGraph_Exec_Var_EditOrGet: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Exec_Var_Get: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_ExecBranch: {\n        bCond: 'bool',\n      },\n      BrickComponentData_WireGraph_ExecUnion: {},\n      BrickComponentData_WireGraph_Expr_Bool_Bool: {\n        bInput: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_BoolBool_Bool: {\n        bInputA: 'bool',\n        bInputB: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_Compare: {\n        InputA: 'WireGraphVariant',\n        InputB: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Expr_Convert: {\n        TargetType: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Expr_EdgeDetector: {\n        Input: 'f64',\n        bPulseOnRisingEdge: 'bool',\n        bPulseOnFallingEdge: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_Float_Float: {\n        Input: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_Int_Int: {\n        Input: 'i64',\n      },\n      BrickComponentData_WireGraph_Expr_IntInt_Int: {\n        InputA: 'i64',\n        InputB: 'i64',\n      },\n      BrickComponentData_WireGraph_Expr_MakeColor: {\n        R: 'f64',\n        G: 'f64',\n        B: 'f64',\n        A: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MakeColorHex: {\n        Hex: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_MakeColorSRGB: {\n        R: 'i64',\n        G: 'i64',\n        B: 'i64',\n        A: 'i64',\n      },\n      BrickComponentData_WireGraph_Expr_MakeQuaternion: {\n        X: 'f64',\n        Y: 'f64',\n        Z: 'f64',\n        W: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MakeRotation: {\n        Pitch: 'f64',\n        Yaw: 'f64',\n        Roll: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MakeVector: {\n        X: 'f64',\n        Y: 'f64',\n        Z: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MathAtan2: {\n        Y: 'f64',\n        X: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MathBlend: {\n        Blend: 'f64',\n        bClampAlpha: 'bool',\n        InputA: 'WireGraphPrimMathVariant',\n        InputB: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Expr_MathClamp: {\n        Min: 'WireGraphPrimMathVariant',\n        Max: 'WireGraphPrimMathVariant',\n        Input: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Expr_MathCompare: {\n        InputA: 'WireGraphPrimMathVariant',\n        InputB: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Expr_MathEasing: {\n        Blend: 'f64',\n        Function: 'EBREasingFunction',\n        Direction: 'EBREasingDirection',\n        InputA: 'WireGraphPrimMathVariant',\n        InputB: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Expr_MathLogBase: {\n        Input: 'f64',\n        Base: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_MathPow: {\n        Input: 'f64',\n        Exponent: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_NearlyEqual: {\n        InputA: 'WireGraphPrimMathVariant',\n        InputB: 'WireGraphPrimMathVariant',\n        Tolerance: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_PrimMathVariant_PrimMathVariant: {\n        Input: 'WireGraphPrimMathVariant',\n      },\n      BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant:\n        {\n          InputA: 'WireGraphPrimMathVariant',\n          InputB: 'WireGraphPrimMathVariant',\n        },\n      BrickComponentData_WireGraph_Expr_Select: {\n        bSelectB: 'bool',\n        InputA: 'WireGraphVariant',\n        InputB: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Expr_String_Concatenate: {\n        InputA: 'str',\n        InputB: 'str',\n        Separator: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_Contains: {\n        Input: 'str',\n        Search: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_EndsWith: {\n        Input: 'str',\n        Suffix: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_Find: {\n        Input: 'str',\n        Search: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_FormatText: {\n        FormatString: 'str',\n        InputA: 'WireGraphVariant',\n        InputB: 'WireGraphVariant',\n        InputC: 'WireGraphVariant',\n        InputD: 'WireGraphVariant',\n        InputE: 'WireGraphVariant',\n        InputF: 'WireGraphVariant',\n        InputG: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Expr_String_Length: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_ParseInt: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_ParseNumber: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_Replace: {\n        Input: 'str',\n        Search: 'str',\n        Replacement: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_Split: {\n        Input: 'str',\n        Delimiter: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_StartsWith: {\n        Input: 'str',\n        Prefix: 'str',\n        bCaseSensitive: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_String_Substring: {\n        Input: 'str',\n        Start: 'i64',\n        Length: 'i64',\n      },\n      BrickComponentData_WireGraph_Expr_String_ToLower: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_ToUpper: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_String_Trim: {\n        Input: 'str',\n      },\n      BrickComponentData_WireGraph_Expr_Swap: {\n        bSwap: 'bool',\n        InputA: 'WireGraphVariant',\n        InputB: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Expr_Variant_Variant: {\n        Input: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraph_Fake_CharacterDamageEvent: {},\n      BrickComponentData_WireGraph_Fake_CharacterDeathEvent: {},\n      BrickComponentData_WireGraph_Fake_CharacterEvent: {},\n      BrickComponentData_WireGraph_Fake_ControllerEvent: {},\n      BrickComponentData_WireGraph_Fake_RoundEvent: {\n        RoundNumber: 'i32',\n      },\n      BrickComponentData_WireGraph_FindPlayer: {\n        Query: 'str',\n      },\n      BrickComponentData_WireGraph_FontReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraph_ItemReference: {\n        Asset: 'class',\n      },\n      BrickComponentData_WireGraph_OneShotAudioReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraph_ParticleReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraph_PickupReference: {\n        Asset: 'class',\n      },\n      BrickComponentData_WireGraph_ProjectileReference: {\n        Asset: 'class',\n      },\n      BrickComponentData_WireGraph_ServerUptime: {},\n      BrickComponentData_WireGraph_WheelEngineAudioReference: {\n        Asset: 'object',\n      },\n      BrickComponentData_WireGraphPseudo_ArrayVar: {\n        Value: 'WireGraphArrayVariant',\n      },\n      BrickComponentData_WireGraphPseudo_BufferSeconds: {\n        SecondsToWait: 'f32',\n        ZeroSecondsToWait: 'f32',\n        CurrentTime: 'f32',\n        Input: 'WireGraphVariant',\n        Output: 'WireGraphVariant',\n        Buffered: 'WireGraphVariant',\n        bHasQueued: 'bool',\n        bIsOffTimer: 'bool',\n      },\n      BrickComponentData_WireGraphPseudo_BufferTicks: {\n        TicksToWait: 'i32',\n        ZeroTicksToWait: 'i32',\n        CurrentTicks: 'i32',\n        Input: 'WireGraphVariant',\n        Output: 'WireGraphVariant',\n        Buffered: 'WireGraphVariant',\n        bHasQueued: 'bool',\n        bIsOffTimer: 'bool',\n      },\n      BrickComponentData_WireGraphPseudo_Timer: {\n        Limit: 'f64',\n        Time: 'f64',\n        bRunning: 'bool',\n      },\n      BrickComponentData_WireGraphPseudo_Tween: {\n        Target: 'WireGraphVariant',\n        Value: 'WireGraphVariant',\n        StartValue: 'WireGraphVariant',\n        Duration: 'f64',\n        Elapsed: 'f64',\n        Function: 'EBREasingFunction',\n        Direction: 'EBREasingDirection',\n      },\n      BrickComponentData_WireGraphPseudo_Var: {\n        Value: 'WireGraphVariant',\n      },\n      BrickComponentWireControl_DriveAndSteer: {},\n      BrickComponentWirePortControl_TeleportDestination: {},\n      BRInventoryEntryVariant: {},\n      BRQueueSecondsEntry: {\n        Data: ['WireGraphVariant'],\n        RemainingTime: 'f32',\n      },\n      BRQueueTicksEntry: {\n        Data: ['WireGraphVariant'],\n        RemainingTicks: 'i32',\n      },\n      BRSavedBrickComponentTypeCounter: {\n        TypeIndex: 'u32',\n        NumInstances: 'u32',\n      },\n      Color: {\n        B: 'u8',\n        G: 'u8',\n        R: 'u8',\n        A: 'u8',\n      },\n      IntVector: {\n        X: 'i32',\n        Y: 'i32',\n        Z: 'i32',\n      },\n      LinearColor: {\n        R: 'f32',\n        G: 'f32',\n        B: 'f32',\n        A: 'f32',\n      },\n      Quat: {\n        X: 'f64',\n        Y: 'f64',\n        Z: 'f64',\n        W: 'f64',\n      },\n      Quat4f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n        W: 'f32',\n      },\n      Rotator: {\n        Pitch: 'f64',\n        Yaw: 'f64',\n        Roll: 'f64',\n      },\n      Rotator3f: {\n        Pitch: 'f32',\n        Yaw: 'f32',\n        Roll: 'f32',\n      },\n      Vector: {\n        X: 'f64',\n        Y: 'f64',\n        Z: 'f64',\n      },\n      Vector2f: {\n        X: 'f32',\n        Y: 'f32',\n      },\n      Vector3f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n      },\n      Vector4: {\n        X: 'f64',\n        Y: 'f64',\n        Z: 'f64',\n        W: 'f64',\n      },\n      WireGraphBoolArray: {\n        Values: ['bool'],\n      },\n      WireGraphDoubleArray: {\n        Values: ['f64'],\n      },\n      WireGraphEnumArray_EBRColorSpace: {\n        Values: ['EBRColorSpace'],\n      },\n      WireGraphEnumArray_EBRDisplayTextEasing: {\n        Values: ['EBRDisplayTextEasing'],\n      },\n      WireGraphEnumArray_EBRDisplayTextJustification: {\n        Values: ['EBRDisplayTextJustification'],\n      },\n      WireGraphEnumArray_EBREasingDirection: {\n        Values: ['EBREasingDirection'],\n      },\n      WireGraphEnumArray_EBREasingFunction: {\n        Values: ['EBREasingFunction'],\n      },\n      WireGraphEnumArray_EBrickAxis: {\n        Values: ['EBrickAxis'],\n      },\n      WireGraphEnumArray_EBrickDirection: {\n        Values: ['EBrickDirection'],\n      },\n      WireGraphEnumArray_EBrickMaterial: {\n        Values: ['EBrickMaterial'],\n      },\n      WireGraphEnumArray_EBrickRigidJointInterpMode: {\n        Values: ['EBrickRigidJointInterpMode'],\n      },\n      WireGraphEnumArray_EBRPawnCollisionChannel: {\n        Values: ['EBRPawnCollisionChannel'],\n      },\n      WireGraphEnumArray_EBRTextFacing: {\n        Values: ['EBRTextFacing'],\n      },\n      WireGraphEnumArray_EBRTextMaterial: {\n        Values: ['EBRTextMaterial'],\n      },\n      WireGraphEnumArray_EBRTextOutline: {\n        Values: ['EBRTextOutline'],\n      },\n      WireGraphEnumArray_EBRTextShading: {\n        Values: ['EBRTextShading'],\n      },\n      WireGraphEnumArray_EBRTextTypeface: {\n        Values: ['EBRTextTypeface'],\n      },\n      WireGraphEnumArray_EProjectileSpawnLocation: {\n        Values: ['EProjectileSpawnLocation'],\n      },\n      WireGraphEnumArrayWrapper: {\n        Enum: 'WireGraphEnumArrayVariant',\n      },\n      WireGraphEnumWrapper: {\n        Enum: 'WireGraphEnumVariant',\n      },\n      WireGraphExec: {},\n      WireGraphInt64Array: {\n        Values: ['i64'],\n      },\n      WireGraphObjectArray: {\n        Values: ['weak_object'],\n      },\n      WireGraphStringArray: {\n        Values: ['str'],\n      },\n      BrickComponentData_BrickPropertyChanger: {\n        bVisibility: 'bool',\n        bCollisionEnabled: 'bool',\n        bCollisionEnabled_Player: 'bool',\n        bCollisionEnabled_Player1: 'bool',\n        bCollisionEnabled_Player2: 'bool',\n        bCollisionEnabled_Player3: 'bool',\n        bCollisionEnabled_Weapon: 'bool',\n        bCollisionEnabled_Interaction: 'bool',\n        bCollisionEnabled_Physics: 'bool',\n        Color: 'Color',\n        MaterialAlpha: 'u8',\n        Material: 'EBrickMaterial',\n      },\n      BrickComponentData_Gyroscope: {\n        bEnabled: 'bool',\n        Strength: 'f32',\n        Damping: 'f32',\n        MaxForce: 'f32',\n        TargetAxis: 'Vector',\n      },\n      BrickComponentData_ItemSpawn: {\n        PickupClass: 'class',\n        bPickupEnabled: 'bool',\n        bPickupRespawnOnMinigameReset: 'bool',\n        PickupMinigameResetRespawnDelay: 'f32',\n        bPickupAutoDisableOnPickup: 'bool',\n        PickupRespawnTime: 'f32',\n        bRenderTranslucentWhenDisabled: 'bool',\n        DamageMultiplier: 'f32',\n        WeaponSpeedMultiplier: 'f32',\n        ItemNameOverride: 'str',\n        ProjectileOverride: 'class',\n        PickupOffsetDirection: 'EBrickDirection',\n        PickupOffsetDistance: 'f32',\n        PickupRotation: 'Rotator3f',\n        PickupScale: 'f32',\n        bOverridePickupColors: 'bool',\n        PickupMeshColors: ['Color'],\n        bPickupAnimationEnabled: 'bool',\n        PickupAnimationAxis: 'EBrickAxis',\n        bPickupAnimationAxisLocal: 'bool',\n        PickupSpinSpeed: 'f32',\n        PickupBobSpeed: 'f32',\n        PickupBobHeight: 'f32',\n        PickupAnimationPhase: 'f32',\n      },\n      BrickComponentData_Joint_Wheel: {\n        Control_DriveAndSteer: 'BrickComponentWireControl_DriveAndSteer',\n        bEnabled: 'bool',\n        DriveSpeed: 'f32',\n        DrivePower: 'f32',\n        bSteerEnabled: 'bool',\n        Steer: 'f32',\n        SteerLimitDegree: 'f32',\n        SteerPower: 'f32',\n        bSuspensionEnabled: 'bool',\n        SuspensionStiffness: 'f32',\n        SuspensionDamping: 'f32',\n        JointDistance: 'i32',\n        bDriveWhenNotAttachedToEngine: 'bool',\n        bCanBrake: 'bool',\n        bAllowEngineSteerCorrect: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_Joint_Wheel_Suspension: {\n        Control_DriveAndSteer: 'BrickComponentWireControl_DriveAndSteer',\n        bEnabled: 'bool',\n        DriveSpeed: 'f32',\n        DrivePower: 'f32',\n        bSteerEnabled: 'bool',\n        Steer: 'f32',\n        SteerLimitDegree: 'f32',\n        SteerPower: 'f32',\n        bSuspensionEnabled: 'bool',\n        SuspensionStiffness: 'f32',\n        SuspensionDamping: 'f32',\n        SuspensionOffset: 'f32',\n        SuspensionLength: 'f32',\n        JointDistance: 'i32',\n        bDriveWhenNotAttachedToEngine: 'bool',\n        bCanBrake: 'bool',\n        bAllowEngineSteerCorrect: 'bool',\n        bReversed: 'bool',\n        Damping: 'f32',\n      },\n      BrickComponentData_PointLight: {\n        bMatchBrickShape: 'bool',\n        bEnabled: 'bool',\n        Brightness: 'f32',\n        Radius: 'f32',\n        Color: 'Color',\n        bUseBrickColor: 'bool',\n        bCastShadows: 'bool',\n      },\n      BrickComponentData_PrefabSpawn: {\n        Prefab: 'bundle_path_ref',\n        SpawnOffset: 'Vector',\n        SpawnOffsetRotation: 'Rotator',\n        SpawnVelocity: 'Vector',\n        bSpawnEnable: 'bool',\n        RespawnTime: 'f64',\n        SpawnedEntityIds: ['u32'],\n      },\n      BrickComponentData_Seat_V2: {\n        bIsOccupied: 'bool',\n        ExitOffset: 'IntVector',\n        bRollCameraInThirdPerson: 'bool',\n        bAllowNearbyInteraction: 'bool',\n        bHiddenInteraction: 'bool',\n        PromptCustomLabel: 'str',\n      },\n      BrickComponentData_SpotLight: {\n        Rotation: 'Rotator3f',\n        InnerConeAngle: 'f32',\n        OuterConeAngle: 'f32',\n        bEnabled: 'bool',\n        Brightness: 'f32',\n        Radius: 'f32',\n        Color: 'Color',\n        bUseBrickColor: 'bool',\n        bCastShadows: 'bool',\n      },\n      BrickComponentData_TextDisplay: {\n        Text: 'str',\n        Font: 'object',\n        Rotation: 'f32',\n        Skew: 'f32',\n        Kerning: 'f32',\n        LineHeight: 'f32',\n        LineOffset: 'f32',\n        Anchor: 'Vector2f',\n        Offset: 'Vector3f',\n        Color: 'Color',\n        MaterialSlider: 'i32',\n        ShadingWidth: 'f32',\n        OutlineColor: 'Color',\n        OutlineWidth: 'f32',\n        ScuffWidth: 'f32',\n        GraffitiDepthLimit: 'f32',\n        GraffitiAngleLimit: 'f32',\n        GraffitiLayer: 'i32',\n        bEnabled: 'bool',\n        Face: 'EBrickDirection',\n        bAlignToWedge: 'bool',\n        bOverrideColor: 'bool',\n        Typeface: 'EBRTextTypeface',\n        Billboard: 'EBRTextFacing',\n        Material: 'EBRTextMaterial',\n        Shading: 'EBRTextShading',\n        bFlipShading: 'bool',\n        Outline: 'EBRTextOutline',\n        bSharpCorners: 'bool',\n        bSharpOutlines: 'bool',\n        bOverrideOutlineColor: 'bool',\n        bForeground: 'bool',\n      },\n      BrickComponentData_WeightBrick: {\n        Mass: 'f32',\n        MassSize: 'IntVector',\n        MassOffset: 'IntVector',\n      },\n      BrickComponentData_WheelEngine_V2: {\n        bEnabled: 'bool',\n        bEnableManualControl: 'bool',\n        ManualInput_Drive: 'f32',\n        ManualInput_Steer: 'f32',\n        bManualInput_Brake: 'bool',\n        Control_DriveAndSteer: 'BrickComponentWireControl_DriveAndSteer',\n        CustomMass: 'f32',\n        CustomMassVerticalOffset: 'f32',\n        DriveInterpSpeed: 'f32',\n        DriveSpeed: 'f32',\n        DriveAcceleratingPowerMultiplier: 'f32',\n        DriveBrakingPowerMultiplier: 'f32',\n        DriveDampingMultiplier: 'f32',\n        SteerPowerMultiplier: 'f32',\n        WheelFrictionMultiplier: 'f32',\n        SteerInterpSpeed: 'f32',\n        SteerLimitSpeedFalloff: 'f32',\n        SteerLimitDegree: 'f32',\n        CenterOfSteering: 'f32',\n        bTankSteering: 'bool',\n        TankSteerSpeedMultiplier: 'f32',\n        bAutoRight: 'bool',\n        WaterDriveForce: 'f32',\n        WaterSteeringForce: 'f32',\n        AudioDescriptor: 'object',\n      },\n      BrickComponentData_WireGraph_Exec_Character_AddInventoryBrick: {\n        ProceduralSize: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetInventoryBrick: {\n        Slot: 'i32',\n        ProceduralSize: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Controller_DisplayText: {\n        Text: 'str',\n        AnchorX: 'f64',\n        AnchorY: 'f64',\n        PositionX: 'f64',\n        PositionY: 'f64',\n        Angle: 'f64',\n        ScaleX: 'f64',\n        ScaleY: 'f64',\n        FontSize: 'i32',\n        FontColor: 'Color',\n        OutlineSize: 'i64',\n        OutlineColor: 'Color',\n        Justification: 'EBRDisplayTextJustification',\n        Transition: 'f64',\n        Easing: 'EBRDisplayTextEasing',\n        Lifetime: 'f64',\n        TextId: 'i64',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_AddLocationRotation: {\n        Vector: 'Vector',\n        Rotation: 'Rotator',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_AddVelocity: {\n        Vector: 'Vector',\n        Rotation: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_RelativeTeleport: {\n        Source: 'BrickComponentWirePortControl_TeleportDestination',\n        Destination: 'BrickComponentWirePortControl_TeleportDestination',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetAngularVelocity: {\n        AngularVelocity: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetGravityDirection: {\n        Rotation: 'Rotator',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetLinearVelocity: {\n        LinearVelocity: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetLocation: {\n        Vector: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetLocationRotation: {\n        Vector: 'Vector',\n        Rotation: 'Rotator',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetRotation: {\n        Rotation: 'Rotator',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_SetVelocity: {\n        Vector: 'Vector',\n        Rotation: 'Vector',\n      },\n      BrickComponentData_WireGraph_Exec_Entity_Teleport: {\n        Destination: 'BrickComponentWirePortControl_TeleportDestination',\n      },\n      BrickComponentData_WireGraph_Exec_PrefabSpawner: {\n        Prefab: 'bundle_path_ref',\n        SpawnOffset: 'Vector',\n        SpawnOffsetRotation: 'Rotator',\n        SpawnVelocity: 'Vector',\n        Lifetime: 'f64',\n        Limit: 'i64',\n        SpawnedEntityIds: ['u32'],\n      },\n      BrickComponentData_WireGraph_Exec_Sweep: {\n        Origin: 'Vector',\n        Direction: 'Vector',\n        Distance: 'f64',\n        Radius: 'f64',\n        bDetectBricks: 'bool',\n        bDetectPlayers1: 'bool',\n        bDetectPlayers2: 'bool',\n        bDetectPlayers3: 'bool',\n        bDetectPlayers4: 'bool',\n        bDetectPhysics: 'bool',\n        bDetectMap: 'bool',\n        bRelative: 'bool',\n        bIgnoreOwningGrid: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_ColorBlend: {\n        ColorA: 'LinearColor',\n        ColorB: 'LinearColor',\n        Alpha: 'f64',\n        BlendSpace: 'EBRColorSpace',\n        bClampAlpha: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_ColorConvert: {\n        Input: 'LinearColor',\n        FromSpace: 'EBRColorSpace',\n        ToSpace: 'EBRColorSpace',\n      },\n      BrickComponentData_WireGraph_Expr_ColorToHex: {\n        Input: 'LinearColor',\n      },\n      BrickComponentData_WireGraph_Expr_DirectionToRotation: {\n        Direction: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_InvertRotation: {\n        Input: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_QuatAngleBetween: {\n        InputA: 'Quat',\n        InputB: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_QuatBetween: {\n        From: 'Vector',\n        To: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_QuatDotProduct: {\n        InputA: 'Quat',\n        InputB: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_QuatFromAxisAngle: {\n        Axis: 'Vector',\n        Angle: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_QuatSlerp: {\n        InputA: 'Quat',\n        InputB: 'Quat',\n        Alpha: 'f64',\n        bShortestPath: 'bool',\n        bClampAlpha: 'bool',\n      },\n      BrickComponentData_WireGraph_Expr_QuatToAxisAngle: {\n        Input: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_RotateVector: {\n        Rotation: 'Quat',\n        Vector: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_RotationToDirection: {\n        Rotation: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_SplitColor: {\n        Input: 'LinearColor',\n      },\n      BrickComponentData_WireGraph_Expr_SplitColorSRGB: {\n        Input: 'LinearColor',\n      },\n      BrickComponentData_WireGraph_Expr_SplitQuaternion: {\n        Input: 'Quat',\n      },\n      BrickComponentData_WireGraph_Expr_SplitRotation: {\n        Input: 'Rotator',\n      },\n      BrickComponentData_WireGraph_Expr_SplitVector: {\n        Input: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_Vec_Float: {\n        Input: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_Vec_Vec: {\n        Input: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_VecFloat_Vec: {\n        Input: 'Vector',\n        Scalar: 'f64',\n      },\n      BrickComponentData_WireGraph_Expr_VecVec_Float: {\n        InputA: 'Vector',\n        InputB: 'Vector',\n      },\n      BrickComponentData_WireGraph_Expr_VecVec_Vec: {\n        InputA: 'Vector',\n        InputB: 'Vector',\n      },\n      BrickComponentData_WireGraphPseudo_Dampen: {\n        Target: 'WireGraphVariant',\n        Value: 'WireGraphVariant',\n        SmoothTime: 'f64',\n        Velocity: 'Vector4',\n      },\n      BrickComponentData_WireGraphPseudo_QueueSeconds: {\n        SecondsToWait: 'f32',\n        Entries: ['BRQueueSecondsEntry'],\n        DataIn1: 'WireGraphVariant',\n        DataIn2: 'WireGraphVariant',\n        DataIn3: 'WireGraphVariant',\n        DataIn4: 'WireGraphVariant',\n        DataIn5: 'WireGraphVariant',\n        DataIn6: 'WireGraphVariant',\n        DataIn7: 'WireGraphVariant',\n        DataIn8: 'WireGraphVariant',\n        DataOut1: 'WireGraphVariant',\n        DataOut2: 'WireGraphVariant',\n        DataOut3: 'WireGraphVariant',\n        DataOut4: 'WireGraphVariant',\n        DataOut5: 'WireGraphVariant',\n        DataOut6: 'WireGraphVariant',\n        DataOut7: 'WireGraphVariant',\n        DataOut8: 'WireGraphVariant',\n      },\n      BrickComponentData_WireGraphPseudo_QueueTicks: {\n        TicksToWait: 'i32',\n        Entries: ['BRQueueTicksEntry'],\n        DataIn1: 'WireGraphVariant',\n        DataIn2: 'WireGraphVariant',\n        DataIn3: 'WireGraphVariant',\n        DataIn4: 'WireGraphVariant',\n        DataIn5: 'WireGraphVariant',\n        DataIn6: 'WireGraphVariant',\n        DataIn7: 'WireGraphVariant',\n        DataIn8: 'WireGraphVariant',\n        DataOut1: 'WireGraphVariant',\n        DataOut2: 'WireGraphVariant',\n        DataOut3: 'WireGraphVariant',\n        DataOut4: 'WireGraphVariant',\n        DataOut5: 'WireGraphVariant',\n        DataOut6: 'WireGraphVariant',\n        DataOut7: 'WireGraphVariant',\n        DataOut8: 'WireGraphVariant',\n      },\n      BrickTypeNetWrapper: {\n        BrickAsset: 'object',\n        ProceduralSize: 'IntVector',\n      },\n      BRInventoryEntryConfig: {\n        Item: 'BRInventoryEntryVariant',\n      },\n      BRPlayerPartCustomizationV3: {\n        PartDescriptor: 'object',\n        DecalDescriptor: 'object',\n        SocketName: 'str',\n        Colors: ['Color'],\n      },\n      BRSavedComponentChunkSoA: {\n        ComponentTypeCounters: ['BRSavedBrickComponentTypeCounter'],\n        ComponentBrickIndices: ['u32'],\n        JointBrickIndices: ['u32'],\n        JointEntityReferences: ['u32'],\n        JointInitialRelativeOffsets: ['Vector3f', null],\n        JointInitialRelativeRotations: ['Quat4f', null],\n        MicrochipBrickIndices: ['u32'],\n        MicrochipBrickGridReferences: ['u32'],\n      },\n      WireGraphLinearColorArray: {\n        Values: ['LinearColor'],\n      },\n      WireGraphQuatArray: {\n        Values: ['Quat'],\n      },\n      WireGraphRotatorArray: {\n        Values: ['Rotator'],\n      },\n      WireGraphVectorArray: {\n        Values: ['Vector'],\n      },\n      BrickComponentData_WireGraph_Exec_Character_AddInventoryEntry: {\n        Entry: 'BRInventoryEntryConfig',\n      },\n      BRInventoryEntryPlan: {\n        Type: 'EBRInventoryEntryPlanType',\n        BrickTypeIfBrick: 'BrickTypeNetWrapper',\n        EntityTypeIfEntity: 'class',\n        ItemTypeIfItem: 'class',\n      },\n      BRPlayerAvatarCustomizationV3: {\n        Parts: ['BRPlayerPartCustomizationV3'],\n      },\n      BrickComponentData_BotSpawn: {\n        RespawnTime: 'f32',\n        CorpseTimeout: 'f32',\n        GunSkill: 'f32',\n        Agression: 'f32',\n        ReactionTime: 'f32',\n        MovementRandomness: 'f32',\n        RunSpeed: 'f32',\n        HealthMultiplier: 'f32',\n        Jumpyness: 'f32',\n        MovementAmount: 'f32',\n        AttackMovementAmount: 'f32',\n        AggroRange: 'f32',\n        AttackDamageMultiplier: 'f32',\n        bCanJump: 'bool',\n        bBackVision: 'bool',\n        bVisionRaycasting: 'bool',\n        bCanTargetPlayers: 'bool',\n        bCanTargetBots: 'bool',\n        bActiveBot: 'bool',\n        bSpawnEnable: 'bool',\n        bDeleteBot: 'bool',\n        MoveTarget: 'Vector',\n        MovementGoalDummy: 'BrickComponentWirePortControl_TeleportDestination',\n        BotName: 'str',\n        Skin: 'BRPlayerAvatarCustomizationV3',\n        bColorsAreLinear: 'bool',\n        TeamCollisionChannel: 'EBRPawnCollisionChannel',\n        bTeamCollision: 'bool',\n        bTeamCollision1: 'bool',\n        bTeamCollision2: 'bool',\n        bTeamCollision3: 'bool',\n        BotWeapon: 'class',\n      },\n      BrickComponentData_WireGraph_Exec_Character_SetInventoryEntry: {\n        Slot: 'i32',\n        Entry: 'BRInventoryEntryConfig',\n        EntryPlan: 'BRInventoryEntryPlan',\n      },\n    },\n  },\n  BRSavedEntityChunkIndexSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BRSavedChunk3DIndex: {\n        X: 'i16',\n        Y: 'i16',\n        Z: 'i16',\n      },\n      BRSavedEntityChunkIndexSoA: {\n        NextPersistentIndex: 'u32',\n        Chunk3DIndices: ['BRSavedChunk3DIndex'],\n        NumEntities: ['u32'],\n      },\n    },\n  },\n  BRSavedEntityChunkSoA: {\n    enums: {},\n    variants: {},\n    structs: {\n      BrickGridDynamicActor: {\n        BouyancyScale: 'f32',\n        MassScale: 'f32',\n        bEnableGravity: 'bool',\n        bUseNewMassCalculation: 'bool',\n        bReceivesDecals: 'bool',\n        EntityTag: 'str',\n      },\n      BRSavedBitFlags: {\n        Flags: ['u8', null],\n      },\n      BRSavedBrickColor: {\n        R: 'u8',\n        G: 'u8',\n        B: 'u8',\n        A: 'u8',\n      },\n      BRSavedEntityTypeCounter: {\n        TypeIndex: 'u32',\n        NumEntities: 'u32',\n      },\n      IntVector: {\n        X: 'i32',\n        Y: 'i32',\n        Z: 'i32',\n      },\n      Quat4f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n        W: 'f32',\n      },\n      Vector3f: {\n        X: 'f32',\n        Y: 'f32',\n        Z: 'f32',\n      },\n      BP_MicrochipBrickGridDynamicActor_C: {\n        bCollapsed: 'bool',\n        PlaneCenter: 'IntVector',\n        PlaneExtent: 'IntVector',\n      },\n      BRSavedEntityColors: {\n        Color0: 'BRSavedBrickColor',\n        Color1: 'BRSavedBrickColor',\n        Color2: 'BRSavedBrickColor',\n        Color3: 'BRSavedBrickColor',\n        Color4: 'BRSavedBrickColor',\n        Color5: 'BRSavedBrickColor',\n        Color6: 'BRSavedBrickColor',\n        Color7: 'BRSavedBrickColor',\n      },\n      BRSavedEntityChunkSoA: {\n        TypeCounters: ['BRSavedEntityTypeCounter'],\n        PersistentIndices: ['u32'],\n        OwnerIndices: ['u32'],\n        OriginalOwnerIndices: ['u32'],\n        Locations: ['Vector3f', null],\n        Rotations: ['Quat4f', null],\n        WeldParentFlags: 'BRSavedBitFlags',\n        PhysicsLockedFlags: 'BRSavedBitFlags',\n        PhysicsSleepingFlags: 'BRSavedBitFlags',\n        WeldParentIndices: ['u32'],\n        LinearVelocities: ['Vector3f', null],\n        AngularVelocities: ['Vector3f', null],\n        ColorsAndAlphas: ['BRSavedEntityColors', null],\n        RemainingLifeSpans: ['f32', null],\n        bColorsAreLinear: 'bool',\n      },\n    },\n  },\n};\n","// BrdbSchema: the msgpack-schema model plus its binary (de)serialization.\n// Wire form: always the 3-element [enums, variants, structs] msgpack array,\n// structs in topological dependency-first order.\nimport { ByteReader, ByteWriter } from './bytes';\nimport {\n  mpArrayHeader,\n  mpBinHeader,\n  mpBool,\n  mpF32,\n  mpF64,\n  mpInt,\n  mpMapHeader,\n  mpNil,\n  mpStr,\n  mpU8,\n  mpUint,\n  rdArrayLen,\n  rdBinLen,\n  rdBool,\n  rdF32,\n  rdF64,\n  rdInt,\n  rdMapLen,\n  rdNil,\n  rdStr,\n  rdUint,\n} from './msgpack';\nimport { parseSchemaText, SchemaData } from './schemaText';\nimport { EmbeddedSchemaName, SCHEMAS } from './schemas';\n\nexport type PropDesc =\n  | { kind: 'type' | 'array' | 'flatarray'; type: string }\n  | { kind: 'map'; key: string; value: string };\n\n/** Compact data form emitted by scripts/syncBrdbData.mjs:\n * 'T' = plain type, ['T'] = array, ['T', null] = flat array,\n * { K: 'V' } = map (single entry). */\nexport type SchemaSourceProp =\n  | string\n  | readonly [string]\n  | readonly [string, null]\n  | Readonly<Record<string, string>>;\n\nexport interface SchemaSource {\n  enums: Readonly<Record<string, Readonly<Record<string, number>>>>;\n  variants: Readonly<Record<string, readonly string[]>>;\n  structs: Readonly<Record<string, Readonly<Record<string, SchemaSourceProp>>>>;\n}\n\nfunction propFromSource(source: SchemaSourceProp, ctx: string): PropDesc {\n  if (typeof source === 'string') return { kind: 'type', type: source };\n  if (Array.isArray(source)) {\n    if (source.length === 1) return { kind: 'array', type: source[0] };\n    if (source.length === 2 && source[1] === null)\n      return { kind: 'flatarray', type: source[0] };\n    throw new Error(`brdb: invalid schema prop source at ${ctx}`);\n  }\n  const entries = Object.entries(source);\n  if (entries.length === 1)\n    return { kind: 'map', key: entries[0][0], value: entries[0][1] as string };\n  throw new Error(`brdb: invalid schema prop source at ${ctx}`);\n}\n\nexport type BrdbValue =\n  | number\n  | boolean\n  | string\n  | null\n  | BrdbValue[]\n  | { [field: string]: BrdbValue };\n\n/** A decoded variant value: which member the tag selected, plus its payload.\n * Kept tagged (rather than flattened like the reference reader) so that\n * decode -> encode round-trips byte-identically. */\nexport interface BrdbVariant {\n  $variant: string;\n  value: BrdbValue;\n}\n\n// The legacy (pre-variant-table) unions use fixed tags; the member names\n// match the named-variant vocabulary so both share one representation.\nconst LEGACY_WIRE_MEMBERS = [\n  'f64',\n  'i64',\n  'bool',\n  'weak_object',\n  'WireGraphExec',\n];\nconst LEGACY_PRIM_MATH_MEMBERS = ['f64', 'i64'];\n\nfunction asVariant(value: BrdbValue, ty: string): BrdbVariant {\n  if (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    typeof (value as { $variant?: unknown }).$variant === 'string'\n  )\n    return value as unknown as BrdbVariant;\n  throw new Error(`brdb: variant ${ty} requires a { $variant, value } wrapper`);\n}\n\nconst FLAT_SIZES: Record<string, number> = {\n  u8: 1,\n  i8: 1,\n  u16: 2,\n  i16: 2,\n  u32: 4,\n  i32: 4,\n  f32: 4,\n  u64: 8,\n  i64: 8,\n  f64: 8,\n};\n\nfunction readPropDesc(r: ByteReader): PropDesc {\n  const m = r.peek();\n  // Type: FixStr/Str8/Str16 only (Str32 descriptors are invalid in this format)\n  if ((m & 0xe0) === 0xa0 || m === 0xd9 || m === 0xda)\n    return { kind: 'type', type: rdStr(r) };\n  if ((m & 0xf0) === 0x90) {\n    const len = rdArrayLen(r);\n    if (len === 1) return { kind: 'array', type: rdStr(r) };\n    if (len === 2) {\n      const type = rdStr(r);\n      rdNil(r); // FlatArray is exactly [type, nil]\n      return { kind: 'flatarray', type };\n    }\n    throw new Error(`brdb: unsupported property array length ${len}`);\n  }\n  if ((m & 0xf0) === 0x80) {\n    const len = rdMapLen(r);\n    if (len !== 1)\n      throw new Error(`brdb: unsupported property map length ${len}`);\n    return { kind: 'map', key: rdStr(r), value: rdStr(r) };\n  }\n  throw new Error(`brdb: unsupported property marker 0x${m.toString(16)}`);\n}\n\nexport class BrdbSchema {\n  constructor(\n    readonly enums: Map<string, Map<string, number>>,\n    readonly variants: Map<string, string[]>,\n    readonly structs: Map<string, Map<string, PropDesc>>\n  ) {}\n\n  static fromText(text: string): BrdbSchema {\n    const { enums, variants, structs } = parseSchemaText(text);\n    return new BrdbSchema(enums, variants, structs);\n  }\n\n  /** Hydrate a schema from the generated data form (see SchemaSource). */\n  static fromData(data: SchemaSource): BrdbSchema {\n    const enums = new Map(\n      Object.entries(data.enums).map(([name, values]) => [\n        name,\n        new Map(Object.entries(values)),\n      ])\n    );\n    const variants = new Map(\n      Object.entries(data.variants).map(([name, members]) => [\n        name,\n        [...members],\n      ])\n    );\n    const structs = new Map(\n      Object.entries(data.structs).map(([name, props]) => [\n        name,\n        new Map(\n          Object.entries(props).map(([field, source]) => [\n            field,\n            propFromSource(source, `${name}.${field}`),\n          ])\n        ),\n      ])\n    );\n    return new BrdbSchema(enums, variants, structs);\n  }\n\n  static fromBinary(bytes: Uint8Array): BrdbSchema {\n    const r = new ByteReader(bytes);\n    const header = rdArrayLen(r);\n    if (header !== 2 && header !== 3)\n      throw new Error(`brdb: invalid schema header length ${header}`);\n    const enums = new Map<string, Map<string, number>>();\n    for (let i = 0, n = rdMapLen(r); i < n; i++) {\n      const name = rdStr(r);\n      const values = new Map<string, number>();\n      for (let j = 0, m = rdMapLen(r); j < m; j++)\n        values.set(rdStr(r), rdInt(r));\n      enums.set(name, values);\n    }\n    const variants = new Map<string, string[]>();\n    if (header === 3) {\n      for (let i = 0, n = rdMapLen(r); i < n; i++) {\n        const name = rdStr(r);\n        const members: string[] = [];\n        for (let j = 0, m = rdArrayLen(r); j < m; j++) members.push(rdStr(r));\n        variants.set(name, members);\n      }\n    }\n    const structs = new Map<string, Map<string, PropDesc>>();\n    for (let i = 0, n = rdMapLen(r); i < n; i++) {\n      const name = rdStr(r);\n      const props = new Map<string, PropDesc>();\n      for (let j = 0, m = rdMapLen(r); j < m; j++)\n        props.set(rdStr(r), readPropDesc(r));\n      structs.set(name, props);\n    }\n    if (r.remaining !== 0)\n      throw new Error(`brdb: ${r.remaining} trailing bytes after schema`);\n    return new BrdbSchema(enums, variants, structs);\n  }\n\n  /** Extract the named structs plus every type they transitively reference\n   * (sub-structs, enums, variants, and variant member types) into a\n   * self-contained subset. Primitive/unknown names are skipped. Uses a LIFO\n   * worklist; the result ORDER matches the reference implementation, and\n   * that order determines the serialized schema's bytes. */\n  extractStructsTransitive(seeds: Iterable<string>): SchemaData {\n    const enums = new Map<string, Map<string, number>>();\n    const variants = new Map<string, string[]>();\n    const structs = new Map<string, Map<string, PropDesc>>();\n    const seen = new Set<string>();\n    const work = [...seeds];\n    for (let name = work.pop(); name !== undefined; name = work.pop()) {\n      if (seen.has(name)) continue;\n      seen.add(name);\n      const variantMembers = this.variants.get(name);\n      if (variantMembers) {\n        work.push(...variantMembers);\n        variants.set(name, [...variantMembers]);\n        continue;\n      }\n      const enumValues = this.enums.get(name);\n      if (enumValues) {\n        enums.set(name, new Map(enumValues));\n        continue;\n      }\n      const props = this.structs.get(name);\n      if (props) {\n        const copy = new Map<string, PropDesc>();\n        for (const [field, prop] of props) {\n          if (prop.kind === 'map') work.push(prop.key, prop.value);\n          else work.push(prop.type);\n          copy.set(field, { ...prop });\n        }\n        structs.set(name, copy);\n      }\n      // else: primitive/unknown type, nothing to extract\n    }\n    return { enums, variants, structs };\n  }\n\n  /** Merge definitions into this schema. Existing names keep their position\n   * (and are replaced); new names append, matching the reference merge. */\n  merge(data: SchemaData): void {\n    for (const [name, values] of data.enums) this.enums.set(name, values);\n    for (const [name, members] of data.variants)\n      this.variants.set(name, members);\n    for (const [name, props] of data.structs) this.structs.set(name, props);\n  }\n\n  /** The zero value of a type: numbers 0, bool false, str '', asset refs\n   * null, arrays empty, structs recursive, enums ordinal 0, variants tag 0\n   * with the first member's zero value. */\n  zeroValue(ty: string): BrdbValue {\n    switch (ty) {\n      case 'u8':\n      case 'u16':\n      case 'u32':\n      case 'u64':\n      case 'i8':\n      case 'i16':\n      case 'i32':\n      case 'i64':\n      case 'f32':\n      case 'f64':\n        return 0;\n      case 'bool':\n        return false;\n      case 'str':\n        return '';\n      case 'class':\n      case 'object':\n      case 'weak_object':\n        return null;\n      case 'wire_graph_variant':\n      case 'wire_graph_prim_math_variant':\n        return { $variant: 'f64', value: 0 };\n    }\n    const variant = this.variants.get(ty);\n    if (variant) {\n      const first = variant[0];\n      if (first === undefined) throw new Error(`brdb: empty variant ${ty}`);\n      return { $variant: first, value: this.zeroValue(first) };\n    }\n    if (this.enums.has(ty)) return 0;\n    const struct = this.structs.get(ty);\n    if (struct) {\n      const obj: { [k: string]: BrdbValue } = {};\n      for (const [field, prop] of struct)\n        obj[field] = prop.kind === 'type' ? this.zeroValue(prop.type) : [];\n      return obj;\n    }\n    throw new Error(`brdb: unknown type ${ty}`);\n  }\n\n  /** Complete a partial struct value: present fields pass through, missing\n   * fields get their zero value. Unknown keys are an error. */\n  fillStruct(\n    structName: string,\n    partial: Readonly<Record<string, BrdbValue>>\n  ): Record<string, BrdbValue> {\n    const struct = this.structs.get(structName);\n    if (!struct) throw new Error(`brdb: unknown struct ${structName}`);\n    for (const key of Object.keys(partial))\n      if (!struct.has(key))\n        throw new Error(`brdb: ${structName} has no field '${key}'`);\n    const out: Record<string, BrdbValue> = {};\n    for (const [field, prop] of struct) {\n      const given = partial[field];\n      out[field] =\n        given !== undefined\n          ? given\n          : prop.kind === 'type'\n          ? this.zeroValue(prop.type)\n          : [];\n    }\n    return out;\n  }\n\n  // DFS post-order: a struct is emitted after every struct it references.\n  // Roots iterate in insertion order; deps in property declaration order\n  // (map: key then value).\n  topoStructOrder(): string[] {\n    const visited = new Set<string>();\n    const order: string[] = [];\n    const visit = (name: string) => {\n      if (visited.has(name)) return;\n      visited.add(name);\n      const props = this.structs.get(name);\n      if (props)\n        for (const prop of props.values()) {\n          const deps =\n            prop.kind === 'map' ? [prop.key, prop.value] : [prop.type];\n          for (const dep of deps) if (this.structs.has(dep)) visit(dep);\n        }\n      order.push(name);\n    };\n    for (const name of this.structs.keys()) visit(name);\n    return order;\n  }\n\n  toBinary(): Uint8Array {\n    const w = new ByteWriter();\n    // Always the 3-element form; an empty variants map is valid.\n    mpArrayHeader(w, 3);\n    mpMapHeader(w, this.enums.size);\n    for (const [name, values] of this.enums) {\n      mpStr(w, name);\n      mpMapHeader(w, values.size);\n      for (const [key, value] of values) {\n        mpStr(w, key);\n        mpInt(w, value);\n      }\n    }\n    mpMapHeader(w, this.variants.size);\n    for (const [name, members] of this.variants) {\n      mpStr(w, name);\n      mpArrayHeader(w, members.length);\n      for (const member of members) mpStr(w, member);\n    }\n    const order = this.topoStructOrder();\n    mpMapHeader(w, order.length);\n    for (const structName of order) {\n      const props = this.structs.get(structName)!;\n      mpStr(w, structName);\n      mpMapHeader(w, props.size);\n      for (const [propName, prop] of props) {\n        mpStr(w, propName);\n        switch (prop.kind) {\n          case 'type':\n            mpStr(w, prop.type);\n            break;\n          case 'array':\n            mpArrayHeader(w, 1);\n            mpStr(w, prop.type);\n            break;\n          case 'flatarray':\n            mpArrayHeader(w, 2);\n            mpStr(w, prop.type);\n            mpNil(w);\n            break;\n          case 'map':\n            mpMapHeader(w, 1);\n            mpStr(w, prop.key);\n            mpStr(w, prop.value);\n            break;\n        }\n      }\n    }\n    return w.toBytes();\n  }\n\n  flatTypeSize(ty: string): number {\n    const prim = FLAT_SIZES[ty];\n    if (prim) return prim;\n    const struct = this.structs.get(ty);\n    if (!struct) return 0;\n    let sum = 0;\n    for (const prop of struct.values())\n      sum += prop.kind === 'type' ? this.flatTypeSize(prop.type) : 0;\n    return sum;\n  }\n\n  writeValue(w: ByteWriter, ty: string, value: BrdbValue): void {\n    switch (ty) {\n      case 'u8':\n        return mpU8(w, value as number);\n      case 'u16':\n      case 'u32':\n      case 'u64':\n        return mpUint(w, value as number);\n      case 'i8':\n      case 'i16':\n      case 'i32':\n      case 'i64':\n        return mpInt(w, value as number);\n      case 'f32':\n        return mpF32(w, value as number);\n      case 'f64':\n        return mpF64(w, value as number);\n      case 'str':\n        return mpStr(w, value as string);\n      case 'bool':\n        return mpBool(w, value as boolean);\n      case 'class':\n      case 'object':\n      case 'weak_object':\n        // asset reference: index into external_asset_references; null = -1\n        if (value === null) return mpInt(w, -1);\n        return mpUint(w, value as number);\n      case 'wire_graph_variant':\n      case 'wire_graph_prim_math_variant':\n        return this.writeLegacyWireVariant(w, ty, value);\n    }\n    // Named variants (e.g. WireGraphVariant): uint tag (the member's index\n    // in the schema's ordered member list — resolved per schema, never\n    // hardcoded) followed by the member value.\n    const variantTy = this.variants.get(ty);\n    if (variantTy) {\n      const v = asVariant(value, ty);\n      const tag = variantTy.indexOf(v.$variant);\n      if (tag === -1)\n        throw new Error(\n          `brdb: '${v.$variant}' is not a member of variant ${ty}`\n        );\n      mpUint(w, tag);\n      return this.writeVariantPayload(w, v.$variant, v.value);\n    }\n    const enumTy = this.enums.get(ty);\n    if (enumTy) {\n      const ordinal = value as number;\n      if (ordinal < 0 || ordinal >= enumTy.size)\n        throw new RangeError(\n          `brdb: enum ${ty} ordinal ${ordinal} out of bounds`\n        );\n      return mpUint(w, ordinal); // ordinal, NOT the declared value\n    }\n    const struct = this.structs.get(ty);\n    if (struct) {\n      const obj = value as { [k: string]: BrdbValue };\n      for (const [field, prop] of struct) {\n        if (!(field in obj))\n          throw new Error(`brdb: missing struct field ${ty}.${field}`);\n        this.writeProperty(w, prop, obj[field], `${ty}.${field}`);\n      }\n      return;\n    }\n    throw new Error(`brdb: unknown type ${ty}`);\n  }\n\n  private writeVariantPayload(\n    w: ByteWriter,\n    member: string,\n    value: BrdbValue\n  ): void {\n    // weak_object payloads inside variants use the signed-int encoder for\n    // both null and non-null (matching the component write path); plain\n    // schema-typed asset refs use the uint encoder when set.\n    if (member === 'weak_object')\n      return mpInt(w, value === null ? -1 : (value as number));\n    this.writeValue(w, member, value);\n  }\n\n  private writeLegacyWireVariant(\n    w: ByteWriter,\n    ty: string,\n    value: BrdbValue\n  ): void {\n    const members =\n      ty === 'wire_graph_variant'\n        ? LEGACY_WIRE_MEMBERS\n        : LEGACY_PRIM_MATH_MEMBERS;\n    const v = asVariant(value, ty);\n    const tag = members.indexOf(v.$variant);\n    if (tag === -1)\n      throw new Error(`brdb: '${v.$variant}' is not a member of ${ty}`);\n    mpUint(w, tag);\n    switch (v.$variant) {\n      case 'f64':\n        return mpF64(w, v.value as number);\n      case 'i64':\n        return mpInt(w, v.value as number);\n      case 'bool':\n        return mpBool(w, v.value as boolean);\n      case 'weak_object':\n        return mpInt(w, v.value === null ? -1 : (v.value as number));\n      case 'WireGraphExec':\n        return; // no payload\n    }\n  }\n\n  private writeProperty(\n    w: ByteWriter,\n    prop: PropDesc,\n    value: BrdbValue,\n    ctx: string\n  ): void {\n    switch (prop.kind) {\n      case 'type':\n        return this.writeValue(w, prop.type, value);\n      case 'array': {\n        const arr = value as BrdbValue[];\n        mpArrayHeader(w, arr.length);\n        for (const item of arr) this.writeValue(w, prop.type, item);\n        return;\n      }\n      case 'flatarray': {\n        const arr = value as BrdbValue[];\n        const size = this.flatTypeSize(prop.type);\n        if (size === 0)\n          throw new Error(`brdb: invalid flat type ${prop.type} at ${ctx}`);\n        mpBinHeader(w, arr.length * size);\n        for (const item of arr) this.writeFlat(w, prop.type, item, ctx);\n        return;\n      }\n      case 'map':\n        // No shipped schema uses Map properties, and the format's reference\n        // reader/writer disagree on the wire form (BRDB.md §4.4 item 10).\n        throw new Error(`brdb: Map properties are unsupported (${ctx})`);\n    }\n  }\n\n  private writeFlat(\n    w: ByteWriter,\n    ty: string,\n    value: BrdbValue,\n    ctx: string\n  ): void {\n    switch (ty) {\n      case 'u8':\n        return w.u8(value as number);\n      case 'i8':\n        return w.i8(value as number);\n      case 'u16':\n        return w.u16le(value as number);\n      case 'i16':\n        return w.i16le(value as number);\n      case 'u32':\n        return w.u32le(value as number);\n      case 'i32':\n        return w.i32le(value as number);\n      case 'f32':\n        return w.f32le(value as number);\n      case 'f64':\n        return w.f64le(value as number);\n      case 'u64':\n        return w.u64le(BigInt(value as number));\n      case 'i64':\n        return w.i64le(BigInt(value as number));\n    }\n    const struct = this.structs.get(ty);\n    if (!struct) throw new Error(`brdb: invalid flat type ${ty} at ${ctx}`);\n    const obj = value as { [k: string]: BrdbValue };\n    for (const [field, prop] of struct) {\n      if (prop.kind !== 'type')\n        throw new Error(`brdb: flat struct ${ty} has non-flat field ${field}`);\n      if (!(field in obj))\n        throw new Error(`brdb: missing struct field ${ty}.${field}`);\n      this.writeFlat(w, prop.type, obj[field], `${ctx}.${field}`);\n    }\n  }\n\n  // A hostile .schema blob can declare a struct that references itself\n  // (directly or transitively) as a plain field, which would otherwise\n  // recurse forever consuming zero input bytes. depth is threaded through\n  // the decode-side walk only (readValue/readProperty); encode is\n  // unaffected since it always terminates against caller-supplied values.\n  private static readonly MAX_DECODE_DEPTH = 64;\n\n  readValue(r: ByteReader, ty: string, depth = 0): BrdbValue {\n    if (depth > BrdbSchema.MAX_DECODE_DEPTH)\n      throw new Error('brdb: schema recursion too deep');\n    switch (ty) {\n      case 'u8':\n      case 'u16':\n      case 'u32':\n      case 'u64':\n        return rdUint(r);\n      case 'i8':\n      case 'i16':\n      case 'i32':\n      case 'i64':\n        return rdInt(r);\n      case 'f32':\n        return rdF32(r);\n      case 'f64':\n        return rdF64(r);\n      case 'str':\n        return rdStr(r);\n      case 'bool':\n        return rdBool(r);\n      case 'class':\n      case 'object':\n      case 'weak_object': {\n        const id = rdInt(r);\n        return id < 0 ? null : id;\n      }\n      case 'wire_graph_variant':\n      case 'wire_graph_prim_math_variant':\n        return this.readLegacyWireVariant(r, ty);\n    }\n    // Named variant: uint tag indexes the schema's ordered member list.\n    const variantTy = this.variants.get(ty);\n    if (variantTy) {\n      const tag = rdUint(r);\n      const member = variantTy[tag];\n      if (member === undefined)\n        throw new Error(`brdb: unknown tag ${tag} for variant ${ty}`);\n      return { $variant: member, value: this.readValue(r, member, depth + 1) };\n    }\n    const enumTy = this.enums.get(ty);\n    if (enumTy) {\n      const ordinal = rdUint(r);\n      if (ordinal >= enumTy.size)\n        throw new RangeError(\n          `brdb: enum ${ty} ordinal ${ordinal} out of bounds`\n        );\n      return ordinal;\n    }\n    const struct = this.structs.get(ty);\n    if (struct) {\n      const obj: { [k: string]: BrdbValue } = {};\n      for (const [field, prop] of struct)\n        obj[field] = this.readProperty(r, prop, `${ty}.${field}`, depth + 1);\n      return obj;\n    }\n    throw new Error(`brdb: unknown type ${ty}`);\n  }\n\n  private readLegacyWireVariant(r: ByteReader, ty: string): BrdbValue {\n    const members =\n      ty === 'wire_graph_variant'\n        ? LEGACY_WIRE_MEMBERS\n        : LEGACY_PRIM_MATH_MEMBERS;\n    const tag = rdUint(r);\n    const member = members[tag];\n    switch (member) {\n      case 'f64':\n        return { $variant: member, value: rdF64(r) };\n      case 'i64':\n        return { $variant: member, value: rdInt(r) };\n      case 'bool':\n        return { $variant: member, value: rdBool(r) };\n      case 'weak_object': {\n        const id = rdInt(r);\n        return { $variant: member, value: id < 0 ? null : id };\n      }\n      case 'WireGraphExec':\n        return { $variant: member, value: null }; // no payload\n      default:\n        throw new Error(`brdb: unknown tag ${tag} for ${ty}`);\n    }\n  }\n\n  private readProperty(\n    r: ByteReader,\n    prop: PropDesc,\n    ctx: string,\n    depth = 0\n  ): BrdbValue {\n    switch (prop.kind) {\n      case 'type':\n        return this.readValue(r, prop.type, depth);\n      case 'array': {\n        const len = rdArrayLen(r);\n        const out: BrdbValue[] = [];\n        for (let i = 0; i < len; i++)\n          out.push(this.readValue(r, prop.type, depth));\n        return out;\n      }\n      case 'flatarray': {\n        const byteLen = rdBinLen(r);\n        const size = this.flatTypeSize(prop.type);\n        if (size === 0)\n          throw new Error(`brdb: invalid flat type ${prop.type} at ${ctx}`);\n        if (byteLen % size !== 0)\n          throw new Error(\n            `brdb: flat data length ${byteLen} not divisible by ${size} (${ctx})`\n          );\n        const out: BrdbValue[] = [];\n        for (let i = 0; i < byteLen / size; i++)\n          out.push(this.readFlat(r, prop.type, ctx));\n        return out;\n      }\n      case 'map':\n        throw new Error(`brdb: Map properties are unsupported (${ctx})`);\n    }\n  }\n\n  private readFlat(r: ByteReader, ty: string, ctx: string): BrdbValue {\n    switch (ty) {\n      case 'u8':\n        return r.u8();\n      case 'i8':\n        return r.i8();\n      case 'u16':\n        return r.u16le();\n      case 'i16':\n        return r.i16le();\n      case 'u32':\n        return r.u32le();\n      case 'i32':\n        return r.i32le();\n      case 'f32':\n        return r.f32le();\n      case 'f64':\n        return r.f64le();\n      case 'u64':\n      case 'i64': {\n        const v = ty === 'u64' ? r.u64le() : r.i64le();\n        if (\n          v > BigInt(Number.MAX_SAFE_INTEGER) ||\n          v < BigInt(Number.MIN_SAFE_INTEGER)\n        )\n          throw new RangeError(\n            `brdb: flat 64-bit value ${v} exceeds JS safe range`\n          );\n        return Number(v);\n      }\n    }\n    const struct = this.structs.get(ty);\n    if (!struct) throw new Error(`brdb: invalid flat type ${ty} at ${ctx}`);\n    const obj: { [k: string]: BrdbValue } = {};\n    for (const [field, prop] of struct) {\n      if (prop.kind !== 'type')\n        throw new Error(`brdb: flat struct ${ty} has non-flat field ${field}`);\n      obj[field] = this.readFlat(r, prop.type, `${ctx}.${field}`);\n    }\n    return obj;\n  }\n\n  encode(ty: string, value: BrdbValue): Uint8Array {\n    const w = new ByteWriter();\n    this.writeValue(w, ty, value);\n    return w.toBytes();\n  }\n\n  decode(bytes: Uint8Array, ty: string): BrdbValue {\n    const r = new ByteReader(bytes);\n    const value = this.readValue(r, ty);\n    if (r.remaining !== 0)\n      throw new Error(`brdb: ${r.remaining} trailing bytes after ${ty}`);\n    return value;\n  }\n}\n\nconst embeddedCache = new Map<string, BrdbSchema>();\n\nexport function embeddedSchema(name: EmbeddedSchemaName): BrdbSchema {\n  let schema = embeddedCache.get(name);\n  if (!schema) {\n    schema = BrdbSchema.fromData(SCHEMAS[name]);\n    embeddedCache.set(name, schema);\n  }\n  return schema;\n}\n","// WriteSaveObject -> brdb world tree -> .brz. Bricks, brdb-native\n// components, and wires; entities are a later phase.\nimport { DEFAULT_UUID } from '../brs/constants';\nimport type { WriteSaveObject } from '../brs/types';\nimport { BitFlags } from './bits';\nimport { BrzContainerOptions, Compressor, writeBrzContainer } from './brz';\nimport { ByteWriter } from './bytes';\nimport { isProceduralAsset } from './catalog';\nimport { COMPONENT_TYPE_STRUCTS } from './componentDb';\nimport { BrGuid, PUBLIC_GUID, uuidToGuid } from './guid';\nimport { file, folder, PendingEntry } from './pending';\nimport { BrdbSchema, BrdbValue, embeddedSchema } from './schema';\nimport { SCHEMAS } from './schemas';\n\nexport const CHUNK_SIZE = 2048;\nexport const CHUNK_HALF = 1024;\n\nexport interface BundleJson {\n  type: string;\n  iD: string;\n  name: string;\n  version: string;\n  tags: string[];\n  authors: string[];\n  createdAt: string;\n  updatedAt: string;\n  description: string;\n  dependencies: unknown[];\n  gameVersion: string;\n}\n\nexport interface WriteBrzOptions {\n  /** zstd compressor for blobs; omitted -> all blobs stored raw (valid, and\n   * what the byte-parity gates compare against). */\n  compress?: Compressor;\n  /** Meta/World.json environment. save.map is NOT used. Default \"Plate\". */\n  environment?: string;\n  /** Meta/Bundle.json field overrides. */\n  bundle?: Partial<BundleJson>;\n}\n\n/** A brdb-native component on a brick. Legacy brs components\n * (save.components / brick.components) are NOT converted. */\nexport interface BrdbComponentInput {\n  /** brdb component type name, e.g. 'Component_Internal_Seat' */\n  type: string;\n  /** fields of the component's data struct; omitted fields zero-fill */\n  data?: Record<string, BrdbValue>;\n}\n\nexport interface BrdbWireEndpointInput {\n  /** index into save.bricks */\n  brick_index: number;\n  /** brdb component type name (must be used by a brick in this save) */\n  component_type: string;\n  /** wire port name, e.g. 'Output' */\n  port: string;\n}\n\n/** A wire between two component ports, using brdb-native names. Legacy\n * save.wires (brs component names) are NOT converted. */\nexport interface BrdbWireInput {\n  source: BrdbWireEndpointInput;\n  target: BrdbWireEndpointInput;\n}\n\n/** brdb-native extras alongside the legacy save shape: bricks carry a\n * modern `components` ARRAY of typed inputs (replacing the legacy .brs\n * component map on that field, which is not converted) and the save\n * carries `wires`. */\nexport interface BrdbBrickExtras {\n  components?: BrdbComponentInput[];\n}\n\nexport interface BrdbSaveExtras {\n  wires?: BrdbWireInput[];\n}\n\n/** The legacy save shape plus the brdb-native extras. The brick-level\n * legacy `components` map and the save-level legacy `wires` list are\n * replaced by the modern forms. */\nexport type WriteBrzSave = Omit<WriteSaveObject, 'bricks' | 'wires'> & {\n  bricks: (Omit<WriteSaveObject['bricks'][number], 'components'> &\n    BrdbBrickExtras)[];\n} & BrdbSaveExtras;\n\n/** What the world writers accept: the modern shape, or an unmodified\n * legacy save (whose map-shaped `components` and legacy-named `wires`\n * are ignored rather than converted). */\nexport type WriteBrzInput = WriteBrzSave | WriteSaveObject;\n\nconst floorDiv = (a: number, n: number) => Math.floor(a / n);\nconst euclidMod = (a: number, n: number) => ((a % n) + n) % n;\n\nexport function toRelative(position: readonly number[]): {\n  chunk: [number, number, number];\n  rel: [number, number, number];\n} {\n  const chunk = position.map(v => floorDiv(v, CHUNK_SIZE)) as [\n    number,\n    number,\n    number\n  ];\n  const rel = position.map(v => euclidMod(v, CHUNK_SIZE) - CHUNK_HALF) as [\n    number,\n    number,\n    number\n  ];\n  return { chunk, rel };\n}\n\ninterface Brick {\n  assetName: string;\n  procedural: boolean;\n  size: [number, number, number];\n  position: [number, number, number];\n  direction: number;\n  rotation: number;\n  collision: {\n    player: boolean;\n    weapon: boolean;\n    interaction: boolean;\n    physics: boolean;\n  };\n  visible: boolean;\n  materialName: string;\n  intensity: number;\n  color: [number, number, number];\n  ownerIndex: number;\n  components: BrdbComponentInput[];\n}\n\nfunction normalizeBricks(save: WriteBrzInput): Brick[] {\n  const assets = save.brick_assets ?? ['PB_DefaultBrick'];\n  const materials = save.materials ?? ['BMC_Plastic'];\n  const numOwners = save.brick_owners?.length ?? 0;\n  return save.bricks.map((brick, i) => {\n    const at = `bricks[${i}]`;\n    // Only the modern array form is written; a legacy map-shaped .brs\n    // `components` object on a brick is ignored (not converted).\n    const componentInputs = Array.isArray(brick.components)\n      ? brick.components\n      : [];\n    const components = componentInputs.map((c, ci) => {\n      if (!COMPONENT_TYPE_STRUCTS.has(c.type))\n        throw new Error(\n          `brdb: ${at}.components[${ci}]: unknown component type '${c.type}'`\n        );\n      return c;\n    });\n    const assetName = assets[brick.asset_name_index ?? 0];\n    if (assetName === undefined)\n      throw new Error(\n        `brdb: ${at}: asset_name_index ${brick.asset_name_index} out of range`\n      );\n    const materialName = materials[brick.material_index ?? 0];\n    if (materialName === undefined)\n      throw new Error(\n        `brdb: ${at}: material_index ${brick.material_index} out of range`\n      );\n    const position = brick.position.map(v => {\n      if (!Number.isSafeInteger(v))\n        throw new Error(\n          `brdb: ${at}: position must be integers, got ${brick.position}`\n        );\n      if (!(v >= -32768 * CHUNK_SIZE && v <= 32768 * CHUNK_SIZE - 1))\n        throw new Error(\n          `brdb: ${at}: position ${v} outside the i16 chunk range`\n        );\n      return v;\n    }) as [number, number, number];\n    const size = brick.size.map(v => {\n      if (!Number.isInteger(v) || v < 0 || v > 0xffff)\n        throw new Error(\n          `brdb: ${at}: size components must be u16, got ${brick.size}`\n        );\n      return v;\n    }) as [number, number, number];\n    let collision: Brick['collision'];\n    if (typeof brick.collision === 'boolean') {\n      const b = brick.collision;\n      collision = { player: b, weapon: b, interaction: b, physics: b };\n    } else {\n      collision = {\n        player: brick.collision?.player ?? true,\n        weapon: brick.collision?.weapon ?? true,\n        interaction: brick.collision?.interaction ?? true,\n        physics: brick.collision?.physics ?? true,\n        // Collision.tool is not serialized in brdb (the column was removed)\n      };\n    }\n    let color: [number, number, number];\n    const c = brick.color;\n    if (typeof c === 'number') {\n      const entry = save.colors?.[c];\n      if (!entry)\n        throw new Error(`brdb: ${at}: color palette index ${c} out of range`);\n      color = [entry[0], entry[1], entry[2]]; // in-memory palette is RGBA\n    } else if (Array.isArray(c)) {\n      if (c.length < 3)\n        throw new Error(\n          `brdb: ${at}: color array must have at least 3 components`\n        );\n      color = [c[0], c[1], c[2]];\n    } else {\n      color = [255, 255, 255];\n    }\n    color = color.map((v, ci) => {\n      if (!Number.isInteger(v) || v < 0 || v > 255)\n        throw new Error(\n          `brdb: ${at}: resolved color component ${ci} must be u8, got ${v}`\n        );\n      return v;\n    }) as [number, number, number];\n    const intensity = brick.material_intensity ?? 5;\n    if (!Number.isInteger(intensity) || intensity < 0 || intensity > 255)\n      throw new Error(\n        `brdb: ${at}: material_intensity must be u8, got ${intensity}`\n      );\n    const ownerIndex = brick.owner_index ?? 0;\n    if (\n      !Number.isInteger(ownerIndex) ||\n      ownerIndex < 0 ||\n      ownerIndex > numOwners\n    )\n      throw new Error(\n        `brdb: ${at}: owner_index ${ownerIndex} out of range (0..${numOwners})`\n      );\n    return {\n      assetName,\n      procedural: isProceduralAsset(assetName),\n      size,\n      position,\n      direction: brick.direction ?? 4, // ZPositive\n      rotation: brick.rotation ?? 0, // Deg0\n      collision,\n      visible: brick.visibility ?? true,\n      materialName,\n      intensity,\n      color,\n      ownerIndex,\n      components,\n    };\n  });\n}\n\nclass Registry {\n  private map = new Map<string, number>();\n  add(name: string): number {\n    let i = this.map.get(name);\n    if (i === undefined) {\n      i = this.map.size;\n      this.map.set(name, i);\n    }\n    return i;\n  }\n  indexOf(name: string): number {\n    const i = this.map.get(name);\n    if (i === undefined) throw new Error(`brdb: registry miss for ${name}`);\n    return i;\n  }\n  has(name: string): boolean {\n    return this.map.has(name);\n  }\n  get names(): string[] {\n    return [...this.map.keys()];\n  }\n  get size(): number {\n    return this.map.size;\n  }\n}\n\n// Column packer for one chunk of the brick SoA.\nclass ChunkBuilder {\n  private sizeCounters: { AssetIndex: number; NumSizes: number }[] = [];\n  private sizes: { X: number; Y: number; Z: number }[] = [];\n  private typeIndices: number[] = [];\n  private ownerIndices: number[] = [];\n  private originalOwnerIndices: number[] = [];\n  private relPositions: { X: number; Y: number; Z: number }[] = [];\n  private orientations: number[] = [];\n  private colPlayer = new BitFlags();\n  private colPlayer1 = new BitFlags();\n  private colPlayer2 = new BitFlags();\n  private colPlayer3 = new BitFlags();\n  private colWeapon = new BitFlags();\n  private colInteraction = new BitFlags();\n  private colPhysics = new BitFlags();\n  private visibility = new BitFlags();\n  private materialIndices: number[] = [];\n  private colors: { R: number; G: number; B: number; A: number }[] = [];\n  private sizeIndexMap = new Map<string, number>();\n  private numBrickSizes = 0;\n  numBricks = 0;\n\n  addBrick(\n    b: Brick,\n    rel: [number, number, number],\n    reg: { materials: Registry; basic: Registry; procedural: Registry },\n    basicCount: number\n  ) {\n    let typeIndex: number;\n    if (!b.procedural) {\n      typeIndex = reg.basic.indexOf(b.assetName);\n    } else {\n      const tyIndex = reg.procedural.indexOf(b.assetName);\n      const key = `${tyIndex}:${b.size[0]},${b.size[1]},${b.size[2]}`;\n      let sizeIndex = this.sizeIndexMap.get(key);\n      if (sizeIndex === undefined) {\n        // slot = per-chunk running size count, offset past the basic assets\n        sizeIndex = this.numBrickSizes + basicCount;\n        const last = this.sizeCounters[this.sizeCounters.length - 1];\n        if (last && last.AssetIndex === tyIndex) {\n          // extend the tail run; the equal-size case is unreachable because\n          // a repeated (asset,size) pair hits sizeIndexMap above\n          last.NumSizes += 1;\n        } else {\n          this.sizeCounters.push({ AssetIndex: tyIndex, NumSizes: 1 });\n        }\n        this.sizes.push({ X: b.size[0], Y: b.size[1], Z: b.size[2] });\n        this.sizeIndexMap.set(key, sizeIndex);\n        this.numBrickSizes += 1;\n      }\n      typeIndex = sizeIndex;\n    }\n    this.typeIndices.push(typeIndex);\n    this.ownerIndices.push(b.ownerIndex);\n    this.originalOwnerIndices.push(b.ownerIndex); // mirrors owner (legacy rule)\n    this.relPositions.push({ X: rel[0], Y: rel[1], Z: rel[2] });\n    this.orientations.push(((b.direction & 0x7) << 2) | (b.rotation & 0x3));\n    this.colPlayer.push(b.collision.player);\n    this.colPlayer1.push(b.collision.player); // Player1..3 mirror player\n    this.colPlayer2.push(b.collision.player);\n    this.colPlayer3.push(b.collision.player);\n    this.colWeapon.push(b.collision.weapon);\n    this.colInteraction.push(b.collision.interaction);\n    this.colPhysics.push(b.collision.physics);\n    this.visibility.push(b.visible);\n    this.materialIndices.push(reg.materials.indexOf(b.materialName));\n    this.colors.push({\n      R: b.color[0],\n      G: b.color[1],\n      B: b.color[2],\n      A: b.intensity,\n    });\n    this.numBricks += 1;\n  }\n\n  toValue(proceduralBrickStartingIndex: number): BrdbValue {\n    return {\n      ProceduralBrickStartingIndex: proceduralBrickStartingIndex,\n      BrickSizeCounters: this.sizeCounters,\n      BrickSizes: this.sizes,\n      BrickTypeIndices: this.typeIndices,\n      OwnerIndices: this.ownerIndices,\n      OriginalOwnerIndices: this.originalOwnerIndices,\n      RelativePositions: this.relPositions,\n      Orientations: this.orientations,\n      CollisionFlags_Player: this.colPlayer.toValue(),\n      CollisionFlags_Player1: this.colPlayer1.toValue(),\n      CollisionFlags_Player2: this.colPlayer2.toValue(),\n      CollisionFlags_Player3: this.colPlayer3.toValue(),\n      CollisionFlags_Weapon: this.colWeapon.toValue(),\n      CollisionFlags_Interaction: this.colInteraction.toValue(),\n      CollisionFlags_Physics: this.colPhysics.toValue(),\n      VisibilityFlags: this.visibility.toValue(),\n      MaterialIndices: this.materialIndices,\n      ColorsAndAlphas: this.colors,\n      bColorsAreLinear: false, // new saves always store sRGB\n    };\n  }\n}\n\n// Column packer for one chunk's component SoA plus the trailing\n// per-instance data structs (appended back-to-back after the SoA; a type\n// whose data-struct slot is \"None\" contributes no trailing bytes).\nclass ComponentChunkBuilder {\n  private counters: { TypeIndex: number; NumInstances: number }[] = [];\n  private brickIndices: number[] = [];\n  private trailing: { structName: string; data: Record<string, BrdbValue> }[] =\n    [];\n  numComponents = 0;\n\n  add(\n    typeIndex: number,\n    brickIndex: number,\n    structName: string,\n    data: Record<string, BrdbValue>\n  ) {\n    // run-length counters merge only consecutive same-type instances\n    const last = this.counters[this.counters.length - 1];\n    if (last && last.TypeIndex === typeIndex) last.NumInstances += 1;\n    else this.counters.push({ TypeIndex: typeIndex, NumInstances: 1 });\n    this.brickIndices.push(brickIndex);\n    if (structName !== 'None') this.trailing.push({ structName, data });\n    this.numComponents += 1;\n  }\n\n  toBytes(schema: BrdbSchema): Uint8Array {\n    const w = new ByteWriter();\n    schema.writeValue(w, 'BRSavedComponentChunkSoA', {\n      ComponentTypeCounters: this.counters,\n      ComponentBrickIndices: this.brickIndices,\n      JointBrickIndices: [],\n      JointEntityReferences: [],\n      JointInitialRelativeOffsets: [],\n      JointInitialRelativeRotations: [],\n      MicrochipBrickIndices: [],\n      MicrochipBrickGridReferences: [],\n    });\n    for (const t of this.trailing)\n      schema.writeValue(\n        w,\n        t.structName,\n        schema.fillStruct(t.structName, t.data)\n      );\n    return w.toBytes();\n  }\n}\n\nexport function saveToPendingFs(\n  save: WriteBrzInput,\n  options: WriteBrzOptions = {}\n): PendingEntry[] {\n  const bricks = normalizeBricks(save);\n\n  // Registry pre-pass: material THEN asset, per brick, in brick order.\n  // Registration must complete before any chunk packs — procedural type\n  // indices embed the final basic-asset count.\n  const materials = new Registry();\n  const basic = new Registry();\n  const procedural = new Registry();\n  for (const b of bricks) {\n    materials.add(b.materialName);\n    (b.procedural ? procedural : basic).add(b.assetName);\n  }\n  if (materials.size > 256)\n    throw new Error(\n      `brdb: too many distinct materials (${materials.size}); MaterialIndices is u8 (max 256)`\n    );\n  const reg = { materials, basic, procedural };\n  const basicCount = basic.size;\n\n  // Component registries: type names first-seen across bricks, with the\n  // parallel data-struct column; port names come from the wires that use\n  // them (matching the reference writer's used-only registration).\n  const componentTypes = new Registry();\n  const componentStructNames: string[] = [];\n  for (const b of bricks)\n    for (const c of b.components) {\n      const before = componentTypes.size;\n      if (componentTypes.add(c.type) === before)\n        componentStructNames.push(COMPONENT_TYPE_STRUCTS.get(c.type)!);\n    }\n\n  // Legacy .brs wires name endpoints by brs component; only modern-shaped\n  // wires (component_type) are written, matching the components handling.\n  const wires = (save.wires ?? []).filter(\n    (w): w is BrdbWireInput => 'component_type' in w.source\n  );\n  const ports = new Registry();\n  wires.forEach((wire, wi) => {\n    for (const [role, end] of [\n      ['source', wire.source],\n      ['target', wire.target],\n    ] as const) {\n      if (\n        !Number.isInteger(end.brick_index) ||\n        end.brick_index < 0 ||\n        end.brick_index >= bricks.length\n      )\n        throw new Error(\n          `brdb: wires[${wi}].${role}: brick_index ${end.brick_index} out of range`\n        );\n      if (!componentTypes.has(end.component_type))\n        throw new Error(\n          `brdb: wires[${wi}].${role}: component type '${end.component_type}' is not used by any brick`\n        );\n      ports.add(end.port);\n    }\n  });\n\n  // ComponentsShared.schema: the minimal SoA scaffolding, plus (when\n  // components are used) the data structs actually referenced and their\n  // transitive dependencies pulled from the max catalog schema.\n  const componentsSchema = BrdbSchema.fromData(\n    SCHEMAS.BRSavedComponentChunkSoA\n  );\n  if (componentTypes.size > 0) {\n    const seeds: string[] = [];\n    for (const structName of componentStructNames)\n      if (structName !== 'None' && !seeds.includes(structName))\n        seeds.push(structName);\n    componentsSchema.merge(\n      embeddedSchema('BRSavedComponentChunkSoA_max').extractStructsTransitive(\n        seeds\n      )\n    );\n  }\n\n  // Owner table: row 0 = PUBLIC, then brick_owners\n  const ownerRows: { guid: BrGuid; name: string; display: string }[] = [\n    { guid: PUBLIC_GUID, name: 'PUBLIC', display: 'PUBLIC' },\n  ];\n  for (const o of save.brick_owners ?? []) {\n    ownerRows.push({\n      guid: uuidToGuid(o.id ?? DEFAULT_UUID),\n      name: o.name ?? 'Unknown',\n      display: o.display_name ?? o.name ?? 'Unknown',\n    });\n  }\n  const brickCounts = ownerRows.map(() => 0);\n  const componentCounts = ownerRows.map(() => 0);\n\n  // Chunking: first-seen chunk order (deterministic; the ChunkIndex SoA\n  // rows use the same order)\n  const chunkOrder: string[] = [];\n  const chunks = new Map<\n    string,\n    { index: [number, number, number]; builder: ChunkBuilder }\n  >();\n  const componentChunks = new Map<string, ComponentChunkBuilder>();\n  const brickLocations: {\n    key: string;\n    chunk: [number, number, number];\n    localIndex: number;\n  }[] = [];\n  for (const b of bricks) {\n    const { chunk, rel } = toRelative(b.position);\n    const key = chunk.join('_');\n    let entry = chunks.get(key);\n    if (!entry) {\n      entry = { index: chunk, builder: new ChunkBuilder() };\n      chunks.set(key, entry);\n      chunkOrder.push(key);\n    }\n    const localIndex = entry.builder.numBricks;\n    entry.builder.addBrick(b, rel, reg, basicCount);\n    brickLocations.push({ key, chunk, localIndex });\n    brickCounts[b.ownerIndex] += 1;\n    if (b.components.length > 0) {\n      componentCounts[b.ownerIndex] += b.components.length;\n      let componentBuilder = componentChunks.get(key);\n      if (!componentBuilder)\n        componentChunks.set(\n          key,\n          (componentBuilder = new ComponentChunkBuilder())\n        );\n      for (const c of b.components) {\n        const typeIndex = componentTypes.indexOf(c.type);\n        componentBuilder.add(\n          typeIndex,\n          localIndex,\n          componentStructNames[typeIndex],\n          c.data ?? {}\n        );\n      }\n    }\n  }\n\n  // Wires live in the TARGET's chunk. Local rows are same-chunk sources\n  // (the legacy writer is single-grid); anything else is a remote source\n  // carrying the source grid + chunk.\n  interface WireRows {\n    remoteSources: Record<string, BrdbValue>[];\n    localSources: Record<string, BrdbValue>[];\n    remoteTargets: Record<string, BrdbValue>[];\n    localTargets: Record<string, BrdbValue>[];\n  }\n  const wireChunks = new Map<string, WireRows>();\n  const chunkWireCounts = new Map<string, number>();\n  for (const wire of wires) {\n    const source = brickLocations[wire.source.brick_index];\n    const targetLoc = brickLocations[wire.target.brick_index];\n    const target = {\n      BrickIndexInChunk: targetLoc.localIndex,\n      ComponentTypeIndex: componentTypes.indexOf(wire.target.component_type),\n      PortIndex: ports.indexOf(wire.target.port),\n    };\n    let rows = wireChunks.get(targetLoc.key);\n    if (!rows)\n      wireChunks.set(\n        targetLoc.key,\n        (rows = {\n          remoteSources: [],\n          localSources: [],\n          remoteTargets: [],\n          localTargets: [],\n        })\n      );\n    chunkWireCounts.set(\n      targetLoc.key,\n      (chunkWireCounts.get(targetLoc.key) ?? 0) + 1\n    );\n    if (source.key === targetLoc.key) {\n      rows.localSources.push({\n        BrickIndexInChunk: source.localIndex,\n        ComponentTypeIndex: componentTypes.indexOf(wire.source.component_type),\n        PortIndex: ports.indexOf(wire.source.port),\n      });\n      rows.localTargets.push(target);\n    } else {\n      rows.remoteSources.push({\n        GridPersistentIndex: 1, // single (main) grid in the legacy writer\n        ChunkIndex: {\n          X: source.chunk[0],\n          Y: source.chunk[1],\n          Z: source.chunk[2],\n        },\n        BrickIndexInChunk: source.localIndex,\n        ComponentTypeIndex: componentTypes.indexOf(wire.source.component_type),\n        PortIndex: ports.indexOf(wire.source.port),\n      });\n      rows.remoteTargets.push(target);\n    }\n  }\n\n  const globalDataSchema = embeddedSchema('BRSavedGlobalDataSoA');\n  const ownersSchema = embeddedSchema('BRSavedOwnerTableSoA');\n  const chunkIndexSchema = embeddedSchema('BRSavedBrickChunkIndexSoA');\n  const chunkSchema = embeddedSchema('BRSavedBrickChunkSoA');\n  const wiresSchema = embeddedSchema('BRSavedWireChunkSoA');\n  const entityChunkIndexSchema = embeddedSchema('BRSavedEntityChunkIndexSoA');\n  const entitySchema = embeddedSchema('BRSavedEntityChunkSoA');\n\n  const globalDataMps = globalDataSchema.encode('BRSavedGlobalDataSoA', {\n    EntityTypeNames: [],\n    EntityDataClassNames: [],\n    BasicBrickAssetNames: basic.names,\n    ProceduralBrickAssetNames: procedural.names,\n    MaterialAssetNames: materials.names,\n    ComponentTypeNames: componentTypes.names,\n    ComponentDataStructNames: componentStructNames,\n    ComponentWirePortNames: ports.names,\n    ExternalAssetReferences: [],\n    GlobalGridEntityTypeIndex: -1,\n  });\n\n  const ownersMps = ownersSchema.encode('BRSavedOwnerTableSoA', {\n    UserIds: ownerRows.map(r => ({\n      A: r.guid.A,\n      B: r.guid.B,\n      C: r.guid.C,\n      D: r.guid.D,\n    })),\n    UserNames: ownerRows.map(r => r.name),\n    DisplayNames: ownerRows.map(r => r.display),\n    EntityCounts: ownerRows.map(() => 0),\n    BrickCounts: brickCounts,\n    ComponentCounts: componentCounts,\n    WireCounts: ownerRows.map(() => 0),\n  });\n\n  const chunkIndexMps = chunkIndexSchema.encode('BRSavedBrickChunkIndexSoA', {\n    Chunk3DIndices: chunkOrder.map(k => {\n      const [X, Y, Z] = chunks.get(k)!.index;\n      return { X, Y, Z };\n    }),\n    // origin chunk gets zero offsets; every other chunk (CHUNK_HALF)³\n    ChunkOffsets: chunkOrder.map(k => {\n      const zero = chunks.get(k)!.index.every(v => v === 0);\n      const off = zero ? 0 : CHUNK_HALF;\n      return { X: off, Y: off, Z: off };\n    }),\n    ChunkSizes: chunkOrder.map(() => CHUNK_SIZE),\n    NumBricks: chunkOrder.map(k => chunks.get(k)!.builder.numBricks),\n    NumComponents: chunkOrder.map(\n      k => componentChunks.get(k)?.numComponents ?? 0\n    ),\n    NumWires: chunkOrder.map(k => chunkWireCounts.get(k) ?? 0),\n  });\n\n  const entityChunkIndexMps = entityChunkIndexSchema.encode(\n    'BRSavedEntityChunkIndexSoA',\n    {\n      NextPersistentIndex: 2, // sub-grids/entities start at 2; none in phase 1\n      Chunk3DIndices: [],\n      NumEntities: [],\n    }\n  );\n\n  const utf8 = new TextEncoder();\n  const bundle: BundleJson = {\n    type: 'World',\n    iD: '00000000-0000-0000-0000-000000000000',\n    name: '',\n    version: '',\n    tags: [],\n    authors: save.author?.name ? [save.author.name] : [],\n    createdAt: '0001.01.01-00.00.00',\n    updatedAt: '0001.01.01-00.00.00',\n    description: save.description ?? 'A Generated World',\n    dependencies: [],\n    gameVersion: 'CL0',\n    ...options.bundle,\n  };\n\n  // Tree creation order below defines archive ids — it is part of the\n  // byte format; do not reorder.\n  const gridDir: PendingEntry[] = [['ChunkIndex.mps', file(chunkIndexMps)]];\n  if (chunkOrder.length > 0) {\n    gridDir.push([\n      'Chunks',\n      folder(\n        chunkOrder.map(k => [\n          `${k}.mps`,\n          file(\n            chunkSchema.encode(\n              'BRSavedBrickChunkSoA',\n              chunks.get(k)!.builder.toValue(basicCount)\n            )\n          ),\n        ])\n      ),\n    ]);\n  }\n  if (componentChunks.size > 0) {\n    gridDir.push([\n      'Components',\n      folder(\n        chunkOrder\n          .filter(k => componentChunks.has(k))\n          .map(k => [\n            `${k}.mps`,\n            file(componentChunks.get(k)!.toBytes(componentsSchema)),\n          ])\n      ),\n    ]);\n  }\n  if (wireChunks.size > 0) {\n    gridDir.push([\n      'Wires',\n      folder(\n        chunkOrder\n          .filter(k => wireChunks.has(k))\n          .map(k => {\n            const rows = wireChunks.get(k)!;\n            return [\n              `${k}.mps`,\n              file(\n                wiresSchema.encode('BRSavedWireChunkSoA', {\n                  RemoteWireSources: rows.remoteSources,\n                  LocalWireSources: rows.localSources,\n                  RemoteWireTargets: rows.remoteTargets,\n                  LocalWireTargets: rows.localTargets,\n                  PendingPropagationFlags: { Flags: [] },\n                })\n              ),\n            ];\n          })\n      ),\n    ]);\n  }\n  return [\n    [\n      'Meta',\n      folder([\n        ['Bundle.json', file(utf8.encode(JSON.stringify(bundle)))],\n        // Screenshot.jpg / Thumbnail.png: no content -> omitted entirely\n        [\n          'World.json',\n          file(\n            utf8.encode(\n              JSON.stringify({ environment: options.environment ?? 'Plate' })\n            )\n          ),\n        ],\n      ]),\n    ],\n    [\n      'World',\n      folder([\n        [\n          '0',\n          folder([\n            ['GlobalData.schema', file(globalDataSchema.toBinary())],\n            ['GlobalData.mps', file(globalDataMps)],\n            ['Owners.schema', file(ownersSchema.toBinary())],\n            ['Owners.mps', file(ownersMps)],\n            [\n              'Bricks',\n              folder([\n                ['ChunkIndexShared.schema', file(chunkIndexSchema.toBinary())],\n                ['ChunksShared.schema', file(chunkSchema.toBinary())],\n                ['WiresShared.schema', file(wiresSchema.toBinary())],\n                ['ComponentsShared.schema', file(componentsSchema.toBinary())],\n                ['Grids', folder([['1', folder(gridDir)]])],\n              ]),\n            ],\n            [\n              'Entities',\n              folder([\n                ['ChunkIndex.schema', file(entityChunkIndexSchema.toBinary())],\n                ['ChunkIndex.mps', file(entityChunkIndexMps)],\n                ['ChunksShared.schema', file(entitySchema.toBinary())],\n              ]),\n            ],\n          ]),\n        ],\n      ]),\n    ],\n  ];\n}\n\n/** Write a .brz world from a legacy .brs-shaped WriteSaveObject. A\n * builder-style world API for authoring saves from scratch is planned;\n * this entry point exists for converting existing saves. */\nexport function writeBrzLegacy(\n  save: WriteBrzInput,\n  options: WriteBrzOptions = {}\n): Uint8Array {\n  const containerOptions: BrzContainerOptions = { compress: options.compress };\n  return writeBrzContainer(saveToPendingFs(save, options), containerOptions);\n}\n","// Lazy .brz world reader. Schemas are parsed once and cached per archive\n// path; chunk payloads are decoded on demand (never all at once); grids and\n// entities are enumerated from the archive rather than assumed. Decoding\n// always uses the ARCHIVE's own schemas — game-authored files may carry\n// field sets that differ from the embedded (current) schemas, and a .brz\n// holds exactly one schema per category.\nimport type { Collision, Owner, Vector } from '../brs/types';\nimport { bit } from './bits';\nimport { ByteReader } from './bytes';\nimport { BrzReader } from './brz';\nimport { ENTITY_TYPE_STRUCTS } from './componentDb';\nimport type { FoundFile, WorldFs } from './fs';\nimport { guidToUuid } from './guid';\nimport { BrdbSchema, BrdbValue } from './schema';\nimport { BundleJson, CHUNK_HALF, CHUNK_SIZE } from './world';\n\nexport type { FoundFile, WorldFs } from './fs';\n\nexport const MAIN_GRID = 1;\n\nexport interface ChunkCoord {\n  x: number;\n  y: number;\n  z: number;\n}\n\nexport interface BrickChunkRef {\n  index: ChunkCoord;\n  offset: ChunkCoord;\n  size: number;\n  numBricks: number;\n  numComponents: number;\n  numWires: number;\n}\n\nexport interface EntityChunkRef {\n  index: ChunkCoord;\n  numEntities: number;\n}\n\nexport interface EntityChunkIndex {\n  nextPersistentIndex: number;\n  chunks: EntityChunkRef[];\n}\n\nexport interface ComponentInstance {\n  typeName: string;\n  structName: string | null;\n  /** the owning brick's local index within its chunk */\n  brickIndex: number;\n  data: Record<string, BrdbValue> | null;\n}\n\nexport interface WireEndpoint {\n  /** the endpoint brick's local index within its chunk */\n  brickIndex: number;\n  componentType: string;\n  port: string;\n}\n\nexport interface RemoteWireEndpoint extends WireEndpoint {\n  gridId: number;\n  chunk: ChunkCoord;\n}\n\nexport interface WireChunk {\n  /** wires whose source is in the same grid+chunk as the target */\n  local: Array<{ source: WireEndpoint; target: WireEndpoint }>;\n  /** wires whose source lives in another grid or chunk */\n  remote: Array<{ source: RemoteWireEndpoint; target: WireEndpoint }>;\n}\n\nexport interface EntityRecord {\n  typeName: string;\n  className: string | null;\n  persistentIndex: number;\n  ownerIndex: number;\n  originalOwnerIndex: number;\n  location: { X: number; Y: number; Z: number };\n  rotation: { X: number; Y: number; Z: number; W: number };\n  frozen: boolean;\n  sleeping: boolean;\n  linearVelocity: { X: number; Y: number; Z: number };\n  angularVelocity: { X: number; Y: number; Z: number };\n  colors: Record<string, BrdbValue>;\n  remainingLifeSpan: number;\n  data: Record<string, BrdbValue> | null;\n}\n\nexport interface BrzWorldBrick {\n  asset_name_index: number;\n  size: Vector;\n  position: Vector;\n  direction: number;\n  rotation: number;\n  collision: Collision;\n  visibility: boolean;\n  material_index: number;\n  material_intensity: number;\n  color: [number, number, number];\n  owner_index: number;\n}\n\n/** Convert one linear-light color channel (0-255) to sRGB. Saves whose\n * colors are stored linear (bColorsAreLinear true, or the field missing\n * entirely on older saves) need this on read; new saves store sRGB already\n * and skip the conversion. Values at or below 0x0F scale into a 15-wide\n * range instead of 255, matching the low-value storage convention used\n * throughout the color format. */\nexport function linearToSrgb(v: number): number {\n  const scale = v <= 0x0f ? 15 : 255;\n  return Math.trunc(Math.pow(v / 255, 1 / 2.2) * scale);\n}\n\n/** Convert one brick color's R/G/B from linear to sRGB, leaving A (material\n * intensity) untouched. */\nfunction colorToSrgb<T extends { R: number; G: number; B: number }>(c: T): T {\n  return {\n    ...c,\n    R: linearToSrgb(c.R),\n    G: linearToSrgb(c.G),\n    B: linearToSrgb(c.B),\n  };\n}\n\n/** Convert every Color0..Color7 slot of an entity's packed colors struct\n * from linear to sRGB, leaving each slot's A untouched. */\nfunction entityColorsToSrgb(\n  colors: Record<string, BrdbValue>\n): Record<string, BrdbValue> {\n  const out: Record<string, BrdbValue> = {};\n  for (const [key, value] of Object.entries(colors))\n    out[key] = colorToSrgb(\n      value as { R: number; G: number; B: number; A: number }\n    );\n  return out;\n}\n\n/** Expand one decoded brick chunk SoA into bricks. Positions are relative to\n * the owning grid's origin (world origin for the main grid). */\nfunction decodeChunkBricks(\n  soa: any,\n  chunk: ChunkCoord,\n  basicCount: number\n): BrzWorldBrick[] {\n  // Expand the run-length size table: slot s belongs to the counter\n  // covering it; BrickSizes[s] is its size. Bound the expansion by the real\n  // payload (a hostile/corrupt chunk could otherwise claim billions of\n  // slots from a single counter): the total must not exceed BrickSizes.\n  let totalNumSizes = 0;\n  for (const counter of soa.BrickSizeCounters)\n    totalNumSizes += counter.NumSizes;\n  if (totalNumSizes < 0 || totalNumSizes > soa.BrickSizes.length)\n    throw new Error('brdb: brick size counters exceed size table');\n  const slotAssets: number[] = [];\n  for (const counter of soa.BrickSizeCounters)\n    for (let s = 0; s < counter.NumSizes; s++)\n      slotAssets.push(counter.AssetIndex);\n  const start: number = soa.ProceduralBrickStartingIndex;\n  // Saves whose colors are stored linear (older saves, or the field simply\n  // absent from this archive's schema) need converting to sRGB on read; new\n  // saves write bColorsAreLinear = false and are returned unchanged.\n  const linear: boolean = soa.bColorsAreLinear ?? true;\n\n  const bricks: BrzWorldBrick[] = [];\n  for (let i = 0; i < soa.BrickTypeIndices.length; i++) {\n    const ty: number = soa.BrickTypeIndices[i];\n    let asset_name_index: number;\n    let size: Vector;\n    if (ty < start) {\n      asset_name_index = ty; // basic: same index in the combined list\n      size = [0, 0, 0];\n    } else {\n      const slot = ty - start;\n      const sz = soa.BrickSizes[slot];\n      if (sz === undefined || slotAssets[slot] === undefined)\n        throw new Error(`brdb: invalid procedural size slot ${slot}`);\n      asset_name_index = basicCount + slotAssets[slot];\n      size = [sz.X, sz.Y, sz.Z];\n    }\n    const rel = soa.RelativePositions[i];\n    const orientation: number = soa.Orientations[i];\n    const rawColor = soa.ColorsAndAlphas[i];\n    const color = linear ? colorToSrgb(rawColor) : rawColor;\n    bricks.push({\n      asset_name_index,\n      size,\n      position: [\n        chunk.x * CHUNK_SIZE + CHUNK_HALF + rel.X,\n        chunk.y * CHUNK_SIZE + CHUNK_HALF + rel.Y,\n        chunk.z * CHUNK_SIZE + CHUNK_HALF + rel.Z,\n      ],\n      direction: (orientation >> 2) & 0x7,\n      rotation: orientation & 0x3,\n      collision: {\n        player: bit(soa.CollisionFlags_Player, i),\n        weapon: bit(soa.CollisionFlags_Weapon, i),\n        interaction: bit(soa.CollisionFlags_Interaction, i),\n        tool: true, // not stored in brdb\n        physics: bit(soa.CollisionFlags_Physics, i),\n      },\n      visibility: bit(soa.VisibilityFlags, i),\n      material_index: soa.MaterialIndices[i],\n      material_intensity: color.A,\n      color: [color.R, color.G, color.B],\n      owner_index: soa.OwnerIndices[i],\n    });\n  }\n  return bricks;\n}\n\n/** Reads a .brz or .brdb world lazily through a WorldFs. Schema blobs and\n * decoded metadata (GlobalData, Owners, Bundle/World JSON) are cached for\n * the lifetime of the reader; chunk payloads are always decoded fresh. For\n * a .brz this is safe by construction (the archive never changes), but a\n * reader built over a live Brdb (Brdb.worldReader()) must not be reused\n * across a write to that database: construct a new reader afterward so\n * cached metadata cannot mix with newly written chunk data. */\nexport class WorldReader {\n  private schemas = new Map<string, BrdbSchema>();\n  private values = new Map<string, unknown>();\n\n  constructor(readonly fs: WorldFs, readonly worldId: number = 0) {}\n\n  static from(data: Uint8Array): WorldReader {\n    return new WorldReader(BrzReader.from(data));\n  }\n\n  private path(rel: string): string {\n    return `World/${this.worldId}/${rel}`;\n  }\n\n  /** Parse a .schema blob once per revision; later calls return the cached\n   * schema. The public form resolves the schema file's own (latest)\n   * revision. */\n  schema(path: string): BrdbSchema {\n    const found = this.fs.findFileByPath(path);\n    if (!found) throw new Error(`brdb: file not found: ${path}`);\n    return this.schemaAt(path, found.createdAt);\n  }\n\n  /** Schema as it existed at `revision` (a created_at timestamp). Schemas\n   * evolve over a world's history; data files must decode with the schema\n   * revision that was live when they were written. */\n  private schemaAt(path: string, revision: number): BrdbSchema {\n    const key = `${path}@${revision}`;\n    let schema = this.schemas.get(key);\n    if (!schema) {\n      const found = this.fs.findFileByPathAtRevision(path, revision);\n      if (!found)\n        throw new Error(`brdb: file not found: ${path} at ${revision}`);\n      schema = BrdbSchema.fromBinary(this.fs.readBlob(found.contentId));\n      this.schemas.set(key, schema);\n    }\n    return schema;\n  }\n\n  private decode(mpsPath: string, schemaPath: string, struct: string): any {\n    const found = this.fs.findFileByPath(mpsPath);\n    if (!found) throw new Error(`brdb: file not found: ${mpsPath}`);\n    return this.schemaAt(schemaPath, found.createdAt).decode(\n      this.fs.readBlob(found.contentId),\n      struct\n    );\n  }\n\n  private cached<T>(key: string, load: () => T): T {\n    if (!this.values.has(key)) this.values.set(key, load());\n    return this.values.get(key) as T;\n  }\n\n  bundle(): BundleJson {\n    return this.cached('Meta/Bundle.json', () =>\n      JSON.parse(new TextDecoder().decode(this.fs.readFile('Meta/Bundle.json')))\n    );\n  }\n\n  environment(): { environment: string } {\n    return this.cached('Meta/World.json', () =>\n      JSON.parse(new TextDecoder().decode(this.fs.readFile('Meta/World.json')))\n    );\n  }\n\n  globalData(): any {\n    return this.cached(this.path('GlobalData.mps'), () =>\n      this.decode(\n        this.path('GlobalData.mps'),\n        this.path('GlobalData.schema'),\n        'BRSavedGlobalDataSoA'\n      )\n    );\n  }\n\n  owners(): any {\n    return this.cached(this.path('Owners.mps'), () =>\n      this.decode(\n        this.path('Owners.mps'),\n        this.path('Owners.schema'),\n        'BRSavedOwnerTableSoA'\n      )\n    );\n  }\n\n  /** Basic asset names followed by procedural — decoded brick\n   * asset_name_index values point into this combined list. */\n  brickAssets(): string[] {\n    const globalData = this.globalData();\n    return [\n      ...globalData.BasicBrickAssetNames,\n      ...globalData.ProceduralBrickAssetNames,\n    ];\n  }\n\n  materials(): string[] {\n    return this.globalData().MaterialAssetNames;\n  }\n\n  /** Owner rows 1.. (the PUBLIC row 0 is excluded). */\n  brickOwners(): Owner[] {\n    const owners = this.owners();\n    const out: Owner[] = [];\n    for (let i = 1; i < owners.UserNames.length; i++) {\n      out.push({\n        id: guidToUuid(owners.UserIds[i]),\n        name: owners.UserNames[i],\n        display_name: owners.DisplayNames[i],\n        bricks: owners.BrickCounts[i],\n      });\n    }\n    return out;\n  }\n\n  /** Grid ids under Bricks/Grids: 1 = the main grid, ≥2 = entity sub-grids. */\n  gridIds(): number[] {\n    return this.fs\n      .childFolders(this.path('Bricks/Grids'))\n      .map(Number)\n      .sort((a, b) => a - b);\n  }\n\n  brickChunkIndex(gridId: number = MAIN_GRID): BrickChunkRef[] {\n    const soa = this.decode(\n      this.path(`Bricks/Grids/${gridId}/ChunkIndex.mps`),\n      this.path('Bricks/ChunkIndexShared.schema'),\n      'BRSavedBrickChunkIndexSoA'\n    );\n    // ChunkOffsets/ChunkSizes were added to the format later; older worlds\n    // decode without them (the archive's own schema simply omits the\n    // keys), so default to a half-chunk offset and the standard chunk size.\n    return soa.Chunk3DIndices.map((c: any, i: number) => {\n      const off = soa.ChunkOffsets?.[i];\n      return {\n        index: { x: c.X, y: c.Y, z: c.Z },\n        offset: off\n          ? { x: off.X, y: off.Y, z: off.Z }\n          : { x: CHUNK_HALF, y: CHUNK_HALF, z: CHUNK_HALF },\n        size: soa.ChunkSizes?.[i] ?? CHUNK_SIZE,\n        numBricks: soa.NumBricks[i],\n        numComponents: soa.NumComponents[i],\n        numWires: soa.NumWires[i],\n      };\n    });\n  }\n\n  /** Decode one brick chunk's SoA. Not cached: chunk payloads are the bulk\n   * of an archive and are meant to be streamed, not retained. */\n  brickChunkSoa(gridId: number, chunk: ChunkCoord): any {\n    return this.decode(\n      this.path(\n        `Bricks/Grids/${gridId}/Chunks/${chunk.x}_${chunk.y}_${chunk.z}.mps`\n      ),\n      this.path('Bricks/ChunksShared.schema'),\n      'BRSavedBrickChunkSoA'\n    );\n  }\n\n  /** Lazily decode a grid's bricks, one chunk at a time. Positions are\n   * relative to the grid's origin: world origin for the main grid (1),\n   * entity-relative for sub-grids (≥2). */\n  *bricks(gridId: number = MAIN_GRID): Generator<BrzWorldBrick, void, void> {\n    const basicCount = this.globalData().BasicBrickAssetNames.length;\n    for (const ref of this.brickChunkIndex(gridId)) {\n      yield* decodeChunkBricks(\n        this.brickChunkSoa(gridId, ref.index),\n        ref.index,\n        basicCount\n      );\n    }\n  }\n\n  /** Entity chunk registry. */\n  entityChunkIndex(): EntityChunkIndex {\n    const soa = this.decode(\n      this.path('Entities/ChunkIndex.mps'),\n      this.path('Entities/ChunkIndex.schema'),\n      'BRSavedEntityChunkIndexSoA'\n    );\n    return {\n      nextPersistentIndex: soa.NextPersistentIndex,\n      chunks: soa.Chunk3DIndices.map((c: any, i: number) => ({\n        index: { x: c.X, y: c.Y, z: c.Z },\n        numEntities: soa.NumEntities[i],\n      })),\n    };\n  }\n\n  /** Decode a component chunk: the SoA plus each instance's trailing data\n   * struct. Instances stream in counter order; a type whose data-struct\n   * slot is missing or \"None\" contributes no trailing bytes. */\n  componentChunk(\n    gridId: number,\n    chunk: ChunkCoord\n  ): { soa: any; components: ComponentInstance[] } {\n    const mpsPath = this.path(\n      `Bricks/Grids/${gridId}/Components/${chunk.x}_${chunk.y}_${chunk.z}.mps`\n    );\n    const found = this.fs.findFileByPath(mpsPath);\n    if (!found) throw new Error(`brdb: file not found: ${mpsPath}`);\n    const bytes = this.fs.readBlob(found.contentId);\n    const schema = this.schemaAt(\n      this.path('Bricks/ComponentsShared.schema'),\n      found.createdAt\n    );\n    const globalData = this.globalData();\n    const r = new ByteReader(bytes);\n    const soa: any = schema.readValue(r, 'BRSavedComponentChunkSoA');\n    // A hostile/corrupt chunk could claim billions of instances from a\n    // single counter with no backing data; validate the total against the\n    // real row count before looping instead of allocating unbounded.\n    let totalInstances = 0;\n    for (const counter of soa.ComponentTypeCounters)\n      totalInstances += counter.NumInstances;\n    if (totalInstances !== soa.ComponentBrickIndices.length)\n      throw new Error(\n        'brdb: component counters do not match brick index count'\n      );\n\n    const components: ComponentInstance[] = [];\n    let stream = 0;\n    for (const counter of soa.ComponentTypeCounters) {\n      const typeName: string =\n        globalData.ComponentTypeNames[counter.TypeIndex] ?? '<invalid>';\n      const rawStruct: string | undefined =\n        globalData.ComponentDataStructNames[counter.TypeIndex];\n      const structName = rawStruct && rawStruct !== 'None' ? rawStruct : null;\n      for (let i = 0; i < counter.NumInstances; i++) {\n        components.push({\n          typeName,\n          structName,\n          brickIndex: soa.ComponentBrickIndices[stream],\n          data: structName\n            ? (schema.readValue(r, structName) as Record<string, BrdbValue>)\n            : null,\n        });\n        stream += 1;\n      }\n    }\n    if (r.remaining !== 0)\n      throw new Error(\n        `brdb: ${r.remaining} trailing bytes after component chunk`\n      );\n    return { soa, components };\n  }\n\n  /** Decode a wire chunk. Wires live in the TARGET's grid+chunk; local\n   * rows are same-grid-same-chunk sources, remote rows carry the source\n   * grid + chunk. Component/port names resolve through GlobalData. */\n  wireChunk(gridId: number, chunk: ChunkCoord): WireChunk {\n    const soa: any = this.decode(\n      this.path(\n        `Bricks/Grids/${gridId}/Wires/${chunk.x}_${chunk.y}_${chunk.z}.mps`\n      ),\n      this.path('Bricks/WiresShared.schema'),\n      'BRSavedWireChunkSoA'\n    );\n    const globalData = this.globalData();\n    const endpoint = (row: any): WireEndpoint => ({\n      brickIndex: row.BrickIndexInChunk,\n      componentType:\n        globalData.ComponentTypeNames[row.ComponentTypeIndex] ?? '<invalid>',\n      port: globalData.ComponentWirePortNames[row.PortIndex] ?? '<invalid>',\n    });\n    return {\n      local: soa.LocalWireSources.map((s: any, i: number) => ({\n        source: endpoint(s),\n        target: endpoint(soa.LocalWireTargets[i]),\n      })),\n      remote: soa.RemoteWireSources.map((s: any, i: number) => ({\n        source: {\n          ...endpoint(s),\n          gridId: s.GridPersistentIndex,\n          chunk: {\n            x: s.ChunkIndex.X,\n            y: s.ChunkIndex.Y,\n            z: s.ChunkIndex.Z,\n          },\n        },\n        target: endpoint(soa.RemoteWireTargets[i]),\n      })),\n    };\n  }\n\n  /** Decode one entity chunk: the SoA plus each entity's trailing data\n   * struct (gated on EntityDataClassNames: absent or \"None\" = no struct). */\n  entityChunk(chunk: ChunkCoord): EntityRecord[] {\n    const mpsPath = this.path(\n      `Entities/Chunks/${chunk.x}_${chunk.y}_${chunk.z}.mps`\n    );\n    const found = this.fs.findFileByPath(mpsPath);\n    if (!found) throw new Error(`brdb: file not found: ${mpsPath}`);\n    const bytes = this.fs.readBlob(found.contentId);\n    const schema = this.schemaAt(\n      this.path('Entities/ChunksShared.schema'),\n      found.createdAt\n    );\n    const globalData = this.globalData();\n    const r = new ByteReader(bytes);\n    const soa: any = schema.readValue(r, 'BRSavedEntityChunkSoA');\n    // A hostile/corrupt chunk could claim billions of entities from a\n    // single counter with no backing rows; validate the total against the\n    // real row count before looping instead of allocating unbounded.\n    let totalEntities = 0;\n    for (const counter of soa.TypeCounters)\n      totalEntities += counter.NumEntities;\n    if (totalEntities !== soa.PersistentIndices.length)\n      throw new Error(\n        'brdb: entity counters do not match persistent index count'\n      );\n    // Very old (legacy) worlds omit EntityDataClassNames from GlobalData\n    // entirely; fall back to the known entity-type-to-class table, using\n    // 'Unknown' for anything not in it (an 'Unknown' struct decode throws\n    // loudly below, same as the reference behavior for such saves).\n    const entityDataClassNames: string[] =\n      globalData.EntityDataClassNames ??\n      globalData.EntityTypeNames.map(\n        (n: string) => ENTITY_TYPE_STRUCTS.get(n) ?? 'Unknown'\n      );\n    // Colors are stored linear on older saves (or any save whose schema\n    // simply omits the flag); convert to sRGB on read, alpha untouched.\n    const entityColorsLinear: boolean = soa.bColorsAreLinear ?? true;\n\n    const entities: EntityRecord[] = [];\n    let index = 0;\n    for (const counter of soa.TypeCounters) {\n      const typeName: string =\n        globalData.EntityTypeNames[counter.TypeIndex] ?? '<invalid>';\n      const rawClass: string | undefined =\n        entityDataClassNames[counter.TypeIndex];\n      const className = rawClass && rawClass !== 'None' ? rawClass : null;\n      for (let i = 0; i < counter.NumEntities; i++) {\n        const rawColors = soa.ColorsAndAlphas[index];\n        entities.push({\n          typeName,\n          className,\n          persistentIndex: soa.PersistentIndices[index],\n          ownerIndex: soa.OwnerIndices[index],\n          // Added alongside the per-entity original-owner update; older\n          // saves omit this column and mirror the owner index instead.\n          originalOwnerIndex:\n            soa.OriginalOwnerIndices?.[index] ?? soa.OwnerIndices[index],\n          location: soa.Locations[index],\n          rotation: soa.Rotations[index],\n          frozen: bit(soa.PhysicsLockedFlags, index),\n          sleeping: bit(soa.PhysicsSleepingFlags, index),\n          linearVelocity: soa.LinearVelocities[index],\n          angularVelocity: soa.AngularVelocities[index],\n          colors: entityColorsLinear\n            ? entityColorsToSrgb(rawColors)\n            : rawColors,\n          remainingLifeSpan: soa.RemainingLifeSpans?.[index] ?? 0,\n          data: className\n            ? (schema.readValue(r, className) as Record<string, BrdbValue>)\n            : null,\n        });\n        index += 1;\n      }\n    }\n    if (r.remaining !== 0)\n      throw new Error(`brdb: ${r.remaining} trailing bytes after entity chunk`);\n    return entities;\n  }\n\n  /** Lazily decode every entity, one chunk at a time. */\n  *entities(): Generator<EntityRecord, void, void> {\n    for (const ref of this.entityChunkIndex().chunks)\n      yield* this.entityChunk(ref.index);\n  }\n}\n","// .brdb container: the same virtual filesystem as .brz, stored in SQLite\n// with content-addressed blobs and soft-delete revision history. This module\n// is engine-free: it speaks to any handle satisfying BrdbSqlite (better-\n// sqlite3 does structurally). The static openers below lazily load\n// better-sqlite3 so the web bundle never needs it.\nimport { blake3 } from '@noble/hashes/blake3.js';\nimport { decompress as zstdDecompress } from 'fzstd';\nimport type { Compressor } from './brz';\nimport type { FoundFile, WorldFs } from './fs';\nimport type { PendingEntry, PendingNode } from './pending';\nimport { WorldReader } from './reader';\nimport { saveToPendingFs, WriteBrzInput, WriteBrzOptions } from './world';\n\nexport interface BrdbStatement {\n  run(...params: unknown[]): { lastInsertRowid: number | bigint };\n  get(...params: unknown[]): unknown;\n  all(...params: unknown[]): unknown[];\n}\n\nexport interface BrdbSqlite {\n  exec(sql: string): unknown;\n  prepare(sql: string): BrdbStatement;\n  close(): void;\n}\n\nexport interface BrdbBlob {\n  blobId: number;\n  compression: number;\n  sizeUncompressed: number;\n  sizeCompressed: number;\n  deltaBaseId: number | null;\n  hash: Uint8Array;\n  content: Uint8Array;\n}\n\nexport interface BrdbRevision {\n  revisionId: number;\n  description: string;\n  createdAt: number;\n}\n\nexport interface WritePendingOptions {\n  /** Revision timestamp in unix seconds. Defaults to the wall clock. */\n  createdAt?: number;\n  /** Blob compressor. undefined uses the instance default (zstd level 14\n   * when opened through the lazy openers); null stores raw. */\n  compress?: Compressor | null;\n}\n\n// The exact statement text matters: SQLite stores CREATE statements verbatim\n// in sqlite_schema, and the parity suite compares this against databases\n// created by the reference implementation (whose DDL indents columns with\n// four tabs and closing parens with three).\nconst C = '\\n\\t\\t\\t\\t';\nconst E = '\\n\\t\\t\\t';\nexport const BRDB_SQLITE_SCHEMA =\n  `CREATE TABLE blobs (${C}blob_id INTEGER PRIMARY KEY,${C}compression INTEGER,` +\n  `${C}size_uncompressed INTEGER,${C}size_compressed INTEGER,` +\n  `${C}delta_base_id INTEGER REFERENCES blobs(blob_id),${C}hash BLOB,` +\n  `${C}content BLOB${E});\\n` +\n  `CREATE TABLE revisions (${C}revision_id INTEGER PRIMARY KEY,` +\n  `${C}description TEXT,${C}created_at INTEGER${E});\\n` +\n  `CREATE TABLE folders (${C}folder_id INTEGER PRIMARY KEY,` +\n  `${C}parent_id INTEGER REFERENCES folders(folder_id),${C}name TEXT,` +\n  `${C}created_at INTEGER,${C}deleted_at INTEGER${E});\\n` +\n  `CREATE TABLE files (${C}file_id INTEGER PRIMARY KEY,` +\n  `${C}parent_id INTEGER REFERENCES folders(folder_id),${C}name TEXT,` +\n  `${C}content_id INTEGER REFERENCES blobs(blob_id),${C}created_at INTEGER,` +\n  `${C}deleted_at INTEGER${E});\\n` +\n  'CREATE INDEX blobs_size_hash ON blobs(size_uncompressed, hash);\\n' +\n  'CREATE INDEX folders_parent_name_deleted ON folders(parent_id, name, deleted_at);\\n' +\n  'CREATE INDEX files_parent_name_deleted ON files(parent_id, name, deleted_at);';\n\nconst REQUIRED_TABLES = ['blobs', 'revisions', 'folders', 'files'] as const;\n\nconst now = () => Math.floor(Date.now() / 1000);\n\n// src/ stays isomorphic (no @types/node), so Buffer has no ambient type here.\n// This module-local declaration describes just enough of the real Node global\n// to type the guarded access below; it shadows (does not conflict with) the\n// full Node typing that test/tsconfig.json brings in for the test suite.\ndeclare const Buffer:\n  | {\n      from(\n        data: ArrayBufferLike | Uint8Array,\n        byteOffset?: number,\n        length?: number\n      ): Uint8Array;\n    }\n  | undefined;\n\n/** Bind bytes as a BLOB parameter. better-sqlite3 requires Buffer; when\n * unavailable (browser engines), pass the Uint8Array through. */\nconst asBlob = (bytes: Uint8Array): Uint8Array =>\n  typeof Buffer === 'undefined'\n    ? bytes\n    : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n\ndeclare const process: { getBuiltinModule?(name: string): any } | undefined;\n\n/** A node builtin without any import machinery (bundler inert and safe\n * under test runners that cannot compile dynamic import at runtime).\n * Null outside node or below Node 22.3. */\nconst builtin = (name: string): any => {\n  try {\n    return typeof process !== 'undefined'\n      ? process?.getBuiltinModule?.(name) ?? null\n      : null;\n  } catch {\n    return null;\n  }\n};\n\n/** Dynamic import kept opaque so bundlers never try to resolve engine or\n * node-builtin specifiers; the web bundle stays SQLite-free. Constructed\n * lazily so merely loading the library never evaluates code under a CSP\n * that bans eval. */\nlet dynamicImport: ((specifier: string) => Promise<any>) | null = null;\nconst loadModule = (specifier: string): Promise<any> => {\n  dynamicImport ??= new Function(\n    'specifier',\n    'return import(specifier)'\n  ) as any;\n  return dynamicImport!(specifier);\n};\n\ninterface SerializableSqlite extends BrdbSqlite {\n  serialize(): Uint8Array;\n}\n\nasync function engine(): Promise<\n  new (\n    source: string | Uint8Array,\n    options?: { readonly?: boolean; fileMustExist?: boolean }\n  ) => SerializableSqlite\n> {\n  try {\n    const mod: any = await (\n      Brdb.engineLoader ?? (() => loadModule('better-sqlite3'))\n    )();\n    return mod.default ?? mod;\n  } catch {\n    throw new Error(\n      'brdb: the Brdb openers require better-sqlite3 (npm install better-sqlite3), or wrap your own handle with new Brdb(db)'\n    );\n  }\n}\n\nfunction nodeZstd(): Compressor | null {\n  const zlib = builtin('node:zlib');\n  if (typeof zlib?.zstdCompressSync !== 'function') return null;\n  const level = zlib.constants.ZSTD_c_compressionLevel;\n  return data =>\n    new Uint8Array(zlib.zstdCompressSync(data, { params: { [level]: 14 } }));\n}\n\nexport class Brdb implements WorldFs {\n  /** Override how the better-sqlite3 module is resolved. Useful when a\n   * bundler or test runner cannot execute a native dynamic import. */\n  static engineLoader: (() => Promise<unknown>) | null = null;\n\n  /** zstd compressor applied to new blobs when no per-write compressor is\n   * given. The lazy openers set this; a directly-wrapped handle has none. */\n  defaultCompress: Compressor | null = null;\n\n  constructor(readonly db: BrdbSqlite) {\n    for (const t of REQUIRED_TABLES) {\n      const row = this.db\n        .prepare(\n          \"SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?\"\n        )\n        .get(t);\n      if (!row) throw new Error(`brdb: missing required table '${t}'`);\n    }\n  }\n\n  /** Create-container semantics on any handle: run the DDL and stamp the\n   * initial revision. */\n  static init(db: BrdbSqlite, createdAt: number = now()): Brdb {\n    db.exec(BRDB_SQLITE_SCHEMA);\n    const brdb = new Brdb(db);\n    brdb.createRevision('Initial Revision', createdAt);\n    return brdb;\n  }\n\n  /** Construct create/open semantics on a handle, closing it if construction\n   * (the DDL or the required-table guard) throws so a failed opener never\n   * leaks the underlying handle (and, on Windows, never leaves it locked). */\n  private static async wrap(db: BrdbSqlite, init: boolean): Promise<Brdb> {\n    try {\n      const brdb = init ? Brdb.init(db) : new Brdb(db);\n      brdb.defaultCompress = nodeZstd();\n      return brdb;\n    } catch (err) {\n      db.close();\n      throw err;\n    }\n  }\n\n  /** Open an existing database file. Rejects (without creating a file) when\n   * the path does not already exist. */\n  static async open(path: string): Promise<Brdb> {\n    return Brdb.wrap(\n      new (await engine())(path, { fileMustExist: true }),\n      false\n    );\n  }\n\n  /** Open an existing database file read-only. Rejects (without creating a\n   * file) when the path does not already exist. */\n  static async openReadonly(path: string): Promise<Brdb> {\n    return Brdb.wrap(\n      new (await engine())(path, { readonly: true, fileMustExist: true }),\n      false\n    );\n  }\n\n  /** Create a new database file (container schema + initial revision). */\n  static async create(path: string): Promise<Brdb> {\n    return Brdb.wrap(new (await engine())(path), true);\n  }\n\n  /** Open the file if it exists, otherwise create it. */\n  static async openOrCreate(path: string): Promise<Brdb> {\n    const fs = builtin('node:fs');\n    if (!fs)\n      throw new Error(\n        'brdb: openOrCreate requires node 22.3 or newer; call open or create explicitly'\n      );\n    return fs.existsSync(path) ? Brdb.open(path) : Brdb.create(path);\n  }\n\n  /** New in-memory database. */\n  static async memory(): Promise<Brdb> {\n    return Brdb.wrap(new (await engine())(':memory:'), true);\n  }\n\n  /** Open a database from serialized bytes. */\n  static async fromBytes(bytes: Uint8Array): Promise<Brdb> {\n    return Brdb.wrap(new (await engine())(Buffer.from(bytes)), false);\n  }\n\n  /** Serialize the database to bytes (requires a better-sqlite3 handle). */\n  toBytes(): Uint8Array {\n    const serialize = (this.db as Partial<SerializableSqlite>).serialize;\n    if (typeof serialize !== 'function')\n      throw new Error(\n        'brdb: toBytes requires a better-sqlite3 database handle'\n      );\n    return new Uint8Array(serialize.call(this.db));\n  }\n\n  /** Write a world save as one revision. */\n  save(\n    description: string,\n    save: WriteBrzInput,\n    options: Omit<WriteBrzOptions, 'compress'> & WritePendingOptions = {}\n  ): void {\n    this.writePending(description, saveToPendingFs(save, options), options);\n  }\n\n  /** Lazy world reader over this database (same surface as .brz reading).\n   * The reader caches decoded metadata (GlobalData, Owners, Bundle/World\n   * JSON) for its lifetime; if this Brdb is written to (save/writePending)\n   * after the reader is created, construct a fresh worldReader() rather\n   * than reusing the old one, or later reads may mix stale cached metadata\n   * with newly written chunk data. */\n  worldReader(): WorldReader {\n    return new WorldReader(this);\n  }\n\n  sqliteSchema(): string {\n    return (this.db.prepare('SELECT sql FROM sqlite_schema').all() as any[])\n      .map(r => r.sql)\n      .join('\\n');\n  }\n\n  createRevision(description: string, createdAt: number = now()): number {\n    return Number(\n      this.db\n        .prepare(\n          'INSERT INTO revisions (description, created_at) VALUES (?, ?);'\n        )\n        .run(description, createdAt).lastInsertRowid\n    );\n  }\n\n  revisions(): BrdbRevision[] {\n    return (\n      this.db\n        .prepare(\n          'SELECT revision_id, description, created_at FROM revisions ORDER BY revision_id;'\n        )\n        .all() as any[]\n    ).map(r => ({\n      revisionId: Number(r.revision_id),\n      description: String(r.description),\n      createdAt: Number(r.created_at),\n    }));\n  }\n\n  insertFolder(\n    name: string,\n    parentId: number | null,\n    createdAt: number\n  ): number {\n    return Number(\n      this.db\n        .prepare(\n          'INSERT INTO folders (name, parent_id, created_at) VALUES (?, ?, ?);'\n        )\n        .run(name, parentId, createdAt).lastInsertRowid\n    );\n  }\n\n  insertFile(\n    name: string,\n    parentId: number | null,\n    contentId: number,\n    createdAt: number\n  ): number {\n    return Number(\n      this.db\n        .prepare(\n          'INSERT INTO files (name, parent_id, content_id, created_at) VALUES (?, ?, ?, ?);'\n        )\n        .run(name, parentId, contentId, createdAt).lastInsertRowid\n    );\n  }\n\n  /** Insert a blob (dedup by hash + uncompressed size), compressing when the\n   * compressor yields something strictly smaller. */\n  insertBlob(\n    content: Uint8Array,\n    hash: Uint8Array,\n    compress: Compressor | null\n  ): number {\n    const existing = this.findBlobByHash(content.length, hash);\n    if (existing) return existing.blobId;\n    const sizeUncompressed = content.length;\n    let sizeCompressed = sizeUncompressed;\n    let compression = 0;\n    let stored = content;\n    const compressed = compress ? compress(content) : null;\n    if (compressed && compressed.length < sizeUncompressed) {\n      sizeCompressed = compressed.length;\n      compression = 1;\n      stored = compressed;\n    }\n    return Number(\n      this.db\n        .prepare(\n          'INSERT INTO blobs (compression, size_uncompressed, size_compressed, delta_base_id, hash, content) VALUES (?, ?, ?, ?, ?, ?);'\n        )\n        .run(\n          compression,\n          sizeUncompressed,\n          sizeCompressed,\n          null,\n          asBlob(hash),\n          asBlob(stored)\n        ).lastInsertRowid\n    );\n  }\n\n  findBlobByHash(size: number, hash: Uint8Array): BrdbBlob | null {\n    const row = this.db\n      .prepare(\n        'SELECT blob_id, compression, size_uncompressed, size_compressed, delta_base_id, hash, content FROM blobs WHERE hash = ? AND size_uncompressed = ? LIMIT 1;'\n      )\n      .get(asBlob(hash), size);\n    return row ? rowToBlob(row) : null;\n  }\n\n  findBlob(contentId: number): BrdbBlob {\n    const row = this.db\n      .prepare(\n        'SELECT blob_id, compression, size_uncompressed, size_compressed, delta_base_id, hash, content FROM blobs WHERE blob_id = ?;'\n      )\n      .get(contentId);\n    if (!row) throw new Error(`brdb: blob ${contentId} not found`);\n    return rowToBlob(row);\n  }\n\n  deleteFile(fileId: number, deletedAt: number): void {\n    this.db\n      .prepare('UPDATE files SET deleted_at = ? WHERE file_id = ?;')\n      .run(deletedAt, fileId);\n  }\n\n  deleteFolder(folderId: number, deletedAt: number): void {\n    this.db\n      .prepare('UPDATE folders SET deleted_at = ? WHERE folder_id = ?;')\n      .run(deletedAt, folderId);\n  }\n\n  findFolder(parentId: number | null, name: string): number | null {\n    const row = this.db\n      .prepare(\n        `SELECT folder_id FROM folders WHERE parent_id ${\n          parentId === null ? 'IS NULL' : '= ?'\n        } AND name = ? AND deleted_at IS NULL;`\n      )\n      .get(...(parentId === null ? [name] : [parentId, name]));\n    return row ? Number((row as any).folder_id) : null;\n  }\n\n  /** Like findFolder, but resolves against the tree as of a revision date\n   * instead of the current tree. Used by findFileByPathAtRevision so an\n   * ancestor folder that was soft-deleted after `date` does not hide a file\n   * that was still live at `date`. */\n  findFolderAtRevision(\n    parentId: number | null,\n    name: string,\n    date: number\n  ): number | null {\n    const row = this.db\n      .prepare(\n        `SELECT folder_id FROM folders WHERE parent_id ${\n          parentId === null ? 'IS NULL' : '= ?'\n        } AND name = ? AND created_at <= ? AND (deleted_at IS NULL OR deleted_at > ?) ORDER BY created_at ASC LIMIT 1;`\n      )\n      .get(\n        ...(parentId === null\n          ? [name, date, date]\n          : [parentId, name, date, date])\n      );\n    return row ? Number((row as any).folder_id) : null;\n  }\n\n  findFile(parentId: number | null, name: string): FoundFile | null {\n    const row = this.db\n      .prepare(\n        `SELECT content_id, created_at FROM files WHERE parent_id ${\n          parentId === null ? 'IS NULL' : '= ?'\n        } AND name = ? AND deleted_at IS NULL;`\n      )\n      .get(...(parentId === null ? [name] : [parentId, name]));\n    return row ? rowToFound(row) : null;\n  }\n\n  findFileAtRevision(\n    parentId: number | null,\n    name: string,\n    date: number\n  ): FoundFile | null {\n    const row = this.db\n      .prepare(\n        `SELECT content_id, created_at FROM files WHERE parent_id ${\n          parentId === null ? 'IS NULL' : '= ?'\n        } AND name = ? AND created_at <= ? AND (deleted_at IS NULL OR deleted_at > ?) ORDER BY created_at ASC LIMIT 1;`\n      )\n      .get(\n        ...(parentId === null\n          ? [name, date, date]\n          : [parentId, name, date, date])\n      );\n    return row ? rowToFound(row) : null;\n  }\n\n  close(): void {\n    this.db.close();\n  }\n\n  /** Merge a COMPLETE pending tree against the current tree in one\n   * transaction: identical files are noops, changed files are soft-deleted\n   * and reinserted, and existing entries absent from the pending tree are\n   * soft-deleted recursively. */\n  writePending(\n    description: string,\n    pending: PendingEntry[],\n    options: WritePendingOptions = {}\n  ): void {\n    const createdAt = options.createdAt ?? now();\n    const compress =\n      options.compress === undefined ? this.defaultCompress : options.compress;\n    this.db.exec('BEGIN');\n    try {\n      this.createRevision(description, createdAt);\n      this.mergeFolder(null, pending, createdAt, compress);\n      this.db.exec('COMMIT');\n    } catch (err) {\n      // Some SQLite error classes (SQLITE_FULL, SQLITE_IOERR, SQLITE_NOMEM)\n      // auto-rollback the transaction before the throw reaches here; an\n      // explicit ROLLBACK would then fail with its own unrelated error and\n      // mask the original one. Swallow that failure so `err` always wins.\n      try {\n        this.db.exec('ROLLBACK');\n      } catch {\n        // transaction already rolled back by SQLite\n      }\n      throw err;\n    }\n  }\n\n  private currentFolders(\n    parentId: number | null\n  ): { folderId: number; name: string }[] {\n    const stmt = this.db.prepare(\n      `SELECT folder_id, name FROM folders WHERE parent_id ${\n        parentId === null ? 'IS NULL' : '= ?'\n      } AND deleted_at IS NULL ORDER BY name;`\n    );\n    const rows = (parentId === null ? stmt.all() : stmt.all(parentId)) as any[];\n    return rows.map(r => ({\n      folderId: Number(r.folder_id),\n      name: String(r.name),\n    }));\n  }\n\n  private currentFiles(\n    parentId: number | null\n  ): { fileId: number; name: string; contentId: number | null }[] {\n    const stmt = this.db.prepare(\n      `SELECT file_id, name, content_id FROM files WHERE parent_id ${\n        parentId === null ? 'IS NULL' : '= ?'\n      } AND deleted_at IS NULL ORDER BY name;`\n    );\n    const rows = (parentId === null ? stmt.all() : stmt.all(parentId)) as any[];\n    return rows.map(r => ({\n      fileId: Number(r.file_id),\n      name: String(r.name),\n      contentId: r.content_id === null ? null : Number(r.content_id),\n    }));\n  }\n\n  private mergeFolder(\n    parentId: number | null,\n    changes: PendingEntry[],\n    createdAt: number,\n    compress: Compressor | null\n  ): void {\n    const folders = new Map(\n      this.currentFolders(parentId).map(f => [f.name, f.folderId])\n    );\n    const files = new Map(this.currentFiles(parentId).map(f => [f.name, f]));\n    const seen = new Set<string>();\n    for (const [name, node] of changes) {\n      if (seen.has(name))\n        throw new Error(`brdb: duplicate name '${name}' in pending tree`);\n      seen.add(name);\n      if (node.type === 'folder') {\n        if (files.has(name))\n          throw new Error(\n            `brdb: pending folder '${name}' collides with an existing file`\n          );\n        const existing = folders.get(name);\n        if (existing !== undefined)\n          this.mergeFolder(existing, node.children, createdAt, compress);\n        else this.insertPending(name, parentId, node, createdAt, compress);\n      } else {\n        if (folders.has(name))\n          throw new Error(\n            `brdb: pending file '${name}' collides with an existing folder`\n          );\n        const existing = files.get(name);\n        if (existing === undefined) {\n          this.insertPending(name, parentId, node, createdAt, compress);\n          continue;\n        }\n        const hash = blake3(node.content);\n        const blob = this.findBlobByHash(node.content.length, hash);\n        if (blob && existing.contentId === blob.blobId) continue;\n        this.deleteFile(existing.fileId, createdAt);\n        const contentId = this.insertBlob(node.content, hash, compress);\n        this.insertFile(name, parentId, contentId, createdAt);\n      }\n    }\n    for (const [name, folderId] of folders)\n      if (!seen.has(name)) this.deleteFolderRecursive(folderId, createdAt);\n    for (const [name, f] of files)\n      if (!seen.has(name)) this.deleteFile(f.fileId, createdAt);\n  }\n\n  private insertPending(\n    name: string,\n    parentId: number | null,\n    node: PendingNode,\n    createdAt: number,\n    compress: Compressor | null\n  ): void {\n    if (node.type === 'folder') {\n      // The reference writer stamps freshly-inserted folders with the wall\n      // clock rather than the revision timestamp; we use the revision\n      // timestamp for both (content-equivalent, deterministic under an\n      // injected createdAt).\n      const folderId = this.insertFolder(name, parentId, createdAt);\n      const seen = new Set<string>();\n      for (const [childName, child] of node.children) {\n        if (seen.has(childName))\n          throw new Error(\n            `brdb: duplicate name '${childName}' in pending tree`\n          );\n        seen.add(childName);\n        this.insertPending(childName, folderId, child, createdAt, compress);\n      }\n    } else {\n      const contentId = this.insertBlob(\n        node.content,\n        blake3(node.content),\n        compress\n      );\n      this.insertFile(name, parentId, contentId, createdAt);\n    }\n  }\n\n  private deleteFolderRecursive(folderId: number, deletedAt: number): void {\n    this.deleteFolder(folderId, deletedAt);\n    for (const child of this.currentFolders(folderId))\n      this.deleteFolderRecursive(child.folderId, deletedAt);\n    for (const f of this.currentFiles(folderId))\n      this.deleteFile(f.fileId, deletedAt);\n  }\n\n  /** Resolve a folder path. '' is the root. With no date, resolves against\n   * the current tree; with a date, resolves each segment against the tree\n   * as of that revision (see findFolderAtRevision). */\n  private folderIdOf(path: string, date?: number): number | null {\n    if (path === '') return null;\n    let id: number | null = null;\n    for (const part of path.split('/')) {\n      // Real crate-written databases stamp a freshly inserted folder with\n      // the wall clock mid-transaction, so a folder's created_at can be\n      // LATER than the files it contains (the revision/file timestamps are\n      // captured once at transaction start). When the at-revision lookup\n      // misses for that reason, fall back to the current tree so such an\n      // ancestor still resolves; a folder deleted after `date` is still\n      // caught by the at-revision branch first.\n      const next =\n        date === undefined\n          ? this.findFolder(id, part)\n          : this.findFolderAtRevision(id, part, date) ??\n            this.findFolder(id, part);\n      if (next === null) return null;\n      id = next;\n    }\n    return id;\n  }\n\n  findFileByPath(path: string): FoundFile | null {\n    if (path.startsWith('/'))\n      throw new Error('brdb: absolute paths not allowed');\n    const slash = path.lastIndexOf('/');\n    const parent = slash === -1 ? '' : path.slice(0, slash);\n    const parentId = this.folderIdOf(parent);\n    if (parent !== '' && parentId === null) return null;\n    return this.findFile(parentId, path.slice(slash + 1));\n  }\n\n  /** Both folders and the leaf file resolve against the tree as of `date`,\n   * so a file is still reachable at a date before an ancestor folder was\n   * later soft-deleted. */\n  findFileByPathAtRevision(path: string, date: number): FoundFile | null {\n    if (path.startsWith('/'))\n      throw new Error('brdb: absolute paths not allowed');\n    const slash = path.lastIndexOf('/');\n    const parent = slash === -1 ? '' : path.slice(0, slash);\n    const parentId = this.folderIdOf(parent, date);\n    if (parent !== '' && parentId === null) return null;\n    return this.findFileAtRevision(parentId, path.slice(slash + 1), date);\n  }\n\n  childFolders(path: string): string[] {\n    const parentId = this.folderIdOf(path);\n    if (path !== '' && parentId === null) return [];\n    return this.currentFolders(parentId).map(f => f.name);\n  }\n\n  childFiles(path: string): string[] {\n    const parentId = this.folderIdOf(path);\n    if (path !== '' && parentId === null) return [];\n    return this.currentFiles(parentId).map(f => f.name);\n  }\n\n  /** Decompressed blob content. Empty files (contentId -1) yield empty\n   * bytes, matching the .brz reader's documented deviation. */\n  readBlob(contentId: number): Uint8Array {\n    if (contentId === -1) return new Uint8Array(0);\n    const blob = this.findBlob(contentId);\n    if (blob.deltaBaseId !== null)\n      throw new Error('brdb: delta blobs are not supported');\n    let content = blob.content;\n    if (blob.compression === 1)\n      content = zstdDecompress(content, new Uint8Array(blob.sizeUncompressed));\n    else if (blob.compression !== 0)\n      throw new Error(`brdb: unknown blob compression ${blob.compression}`);\n    if (content.length !== blob.sizeUncompressed)\n      throw new Error('brdb: blob uncompressed size mismatch');\n    return content;\n  }\n\n  readFile(path: string): Uint8Array {\n    const found = this.findFileByPath(path);\n    if (!found) throw new Error(`brdb: file not found: ${path}`);\n    return this.readBlob(found.contentId);\n  }\n\n  /** The full current tree as a pending tree (folders first, then files,\n   * each in name order). */\n  toPending(): PendingEntry[] {\n    const walk = (parentId: number | null): PendingEntry[] => {\n      const out: PendingEntry[] = [];\n      for (const f of this.currentFolders(parentId))\n        out.push([f.name, { type: 'folder', children: walk(f.folderId) }]);\n      for (const f of this.currentFiles(parentId))\n        out.push([\n          f.name,\n          { type: 'file', content: this.readBlob(f.contentId ?? -1) },\n        ]);\n      return out;\n    };\n    return walk(null);\n  }\n}\n\nconst rowToBlob = (row: any): BrdbBlob => ({\n  blobId: Number(row.blob_id),\n  compression: Number(row.compression),\n  sizeUncompressed: Number(row.size_uncompressed),\n  sizeCompressed: Number(row.size_compressed),\n  deltaBaseId: row.delta_base_id === null ? null : Number(row.delta_base_id),\n  hash: new Uint8Array(row.hash),\n  content: new Uint8Array(row.content),\n});\n\nconst rowToFound = (row: any): FoundFile => ({\n  contentId: row.content_id === null ? -1 : Number(row.content_id),\n  createdAt: Number(row.created_at),\n});\n","export {\n  CHUNK_HALF,\n  CHUNK_SIZE,\n  saveToPendingFs,\n  toRelative,\n  writeBrzLegacy,\n} from './world';\nexport type {\n  BrdbBrickExtras,\n  BrdbComponentInput,\n  BrdbSaveExtras,\n  BrdbWireEndpointInput,\n  BrdbWireInput,\n  BundleJson,\n  WriteBrzInput,\n  WriteBrzOptions,\n  WriteBrzSave,\n} from './world';\nexport { MAIN_GRID, WorldReader } from './reader';\nexport type {\n  BrickChunkRef,\n  BrzWorldBrick,\n  ChunkCoord,\n  ComponentInstance,\n  EntityChunkIndex,\n  EntityChunkRef,\n  EntityRecord,\n  FoundFile,\n  RemoteWireEndpoint,\n  WireChunk,\n  WireEndpoint,\n  WorldFs,\n} from './reader';\nexport { BrzReader, writeBrzContainer } from './brz';\nexport type { BrzContainerOptions, Compressor } from './brz';\nexport { BrdbSchema, embeddedSchema } from './schema';\nexport type {\n  BrdbValue,\n  BrdbVariant,\n  PropDesc,\n  SchemaSource,\n  SchemaSourceProp,\n} from './schema';\nexport type { SchemaData } from './schemaText';\nexport type { EmbeddedSchemaName } from './schemas';\nexport { guidToUuid, PUBLIC_GUID, uuidToGuid } from './guid';\nexport type { BrGuid } from './guid';\nexport { file, folder } from './pending';\nexport type { PendingEntry, PendingNode } from './pending';\nexport { isProceduralAsset } from './catalog';\nexport { Brdb, BRDB_SQLITE_SCHEMA } from './brdb';\nexport type {\n  BrdbBlob,\n  BrdbRevision,\n  BrdbSqlite,\n  BrdbStatement,\n  WritePendingOptions,\n} from './brdb';\n// Low-level building blocks for custom SoA (de)serializers: the packed\n// bit-flag column helpers, the growable byte buffers, and the exact\n// msgpack primitives the format uses (including its encoding deviations).\nexport { bit, BitFlags } from './bits';\nexport { ByteReader, ByteWriter } from './bytes';\nexport * as msgpack from './msgpack';\n","import read from './brs/read';\nimport write from './brs/write';\nimport * as utils from './brs/utils';\nimport * as constants from './brs/constants';\nimport * as types from './brs/types';\nimport * as brdb from './brdb';\nexport * from './brs/types';\n\n// https://i.imgur.com/cv1fDWs.png\nconst brs = { read, write, utils, constants, types, brdb };\nexport { read, write, utils, constants, types, brdb };\nexport { Brdb, WorldReader, writeBrzLegacy } from './brdb';\nexport default brs;\n\nif (typeof window !== 'undefined') {\n  (window as any).BRS = brs;\n}\n"],"x_google_ignoreList":[1,16,17,18,19,20,21,22],"mappings":"qgBAEa,EAAQ,IAAI,WAAW,CAAC,GAAI,GAAI,EAAE,CAAC,EAEnC,EAAU,WACV,EAAqB,2tBCJlC,IAAI,EAAU,EACV,EAAW,EACX,EAAS,EACT,EAAY,EAChB,SAAS,EAAO,EAAK,CACpB,IAAI,EAAM,EAAI,OACd,KAAO,EAAE,GAAO,GAAG,EAAI,GAAO,CAC/B,CACA,IAAI,EAAe,EACf,EAAe,EACf,EAAY,EACZ,EAAe,GACf,EAAW,IACX,EAAU,IACV,EAAU,GACV,EAAW,GACX,EAAc,IACd,EAAW,GACX,EAAW,GACX,EAAc,EACd,EAAY,IACZ,EAAU,GACV,EAAY,GACZ,EAAc,GACd,EAAc,IAAI,WAAW,CAChC,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,CACD,CAAC,EACG,GAAc,IAAI,WAAW,CAChC,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,EACD,CAAC,EACG,GAAe,IAAI,WAAW,CACjC,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,CACD,CAAC,EACG,GAAW,IAAI,WAAW,CAC7B,GACA,GACA,GACA,EACA,EACA,EACA,EACA,EACA,GACA,EACA,GACA,EACA,GACA,EACA,GACA,EACA,GACA,EACA,EACD,CAAC,EACG,GAAgB,IAChB,GAAmB,MAAM,IAAM,CAAC,EACpC,EAAO,EAAY,EACnB,IAAI,GAAmB,MAAM,EAAU,CAAC,EACxC,EAAO,EAAY,EACnB,IAAI,GAAiB,MAAM,EAAa,EACxC,EAAO,EAAU,EACjB,IAAI,GAAmB,MAAM,GAAG,EAChC,EAAO,EAAY,EACnB,IAAI,GAAkB,MAAM,CAAY,EACxC,EAAO,EAAW,EAClB,IAAI,GAAgB,MAAM,CAAO,EACjC,EAAO,EAAS,EAChB,IAAI,GAAiB,KAAM,CAC1B,YAAY,EAAa,EAAY,EAAY,EAAO,EAAY,CACnE,KAAK,YAAc,EACnB,KAAK,WAAa,EAClB,KAAK,WAAa,EAClB,KAAK,MAAQ,EACb,KAAK,WAAa,EAClB,KAAK,UAAY,GAAe,EAAY,MAC7C,CACD,EACI,GACA,GACA,GACA,GAAW,KAAM,CACpB,YAAY,EAAU,EAAW,CAChC,KAAK,SAAW,EAChB,KAAK,SAAW,EAChB,KAAK,UAAY,CAClB,CACD,EACI,GAAU,GACN,EAAO,IAAM,GAAW,GAAQ,GAAW,KAAO,IAAS,IAE/D,IAAa,EAAG,IAAM,CACzB,EAAE,YAAY,EAAE,WAAa,EAAI,IACjC,EAAE,YAAY,EAAE,WAAa,IAAM,EAAI,GACxC,EACI,GAAa,EAAG,EAAO,IAAW,CACjC,EAAE,SAAW,EAAW,GAC3B,EAAE,QAAU,GAAS,EAAE,SAAW,MAClC,GAAU,EAAG,EAAE,MAAM,EACrB,EAAE,OAAS,GAAS,EAAW,EAAE,SACjC,EAAE,UAAY,EAAS,IAEvB,EAAE,QAAU,GAAS,EAAE,SAAW,MAClC,EAAE,UAAY,EAEhB,EACI,IAAa,EAAG,EAAG,IAAS,CAC/B,EAAU,EAAG,EAAK,EAAI,GAAI,EAAK,EAAI,EAAI,EAAE,CAC1C,EACI,IAAc,EAAM,IAAQ,CAC/B,IAAI,EAAM,EACV,EACC,IAAO,EAAO,EACd,KAAU,EACV,IAAQ,QACA,EAAE,EAAM,GACjB,OAAO,IAAQ,CAChB,EACI,GAAY,GAAM,CACjB,EAAE,WAAa,IAClB,GAAU,EAAG,EAAE,MAAM,EACrB,EAAE,OAAS,EACX,EAAE,SAAW,GACH,EAAE,UAAY,IACxB,EAAE,YAAY,EAAE,WAAa,EAAE,OAAS,IACxC,EAAE,SAAW,EACb,EAAE,UAAY,EAEhB,EACI,IAAc,EAAG,IAAS,CAC7B,IAAM,EAAO,EAAK,SACZ,EAAW,EAAK,SAChB,EAAQ,EAAK,UAAU,YACvB,EAAY,EAAK,UAAU,UAC3B,EAAQ,EAAK,UAAU,WACvB,EAAO,EAAK,UAAU,WACtB,EAAa,EAAK,UAAU,WAC9B,EACA,EAAG,EACH,EACA,EACA,EACA,EAAW,EACf,IAAK,EAAO,EAAG,GAAQ,EAAU,IAAQ,EAAE,SAAS,GAAQ,EAE5D,IADA,EAAK,EAAE,KAAK,EAAE,UAAY,EAAI,GAAK,EAC9B,EAAI,EAAE,SAAW,EAAG,EAAI,EAAa,IACzC,EAAI,EAAE,KAAK,GACX,EAAO,EAAK,EAAK,EAAI,EAAI,GAAK,EAAI,GAAK,EACnC,EAAO,IACV,EAAO,EACP,KAED,EAAK,EAAI,EAAI,GAAK,EACd,IAAI,KACR,EAAE,SAAS,EAAK,GAChB,EAAQ,EACJ,GAAK,IAAM,EAAQ,EAAM,EAAI,IACjC,EAAI,EAAK,EAAI,GACb,EAAE,SAAW,GAAK,EAAO,GACrB,IAAW,EAAE,YAAc,GAAK,EAAM,EAAI,EAAI,GAAK,KAEpD,OAAa,EACjB,GAAG,CAEF,IADA,EAAO,EAAa,EACb,EAAE,SAAS,KAAU,GAAG,IAC/B,EAAE,SAAS,EAAK,GAChB,EAAE,SAAS,EAAO,IAAM,EACxB,EAAE,SAAS,EAAW,GACtB,GAAY,CACb,OAAS,EAAW,GACpB,IAAK,EAAO,EAAY,IAAS,EAAG,IAEnC,IADA,EAAI,EAAE,SAAS,GACR,IAAM,GACZ,EAAI,EAAE,KAAK,EAAE,GACT,IAAI,KACJ,EAAK,EAAI,EAAI,KAAO,IACvB,EAAE,UAAY,EAAO,EAAK,EAAI,EAAI,IAAM,EAAK,EAAI,GACjD,EAAK,EAAI,EAAI,GAAK,GAEnB,IAVkB,CAarB,EACI,IAAa,EAAM,EAAU,IAAa,CAC7C,IAAM,EAAgB,MAAM,EAAE,EAC1B,EAAO,EACP,EACA,EACJ,IAAK,EAAO,EAAG,GAAQ,EAAU,IAChC,EAAO,EAAO,EAAS,EAAO,IAAM,EACpC,EAAU,GAAQ,EAEnB,IAAK,EAAI,EAAG,GAAK,EAAU,IAAK,CAC/B,IAAI,EAAM,EAAK,EAAI,EAAI,GACnB,IAAQ,IACZ,EAAK,EAAI,GAAK,GAAW,EAAU,EAAI,GAAI,CAAG,EAC/C,CACD,EACI,OAAuB,CAC1B,IAAI,EACA,EACA,EACA,EACA,EACE,EAAe,MAAM,EAAE,EAE7B,IADA,EAAS,EACJ,EAAO,EAAG,EAAO,EAAe,EAAG,IAEvC,IADA,GAAY,GAAQ,EACf,EAAI,EAAG,EAAI,GAAK,EAAY,GAAO,IAAK,GAAa,KAAY,EAIvE,IAFA,GAAa,EAAS,GAAK,EAC3B,EAAO,EACF,EAAO,EAAG,EAAO,GAAI,IAEzB,IADA,GAAU,GAAQ,EACb,EAAI,EAAG,EAAI,GAAK,GAAY,GAAO,IAAK,GAAW,KAAU,EAGnE,IADA,IAAS,EACF,EAAO,EAAS,IAEtB,IADA,GAAU,GAAQ,GAAQ,EACrB,EAAI,EAAG,EAAI,GAAK,GAAY,GAAQ,EAAG,IAAK,GAAW,IAAM,KAAU,EAE7E,IAAK,EAAO,EAAG,GAAQ,EAAU,IAAQ,EAAS,GAAQ,EAE1D,IADA,EAAI,EACG,GAAK,KACX,GAAa,EAAI,EAAI,GAAK,EAC1B,IACA,EAAS,EAAE,GAEZ,KAAO,GAAK,KACX,GAAa,EAAI,EAAI,GAAK,EAC1B,IACA,EAAS,EAAE,GAEZ,KAAO,GAAK,KACX,GAAa,EAAI,EAAI,GAAK,EAC1B,IACA,EAAS,EAAE,GAEZ,KAAO,GAAK,KACX,GAAa,EAAI,EAAI,GAAK,EAC1B,IACA,EAAS,EAAE,GAGZ,IADA,GAAU,GAAc,IAAK,CAAQ,EAChC,EAAI,EAAG,EAAI,EAAS,IACxB,GAAa,EAAI,EAAI,GAAK,EAC1B,GAAa,EAAI,GAAK,GAAW,EAAG,CAAC,EAEtC,GAAgB,IAAI,GAAe,GAAc,EAAa,IAAK,EAAS,CAAQ,EACpF,GAAgB,IAAI,GAAe,GAAc,GAAa,EAAG,EAAS,CAAQ,EAClF,GAAiB,IAAI,GAAe,CAAW,EAAG,GAAc,EAAG,EAAU,CAAW,CACzF,EACI,GAAc,GAAM,CACvB,IAAI,EACJ,IAAK,EAAI,EAAG,EAAI,EAAS,IAAK,EAAE,UAAU,EAAI,GAAK,EACnD,IAAK,EAAI,EAAG,EAAI,EAAS,IAAK,EAAE,UAAU,EAAI,GAAK,EACnD,IAAK,EAAI,EAAG,EAAI,EAAU,IAAK,EAAE,QAAQ,EAAI,GAAK,EAClD,EAAE,UAAU,EAAY,GAAK,EAC7B,EAAE,QAAU,EAAE,WAAa,EAC3B,EAAE,SAAW,EAAE,QAAU,CAC1B,EACI,GAAa,GAAM,CAClB,EAAE,SAAW,EAAG,GAAU,EAAG,EAAE,MAAM,EAChC,EAAE,SAAW,IAAG,EAAE,YAAY,EAAE,WAAa,EAAE,QACxD,EAAE,OAAS,EACX,EAAE,SAAW,CACd,EACI,IAAW,EAAM,EAAG,EAAG,IAAU,CACpC,IAAM,EAAM,EAAI,EACV,EAAM,EAAI,EAChB,OAAO,EAAK,GAAO,EAAK,IAAQ,EAAK,KAAS,EAAK,IAAQ,EAAM,IAAM,EAAM,EAC9E,EACI,IAAc,EAAG,EAAM,IAAM,CAChC,IAAM,EAAI,EAAE,KAAK,GACb,EAAI,GAAK,EACb,KAAO,GAAK,EAAE,WACT,EAAI,EAAE,UAAY,GAAQ,EAAM,EAAE,KAAK,EAAI,GAAI,EAAE,KAAK,GAAI,EAAE,KAAK,GAAG,IACpE,IAAQ,EAAM,EAAG,EAAE,KAAK,GAAI,EAAE,KAAK,IACvC,EAAE,KAAK,GAAK,EAAE,KAAK,GACnB,EAAI,EACJ,IAAM,EAEP,EAAE,KAAK,GAAK,CACb,EACI,IAAkB,EAAG,EAAO,IAAU,CACzC,IAAI,EACA,EACA,EAAK,EACL,EACA,EACJ,GAAI,EAAE,WAAa,EAAG,EACrB,GAAO,EAAE,YAAY,EAAE,QAAU,KAAQ,IACzC,IAAS,EAAE,YAAY,EAAE,QAAU,KAAQ,MAAQ,EACnD,EAAK,EAAE,YAAY,EAAE,QAAU,KAC3B,IAAS,EAAG,GAAU,EAAG,EAAI,CAAK,GAErC,EAAO,GAAa,GACpB,GAAU,EAAG,EAAO,EAAW,EAAG,CAAK,EACvC,EAAQ,EAAY,GAChB,IAAU,IACb,GAAM,GAAY,GAClB,EAAU,EAAG,EAAI,CAAK,GAEvB,IACA,EAAO,GAAO,CAAI,EAClB,GAAU,EAAG,EAAM,CAAK,EACxB,EAAQ,GAAY,GAChB,IAAU,IACb,GAAQ,GAAU,GAClB,EAAU,EAAG,EAAM,CAAK,UAGlB,EAAK,EAAE,UAChB,GAAU,EAAG,EAAW,CAAK,CAC9B,EACI,IAAc,EAAG,IAAS,CAC7B,IAAM,EAAO,EAAK,SACZ,EAAQ,EAAK,UAAU,YACvB,EAAY,EAAK,UAAU,UAC3B,EAAQ,EAAK,UAAU,MACzB,EAAG,EACH,EAAW,GACX,EAGJ,IAFA,EAAE,SAAW,EACb,EAAE,SAAW,EACR,EAAI,EAAG,EAAI,EAAO,IAAS,EAAK,EAAI,KAAO,EAGzC,EAAK,EAAI,EAAI,GAAK,GAFxB,EAAE,KAAK,EAAE,EAAE,UAAY,EAAW,EAClC,EAAE,MAAM,GAAK,GAEd,KAAO,EAAE,SAAW,GACnB,EAAO,EAAE,KAAK,EAAE,EAAE,UAAY,EAAW,EAAI,EAAE,EAAW,EAC1D,EAAK,EAAO,GAAK,EACjB,EAAE,MAAM,GAAQ,EAChB,EAAE,UACE,IAAW,EAAE,YAAc,EAAM,EAAO,EAAI,IAGjD,IADA,EAAK,SAAW,EACX,EAAI,EAAE,UAAY,EAAG,GAAK,EAAG,IAAK,GAAW,EAAG,EAAM,CAAC,EAC5D,EAAO,EACP,EAEC,GAAI,EAAE,KAAK,GACX,EAAE,KAAK,GAAK,EAAE,KAAK,EAAE,YACrB,GAAW,EAAG,EAAM,CAAC,EACrB,EAAI,EAAE,KAAK,GACX,EAAE,KAAK,EAAE,EAAE,UAAY,EACvB,EAAE,KAAK,EAAE,EAAE,UAAY,EACvB,EAAK,EAAO,GAAK,EAAK,EAAI,GAAK,EAAK,EAAI,GACxC,EAAE,MAAM,IAAS,EAAE,MAAM,IAAM,EAAE,MAAM,GAAK,EAAE,MAAM,GAAK,EAAE,MAAM,IAAM,EACvE,EAAK,EAAI,EAAI,GAAK,EAAK,EAAI,EAAI,GAAK,EACpC,EAAE,KAAK,GAAK,IACZ,GAAW,EAAG,EAAM,CAAC,QACb,EAAE,UAAY,GACvB,EAAE,KAAK,EAAE,EAAE,UAAY,EAAE,KAAK,GAC9B,GAAW,EAAG,CAAI,EAClB,GAAU,EAAM,EAAU,EAAE,QAAQ,CACrC,EACI,IAAa,EAAG,EAAM,IAAa,CACtC,IAAI,EACA,EAAU,GACV,EACA,EAAU,EAAK,GACf,EAAQ,EACR,EAAY,EACZ,EAAY,EAMhB,IALI,IAAY,IACf,EAAY,IACZ,EAAY,GAEb,GAAM,EAAW,GAAK,EAAI,GAAK,MAC1B,EAAI,EAAG,GAAK,EAAU,IAC1B,EAAS,EACT,EAAU,GAAM,EAAI,GAAK,EAAI,GACzB,IAAE,EAAQ,GAAa,IAAW,KAC7B,EAAQ,EAAW,EAAE,QAAQ,EAAS,IAAM,EAC5C,IAAW,EAGT,GAAS,GAAI,EAAE,QAAQ,EAAY,EAAE,GAC3C,EAAE,QAAQ,EAAc,EAAE,IAH1B,IAAW,GAAS,EAAE,QAAQ,EAAS,EAAE,GAC7C,EAAE,QAAQ,EAAU,EAAE,IAGvB,EAAQ,EACR,EAAU,EACN,IAAY,GACf,EAAY,IACZ,EAAY,GACF,IAAW,GACrB,EAAY,EACZ,EAAY,IAEZ,EAAY,EACZ,EAAY,GAGf,EACI,IAAa,EAAG,EAAM,IAAa,CACtC,IAAI,EACA,EAAU,GACV,EACA,EAAU,EAAK,GACf,EAAQ,EACR,EAAY,EACZ,EAAY,EAKhB,IAJI,IAAY,IACf,EAAY,IACZ,EAAY,GAER,EAAI,EAAG,GAAK,EAAU,IAC1B,KAAS,EACT,EAAU,GAAM,EAAI,GAAK,EAAI,GACzB,IAAE,EAAQ,GAAa,IAAW,GACjC,IAAI,EAAQ,EAAW,GAC3B,GAAU,EAAG,EAAQ,EAAE,OAAO,QACxB,EAAE,IAAU,QACV,IAAW,EAOT,GAAS,IACnB,GAAU,EAAG,EAAW,EAAE,OAAO,EACjC,EAAU,EAAG,EAAQ,EAAG,CAAC,IAEzB,GAAU,EAAG,EAAa,EAAE,OAAO,EACnC,EAAU,EAAG,EAAQ,GAAI,CAAC,IAXtB,IAAW,IACd,GAAU,EAAG,EAAQ,EAAE,OAAO,EAC9B,KAED,GAAU,EAAG,EAAS,EAAE,OAAO,EAC/B,EAAU,EAAG,EAAQ,EAAG,CAAC,GAQ1B,EAAQ,EACR,EAAU,EACN,IAAY,GACf,EAAY,IACZ,EAAY,GACF,IAAW,GACrB,EAAY,EACZ,EAAY,IAEZ,EAAY,EACZ,EAAY,EAXb,CAcF,EACI,GAAiB,GAAM,CAC1B,IAAI,EAIJ,IAHA,GAAU,EAAG,EAAE,UAAW,EAAE,OAAO,QAAQ,EAC3C,GAAU,EAAG,EAAE,UAAW,EAAE,OAAO,QAAQ,EAC3C,GAAW,EAAG,EAAE,OAAO,EAClB,EAAc,EAAW,EAAG,GAAe,GAAsB,EAAE,QAAQ,GAAS,GAAe,EAAI,KAAO,EAAhE,KAEnD,MADA,GAAE,SAAW,GAAK,EAAc,GAAK,EAAI,EAAI,EACtC,CACR,EACI,IAAkB,EAAG,EAAQ,EAAQ,IAAY,CACpD,IAAI,EAIJ,IAHA,EAAU,EAAG,EAAS,IAAK,CAAC,EAC5B,EAAU,EAAG,EAAS,EAAG,CAAC,EAC1B,EAAU,EAAG,EAAU,EAAG,CAAC,EACtB,EAAO,EAAG,EAAO,EAAS,IAAQ,EAAU,EAAG,EAAE,QAAQ,GAAS,GAAQ,EAAI,GAAI,CAAC,EACxF,GAAU,EAAG,EAAE,UAAW,EAAS,CAAC,EACpC,GAAU,EAAG,EAAE,UAAW,EAAS,CAAC,CACrC,EACI,GAAoB,GAAM,CAC7B,IAAI,EAAa,WACb,EACJ,IAAK,EAAI,EAAG,GAAK,GAAI,IAAK,KAAgB,EAAG,GAAI,EAAa,GAAK,EAAE,UAAU,EAAI,KAAO,EAAG,OAAO,EACpG,GAAI,EAAE,UAAU,MAAQ,GAAK,EAAE,UAAU,MAAQ,GAAK,EAAE,UAAU,MAAQ,EAAG,OAAO,EACpF,IAAK,EAAI,GAAI,EAAI,EAAU,IAAK,GAAI,EAAE,UAAU,EAAI,KAAO,EAAG,OAAO,EACrE,OAAO,CACR,EACI,GAAmB,GACnB,GAAY,GAAM,CAChB,KACJ,GAAe,EACf,GAAmB,IAEpB,EAAE,OAAS,IAAI,GAAS,EAAE,UAAW,EAAa,EAClD,EAAE,OAAS,IAAI,GAAS,EAAE,UAAW,EAAa,EAClD,EAAE,QAAU,IAAI,GAAS,EAAE,QAAS,EAAc,EAClD,EAAE,OAAS,EACX,EAAE,SAAW,EACb,GAAW,CAAC,CACb,EACI,IAAoB,EAAG,EAAK,EAAY,IAAS,CACpD,EAAU,GAAI,GAAgB,IAAM,KAAe,CAAC,EACpD,GAAU,CAAC,EACX,GAAU,EAAG,CAAU,EACvB,GAAU,EAAG,CAAC,CAAU,EACpB,GAAY,EAAE,YAAY,IAAI,EAAE,OAAO,SAAS,EAAK,EAAM,CAAU,EAAG,EAAE,OAAO,EACrF,EAAE,SAAW,CACd,EACI,GAAa,GAAM,CACtB,EAAU,EAAG,GAAgB,EAAG,CAAC,EACjC,GAAU,EAAG,EAAW,EAAY,EACpC,GAAS,CAAC,CACX,EACI,IAAmB,EAAG,EAAK,EAAY,IAAS,CACnD,IAAI,EAAU,EACV,EAAc,EACd,EAAE,MAAQ,GACT,EAAE,KAAK,YAAc,IAAW,EAAE,KAAK,UAAY,GAAiB,CAAC,GACzE,GAAW,EAAG,EAAE,MAAM,EACtB,GAAW,EAAG,EAAE,MAAM,EACtB,EAAc,GAAc,CAAC,EAC7B,EAAW,EAAE,QAAU,EAAI,IAAM,EACjC,EAAc,EAAE,WAAa,EAAI,IAAM,EACnC,GAAe,IAAU,EAAW,IAClC,EAAW,EAAc,EAAa,EACzC,EAAa,GAAK,GAAY,IAAQ,GAAI,GAAiB,EAAG,EAAK,EAAY,CAAI,EAC9E,EAAE,WAAa,GAAW,IAAgB,GAClD,EAAU,GAAI,GAAgB,IAAM,KAAe,CAAC,EACpD,GAAe,EAAG,GAAc,EAAY,IAE5C,EAAU,GAAI,GAAa,IAAM,KAAe,CAAC,EACjD,GAAe,EAAG,EAAE,OAAO,SAAW,EAAG,EAAE,OAAO,SAAW,EAAG,EAAc,CAAC,EAC/E,GAAe,EAAG,EAAE,UAAW,EAAE,SAAS,GAE3C,GAAW,CAAC,EACR,GAAM,GAAU,CAAC,CACtB,EACI,IAAa,EAAG,EAAM,KACzB,EAAE,YAAY,EAAE,QAAU,EAAE,YAAc,EAC1C,EAAE,YAAY,EAAE,QAAU,EAAE,YAAc,GAAQ,EAClD,EAAE,YAAY,EAAE,QAAU,EAAE,YAAc,EACtC,IAAS,EAAG,EAAE,UAAU,EAAK,EAAE,IAElC,EAAE,UACF,IACA,EAAE,WAAW,GAAa,GAAM,EAAW,GAAK,EAAE,GAClD,EAAE,UAAU,GAAO,CAAI,EAAI,EAAE,IAEvB,EAAE,WAAa,EAAE,SAIrB,IAAW,EAAO,EAAK,EAAK,IAAQ,CACvC,IAAI,EAAK,EAAQ,MAAQ,EAAG,EAAK,IAAU,GAAK,MAAQ,EAAG,EAAI,EAC/D,KAAO,IAAQ,GAAG,CACjB,EAAI,EAAM,IAAM,IAAM,EACtB,GAAO,EACP,EACC,GAAK,EAAK,EAAI,KAAS,EACvB,EAAK,EAAK,EAAK,QACP,EAAE,GACX,GAAM,MACN,GAAM,KACP,CACA,OAAO,EAAK,GAAM,GAAK,CACxB,EAYI,GAAW,IAAI,iBATG,CACrB,IAAI,EAAG,EAAQ,CAAC,EAChB,IAAK,IAAI,EAAI,EAAG,EAAI,IAAK,IAAK,CAC7B,EAAI,EACJ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,IAAK,EAAI,EAAI,EAAI,WAAa,IAAM,EAAI,IAAM,EACrE,EAAM,GAAK,CACZ,CACA,OAAO,CACR,EAC+B,CAAU,CAAC,EACtC,GAAS,EAAK,EAAK,EAAK,IAAQ,CACnC,IAAM,EAAI,GACJ,EAAM,EAAM,EAClB,GAAO,GACP,IAAK,IAAI,EAAI,EAAK,EAAI,EAAK,IAAK,EAAM,IAAQ,EAAI,GAAG,EAAM,EAAI,IAAM,KACrE,OAAO,EAAM,EACd,EAGI,GAAmB,CACtB,EAAG,kBACH,EAAG,aACH,EAAG,GACH,KAAM,aACN,KAAM,eACN,KAAM,aACN,KAAM,sBACN,KAAM,eACN,KAAM,sBACP,EAoBI,GAAgB,EAGhB,GAAY,IACZ,EAAY,EACZ,GAAY,IACZ,GAAgB,IAChB,GAAc,GACd,GAAa,GACb,GAAa,GACb,GAAc,GACd,GAAa,GACb,GAAgB,GAChB,GAAa,IACb,GAAa,IACb,GAAe,IACf,EAAe,EACf,GAAgB,EAChB,GAAoB,EACpB,GAAiB,EACjB,GAAU,EACVA,IAAO,EAAM,KAChB,EAAK,IAAM,GAAiB,GACrB,GAEJ,GAAQ,GACJ,EAAI,GAAK,EAAI,EAAI,EAAI,GAEzB,GAAQ,GAAQ,CACnB,IAAI,EAAM,EAAI,OACd,KAAO,EAAE,GAAO,GAAG,EAAI,GAAO,CAC/B,EACI,GAAc,GAAM,CACvB,IAAI,EAAG,EACH,EACA,EAAQ,EAAE,OACd,EAAI,EAAE,UACN,EAAI,EACJ,EACC,GAAI,EAAE,KAAK,EAAE,GACb,EAAE,KAAK,GAAK,GAAK,EAAQ,EAAI,EAAQ,QAC7B,EAAE,GACX,EAAI,EACJ,EAAI,EACJ,EACC,GAAI,EAAE,KAAK,EAAE,GACb,EAAE,KAAK,GAAK,GAAK,EAAQ,EAAI,EAAQ,QAC7B,EAAE,EACZ,EACI,IAAQ,EAAG,EAAM,KAAU,GAAQ,EAAE,WAAa,GAAQ,EAAE,UAC5D,IAAiB,EAAG,IAAQ,CAC/B,IAAI,EACJ,GAAI,EAAE,YAAa,EAAI,EAAE,MAAQ,GAAK,EAAG,EAAE,MAAO,EAAE,OAAO,EAAM,EAAY,EAAE,MAC1E,CACJ,IAAM,EAAI,EAAE,OACN,EAAQ,EAAE,GAAO,EAAE,EAAM,IAAM,EAAI,EAAE,EAAM,IAAM,GAAK,EAAE,EAAM,IAAM,GAC1E,EAAI,EAAE,MAAQ,KAAK,KAAK,EAAO,KAAK,EAAI,QAAU,GAAK,EAAE,SAC1D,CACA,IAAM,EAAY,EAAE,KAAK,EAAM,EAAE,QAAU,EAAE,KAAK,GAElD,MADA,GAAE,KAAK,GAAK,EACL,CACR,EACI,EAAiB,GAAS,CAC7B,IAAM,EAAI,EAAK,MACX,EAAM,EAAE,QACR,EAAM,EAAK,YAAW,EAAM,EAAK,WACjC,IAAQ,IACZ,EAAK,OAAO,IAAI,EAAE,YAAY,SAAS,EAAE,YAAa,EAAE,YAAc,CAAG,EAAG,EAAK,QAAQ,EACzF,EAAK,UAAY,EACjB,EAAE,aAAe,EACjB,EAAK,WAAa,EAClB,EAAK,WAAa,EAClB,EAAE,SAAW,EACT,EAAE,UAAY,IAAG,EAAE,YAAc,GACtC,EACI,GAAoB,EAAG,IAAS,CACnC,GAAgB,EAAG,EAAE,aAAe,EAAI,EAAE,YAAc,GAAI,EAAE,SAAW,EAAE,YAAa,CAAI,EAC5F,EAAE,YAAc,EAAE,SAClB,EAAc,EAAE,IAAI,CACrB,EACI,GAAY,EAAG,IAAM,CACxB,EAAE,YAAY,EAAE,WAAa,CAC9B,EACI,IAAe,EAAG,IAAM,CAC3B,EAAE,YAAY,EAAE,WAAa,IAAM,EAAI,IACvC,EAAE,YAAY,EAAE,WAAa,EAAI,GAClC,EACI,IAAY,EAAM,EAAK,EAAO,IAAS,CAC1C,IAAI,EAAM,EAAK,SASf,OARI,EAAM,IAAM,EAAM,GAClB,IAAQ,EAAU,GACtB,EAAK,UAAY,EACjB,EAAI,IAAI,EAAK,MAAM,SAAS,EAAK,QAAS,EAAK,QAAU,CAAG,EAAG,CAAK,EAChE,EAAK,MAAM,OAAS,EAAG,EAAK,MAAQ,GAAQ,EAAK,MAAO,EAAK,EAAK,CAAK,EAClE,EAAK,MAAM,OAAS,IAAG,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAK,EAAK,CAAK,GAC9E,EAAK,SAAW,EAChB,EAAK,UAAY,EACV,EACR,EACI,IAAiB,EAAG,IAAc,CACrC,IAAI,EAAe,EAAE,iBACjB,EAAO,EAAE,SACT,EACA,EACA,EAAW,EAAE,YACb,EAAa,EAAE,WACb,EAAQ,EAAE,SAAW,EAAE,OAAS,GAAgB,EAAE,UAAY,EAAE,OAAS,IAAiB,EAC1F,EAAO,EAAE,OACT,EAAQ,EAAE,OACV,EAAO,EAAE,KACT,EAAS,EAAE,SAAW,GACxB,EAAY,EAAK,EAAO,EAAW,GACnC,EAAW,EAAK,EAAO,GACvB,EAAE,aAAe,EAAE,aAAY,IAAiB,GAChD,EAAa,EAAE,YAAW,EAAa,EAAE,WAC7C,EAAG,CAEF,GADA,EAAQ,EACJ,EAAK,EAAQ,KAAc,GAAY,EAAK,EAAQ,EAAW,KAAO,GAAa,EAAK,KAAW,EAAK,IAAS,EAAK,EAAE,KAAW,EAAK,EAAO,GAAI,SACvJ,GAAQ,EACR,IACA,EAAI,OACC,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAK,EAAE,KAAU,EAAK,EAAE,IAAU,EAAO,GAG5R,GAFA,EAAM,IAAa,EAAS,GAC5B,EAAO,EAAS,GACZ,EAAM,EAAU,CAGnB,GAFA,EAAE,YAAc,EAChB,EAAW,EACP,GAAO,EAAY,MACvB,EAAY,EAAK,EAAO,EAAW,GACnC,EAAW,EAAK,EAAO,EACxB,CACD,QAAU,EAAY,EAAK,EAAY,IAAU,GAAS,EAAE,IAAiB,GAE7E,OADI,GAAY,EAAE,UAAkB,EAC7B,EAAE,SACV,EACI,GAAe,GAAM,CACxB,IAAM,EAAU,EAAE,OACd,EAAG,EAAM,EACb,EAAG,CAWF,GAVA,EAAO,EAAE,YAAc,EAAE,UAAY,EAAE,SACnC,EAAE,UAAY,GAAW,EAAU,MACtC,EAAE,OAAO,IAAI,EAAE,OAAO,SAAS,EAAS,EAAU,EAAU,CAAI,EAAG,CAAC,EACpE,EAAE,aAAe,EACjB,EAAE,UAAY,EACd,EAAE,aAAe,EACb,EAAE,OAAS,EAAE,WAAU,EAAE,OAAS,EAAE,UACxC,GAAW,CAAC,EACZ,GAAQ,GAEL,EAAE,KAAK,WAAa,EAAG,MAG3B,GAFA,EAAI,GAAS,EAAE,KAAM,EAAE,OAAQ,EAAE,SAAW,EAAE,UAAW,CAAI,EAC7D,EAAE,WAAa,EACX,CAAC,EAAE,gBACF,EAAE,UAAY,EAAE,OAAS,EAE5B,IADA,EAAM,EAAE,SAAW,EAAE,OACd,EAAE,SACR,GAAc,EAAG,CAAG,EACpB,IACA,EAAE,SACE,IAAE,UAAY,EAAE,QAAU,MAEhC,MACM,GAAI,EAAE,UAAY,EAAE,QAAU,EAIpC,IAHA,EAAM,EAAE,SAAW,EAAE,OACrB,EAAE,MAAQ,EAAE,OAAO,GACnB,EAAE,MAAQ,GAAK,EAAG,EAAE,MAAO,EAAE,OAAO,EAAM,EAAE,EACrC,EAAE,SACR,GAAc,EAAG,CAAG,EACpB,IACA,EAAE,SACE,IAAE,UAAY,EAAE,OAAS,MAGhC,OAAS,EAAE,UAAY,IAAiB,EAAE,KAAK,WAAa,EAC7D,EACI,IAAkB,EAAG,IAAU,CAClC,IAAI,EAAY,EAAE,iBAAmB,EAAI,EAAE,OAAS,EAAE,OAAS,EAAE,iBAAmB,EAChF,EAAK,EAAM,EAAM,EAAO,EACxB,EAAO,EAAE,KAAK,SAClB,EAAG,CAQF,GAPA,EAAM,MACN,EAAO,EAAE,SAAW,IAAM,EACtB,EAAE,KAAK,UAAY,IACvB,EAAO,EAAE,KAAK,UAAY,EAC1B,EAAO,EAAE,SAAW,EAAE,YAClB,EAAM,EAAO,EAAE,KAAK,WAAU,EAAM,EAAO,EAAE,KAAK,UAClD,EAAM,IAAM,EAAM,GAClB,EAAM,IAAc,IAAQ,GAAK,IAAU,GAAK,IAAU,GAAK,IAAQ,EAAO,EAAE,KAAK,WAAW,MACpG,EAAO,MAAU,GAAK,IAAQ,EAAO,EAAE,KAAK,UAC5C,GAAiB,EAAG,EAAG,EAAG,CAAI,EAC9B,EAAE,YAAY,EAAE,QAAU,GAAK,EAC/B,EAAE,YAAY,EAAE,QAAU,GAAK,GAAO,EACtC,EAAE,YAAY,EAAE,QAAU,GAAK,CAAC,EAChC,EAAE,YAAY,EAAE,QAAU,GAAK,CAAC,GAAO,EACvC,EAAc,EAAE,IAAI,EAChB,IACC,EAAO,IAAK,EAAO,GACvB,EAAE,KAAK,OAAO,IAAI,EAAE,OAAO,SAAS,EAAE,YAAa,EAAE,YAAc,CAAI,EAAG,EAAE,KAAK,QAAQ,EACzF,EAAE,KAAK,UAAY,EACnB,EAAE,KAAK,WAAa,EACpB,EAAE,KAAK,WAAa,EACpB,EAAE,aAAe,EACjB,GAAO,GAEJ,IACH,GAAS,EAAE,KAAM,EAAE,KAAK,OAAQ,EAAE,KAAK,SAAU,CAAG,EACpD,EAAE,KAAK,UAAY,EACnB,EAAE,KAAK,WAAa,EACpB,EAAE,KAAK,WAAa,EAEtB,OAAS,IAAS,GAmDlB,MAlDA,IAAQ,EAAE,KAAK,SACX,IACC,GAAQ,EAAE,QACb,EAAE,QAAU,EACZ,EAAE,OAAO,IAAI,EAAE,KAAK,MAAM,SAAS,EAAE,KAAK,QAAU,EAAE,OAAQ,EAAE,KAAK,OAAO,EAAG,CAAC,EAChF,EAAE,SAAW,EAAE,OACf,EAAE,OAAS,EAAE,WAET,EAAE,YAAc,EAAE,UAAY,IACjC,EAAE,UAAY,EAAE,OAChB,EAAE,OAAO,IAAI,EAAE,OAAO,SAAS,EAAE,OAAQ,EAAE,OAAS,EAAE,QAAQ,EAAG,CAAC,EAC9D,EAAE,QAAU,GAAG,EAAE,UACjB,EAAE,OAAS,EAAE,WAAU,EAAE,OAAS,EAAE,WAEzC,EAAE,OAAO,IAAI,EAAE,KAAK,MAAM,SAAS,EAAE,KAAK,QAAU,EAAM,EAAE,KAAK,OAAO,EAAG,EAAE,QAAQ,EACrF,EAAE,UAAY,EACd,EAAE,QAAU,EAAO,EAAE,OAAS,EAAE,OAAS,EAAE,OAAS,EAAE,OAAS,GAEhE,EAAE,YAAc,EAAE,UAEf,EAAE,WAAa,EAAE,WAAU,EAAE,WAAa,EAAE,UAC5C,EAAa,GACb,IAAU,GAAK,IAAU,GAAK,EAAE,KAAK,WAAa,GAAK,EAAE,WAAa,EAAE,YAAoB,IAChG,EAAO,EAAE,YAAc,EAAE,SACrB,EAAE,KAAK,SAAW,GAAQ,EAAE,aAAe,EAAE,SAChD,EAAE,aAAe,EAAE,OACnB,EAAE,UAAY,EAAE,OAChB,EAAE,OAAO,IAAI,EAAE,OAAO,SAAS,EAAE,OAAQ,EAAE,OAAS,EAAE,QAAQ,EAAG,CAAC,EAC9D,EAAE,QAAU,GAAG,EAAE,UACrB,GAAQ,EAAE,OACN,EAAE,OAAS,EAAE,WAAU,EAAE,OAAS,EAAE,WAErC,EAAO,EAAE,KAAK,WAAU,EAAO,EAAE,KAAK,UACtC,IACH,GAAS,EAAE,KAAM,EAAE,OAAQ,EAAE,SAAU,CAAI,EAC3C,EAAE,UAAY,EACd,EAAE,QAAU,EAAO,EAAE,OAAS,EAAE,OAAS,EAAE,OAAS,EAAE,OAAS,GAE5D,EAAE,WAAa,EAAE,WAAU,EAAE,WAAa,EAAE,UAChD,EAAO,EAAE,SAAW,IAAM,EAC1B,EAAO,EAAE,iBAAmB,EAAO,MAAQ,MAAQ,EAAE,iBAAmB,EACxE,EAAY,EAAO,EAAE,OAAS,EAAE,OAAS,EACzC,EAAO,EAAE,SAAW,EAAE,aAClB,GAAQ,IAAc,GAAQ,IAAU,IAAM,IAAU,GAAK,EAAE,KAAK,WAAa,GAAK,GAAQ,KACjG,EAAM,EAAO,EAAO,EAAO,EAC3B,EAAO,MAAU,GAAK,EAAE,KAAK,WAAa,GAAK,IAAQ,GACvD,GAAiB,EAAG,EAAE,YAAa,EAAK,CAAI,EAC5C,EAAE,aAAe,EACjB,EAAc,EAAE,IAAI,GAEd,EAAO,GAAoB,EACnC,EACI,IAAgB,EAAG,IAAU,CAChC,IAAI,EACA,EACJ,OAAS,CACR,GAAI,EAAE,UAAY,GAAe,CAEhC,GADA,GAAY,CAAC,EACT,EAAE,UAAY,IAAiB,IAAU,EAAG,OAAO,EACvD,GAAI,EAAE,YAAc,EAAG,KACxB,CAIA,GAHA,EAAY,EACR,EAAE,WAAa,IAAW,EAAY,GAAc,EAAG,EAAE,QAAQ,GACjE,IAAc,GAAK,EAAE,SAAW,GAAa,EAAE,OAAS,KAAe,EAAE,aAAe,GAAc,EAAG,CAAS,GAClH,EAAE,cAAgB,EAKrB,GAFA,EAAS,GAAU,EAAG,EAAE,SAAW,EAAE,YAAa,EAAE,aAAe,CAAS,EAC5E,EAAE,WAAa,EAAE,aACb,EAAE,cAAgB,EAAE,gBAAkB,EAAE,WAAa,EAAW,CACnE,EAAE,eACF,EACC,GAAE,WACF,EAAY,GAAc,EAAG,EAAE,QAAQ,QAC/B,EAAE,EAAE,eAAiB,GAC9B,EAAE,UACH,KACC,GAAE,UAAY,EAAE,aAChB,EAAE,aAAe,EACb,EAAE,cACL,EAAE,MAAQ,EAAE,OAAO,EAAE,UACrB,EAAE,MAAQ,GAAK,EAAG,EAAE,MAAO,EAAE,OAAO,EAAE,SAAW,EAAE,OAKrD,GAAS,GAAU,EAAG,EAAG,EAAE,OAAO,EAAE,SAAS,EAC7C,EAAE,YACF,EAAE,WAEH,GAAI,IAEH,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAG,OAAO,CAErC,CAaA,MAZA,GAAE,OAAS,EAAE,SAAW,EAAY,EAAI,EAAE,SAAW,EAAY,EAC7D,IAAU,GAEb,EAAiB,EAAG,EAAI,EACpB,EAAE,KAAK,YAAc,EAAU,GAC5B,IAEJ,EAAE,WAEL,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAU,EAE7B,EACR,EACI,IAAgB,EAAG,IAAU,CAChC,IAAI,EACA,EACA,EACJ,OAAS,CACR,GAAI,EAAE,UAAY,GAAe,CAEhC,GADA,GAAY,CAAC,EACT,EAAE,UAAY,IAAiB,IAAU,EAAG,OAAO,EACvD,GAAI,EAAE,YAAc,EAAG,KACxB,CAUA,GATA,EAAY,EACR,EAAE,WAAa,IAAW,EAAY,GAAc,EAAG,EAAE,QAAQ,GACrE,EAAE,YAAc,EAAE,aAClB,EAAE,WAAa,EAAE,YACjB,EAAE,aAAe,EAAY,EACzB,IAAc,GAAK,EAAE,YAAc,EAAE,gBAAkB,EAAE,SAAW,GAAa,EAAE,OAAS,KAC/F,EAAE,aAAe,GAAc,EAAG,CAAS,EACvC,EAAE,cAAgB,IAAM,EAAE,WAAa,GAAK,EAAE,eAAiB,GAAa,EAAE,SAAW,EAAE,YAAc,QAAO,EAAE,aAAe,EAAY,IAE9I,EAAE,aAAe,GAAa,EAAE,cAAgB,EAAE,YAAa,CAClE,EAAa,EAAE,SAAW,EAAE,UAAY,EAGxC,EAAS,GAAU,EAAG,EAAE,SAAW,EAAI,EAAE,WAAY,EAAE,YAAc,CAAS,EAC9E,EAAE,WAAa,EAAE,YAAc,EAC/B,EAAE,aAAe,EACjB,EACK,EAAE,EAAE,UAAY,IAAY,EAAY,GAAc,EAAG,EAAE,QAAQ,SACjE,EAAE,EAAE,cAAgB,GAI3B,GAHA,EAAE,gBAAkB,EACpB,EAAE,aAAe,EAAY,EAC7B,EAAE,WACE,IAEH,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAG,OAAO,CAErC,MAAO,GAAI,EAAE,gBAQZ,IANA,EAAS,GAAU,EAAG,EAAG,EAAE,OAAO,EAAE,SAAW,EAAE,EAC7C,GAEJ,EAAiB,EAAG,EAAK,EACzB,EAAE,WACF,EAAE,YACE,EAAE,KAAK,YAAc,EAAG,OAAO,CAAA,KAEnC,GAAE,gBAAkB,EACpB,EAAE,WACF,EAAE,WAEJ,CAkBA,OAjBI,EAAE,kBAEL,EAAS,GAAU,EAAG,EAAG,EAAE,OAAO,EAAE,SAAW,EAAE,EACjD,EAAE,gBAAkB,GAErB,EAAE,OAAS,EAAE,SAAW,EAAY,EAAI,EAAE,SAAW,EAAY,EAC7D,IAAU,GAEb,EAAiB,EAAG,EAAI,EACpB,EAAE,KAAK,YAAc,EAAU,GAC5B,IAEJ,EAAE,WAEL,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAU,EAE7B,EACR,EACI,IAAe,EAAG,IAAU,CAC/B,IAAI,EACA,EACA,EAAM,EACJ,EAAO,EAAE,OACf,OAAS,CACR,GAAI,EAAE,WAAa,GAAW,CAE7B,GADA,GAAY,CAAC,EACT,EAAE,WAAa,IAAa,IAAU,EAAG,OAAO,EACpD,GAAI,EAAE,YAAc,EAAG,KACxB,CAEA,GADA,EAAE,aAAe,EACb,EAAE,WAAa,GAAa,EAAE,SAAW,IAC5C,EAAO,EAAE,SAAW,EACpB,EAAO,EAAK,GACR,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAO,CAC5E,EAAS,EAAE,SAAW,GACtB,EAAM,OACH,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,IAAS,EAAK,EAAE,IAAS,EAAO,GAClN,EAAE,aAAe,IAAa,EAAS,GACnC,EAAE,aAAe,EAAE,YAAW,EAAE,aAAe,EAAE,UACtD,CAcD,GAZI,EAAE,cAAgB,GAErB,EAAS,GAAU,EAAG,EAAG,EAAE,aAAe,CAAS,EACnD,EAAE,WAAa,EAAE,aACjB,EAAE,UAAY,EAAE,aAChB,EAAE,aAAe,IAGjB,EAAS,GAAU,EAAG,EAAG,EAAE,OAAO,EAAE,SAAS,EAC7C,EAAE,YACF,EAAE,YAEC,IAEH,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAG,OAAO,CAErC,CAaA,MAZA,GAAE,OAAS,EACP,IAAU,GAEb,EAAiB,EAAG,EAAI,EACpB,EAAE,KAAK,YAAc,EAAU,GAC5B,IAEJ,EAAE,WAEL,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAU,EAE7B,EACR,EACI,IAAgB,EAAG,IAAU,CAChC,IAAI,EACJ,OAAS,CACR,GAAI,EAAE,YAAc,IACnB,GAAY,CAAC,EACT,EAAE,YAAc,GAAG,CACtB,GAAI,IAAU,EAAG,OAAO,EACxB,KACD,CAOD,GALA,EAAE,aAAe,EAEjB,EAAS,GAAU,EAAG,EAAG,EAAE,OAAO,EAAE,SAAS,EAC7C,EAAE,YACF,EAAE,WACE,IAEH,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAG,OAAO,CAErC,CAaA,MAZA,GAAE,OAAS,EACP,IAAU,GAEb,EAAiB,EAAG,EAAI,EACpB,EAAE,KAAK,YAAc,EAAU,GAC5B,IAEJ,EAAE,WAEL,EAAiB,EAAG,EAAK,EACrB,EAAE,KAAK,YAAc,GAAU,EAE7B,EACR,EACI,GAAS,KAAM,CAClB,YAAY,EAAa,EAAU,EAAa,EAAW,EAAM,CAChE,KAAK,YAAc,EACnB,KAAK,SAAW,EAChB,KAAK,YAAc,EACnB,KAAK,UAAY,EACjB,KAAK,KAAO,CACb,CACD,EACI,GAAsB,CACzB,IAAI,GAAO,EAAG,EAAG,EAAG,EAAG,EAAc,EACrC,IAAI,GAAO,EAAG,EAAG,EAAG,EAAG,EAAY,EACnC,IAAI,GAAO,EAAG,EAAG,GAAI,EAAG,EAAY,EACpC,IAAI,GAAO,EAAG,EAAG,GAAI,GAAI,EAAY,EACrC,IAAI,GAAO,EAAG,EAAG,GAAI,GAAI,EAAY,EACrC,IAAI,GAAO,EAAG,GAAI,GAAI,GAAI,EAAY,EACtC,IAAI,GAAO,EAAG,GAAI,IAAK,IAAK,EAAY,EACxC,IAAI,GAAO,EAAG,GAAI,IAAK,IAAK,EAAY,EACxC,IAAI,GAAO,GAAI,IAAK,IAAK,KAAM,EAAY,EAC3C,IAAI,GAAO,GAAI,IAAK,IAAK,KAAM,EAAY,CAC5C,EACI,GAAW,GAAM,CACpB,EAAE,YAAc,EAAI,EAAE,OAEtB,GAAK,EAAE,IAAI,EACX,EAAE,eAAiB,GAAoB,EAAE,MAAM,CAAC,SAChD,EAAE,WAAa,GAAoB,EAAE,MAAM,CAAC,YAC5C,EAAE,WAAa,GAAoB,EAAE,MAAM,CAAC,YAC5C,EAAE,iBAAmB,GAAoB,EAAE,MAAM,CAAC,UAClD,EAAE,SAAW,EACb,EAAE,YAAc,EAChB,EAAE,UAAY,EACd,EAAE,OAAS,EACX,EAAE,aAAe,EAAE,YAAc,EAAY,EAC7C,EAAE,gBAAkB,EACpB,EAAE,MAAQ,CACX,EACI,GAAe,KAAM,CACxB,aAAc,CACb,KAAK,KAAO,KACZ,KAAK,OAAS,EACd,KAAK,YAAc,KACnB,KAAK,iBAAmB,EACxB,KAAK,YAAc,EACnB,KAAK,QAAU,EACf,KAAK,KAAO,EACZ,KAAK,OAAS,KACd,KAAK,QAAU,EACf,KAAK,OAAS,EACd,KAAK,WAAa,GAClB,KAAK,OAAS,EACd,KAAK,OAAS,EACd,KAAK,OAAS,EACd,KAAK,OAAS,KACd,KAAK,YAAc,EACnB,KAAK,KAAO,KACZ,KAAK,KAAO,KACZ,KAAK,MAAQ,EACb,KAAK,YAAc,EACnB,KAAK,UAAY,EACjB,KAAK,UAAY,EACjB,KAAK,UAAY,EACjB,KAAK,WAAa,EAClB,KAAK,YAAc,EACnB,KAAK,aAAe,EACpB,KAAK,WAAa,EAClB,KAAK,gBAAkB,EACvB,KAAK,SAAW,EAChB,KAAK,YAAc,EACnB,KAAK,UAAY,EACjB,KAAK,YAAc,EACnB,KAAK,iBAAmB,EACxB,KAAK,eAAiB,EACtB,KAAK,MAAQ,EACb,KAAK,SAAW,EAChB,KAAK,WAAa,EAClB,KAAK,WAAa,EAClB,KAAK,UAAY,IAAI,YAAY,GAAY,CAAC,EAC9C,KAAK,UAA4B,IAAI,YAAY,GAAG,EACpD,KAAK,QAA0B,IAAI,YAAY,EAAE,EACjD,GAAK,KAAK,SAAS,EACnB,GAAK,KAAK,SAAS,EACnB,GAAK,KAAK,OAAO,EACjB,KAAK,OAAS,KACd,KAAK,OAAS,KACd,KAAK,QAAU,KACf,KAAK,SAA2B,IAAI,YAAY,EAAE,EAClD,KAAK,KAAuB,IAAI,YAAY,GAAG,EAC/C,GAAK,KAAK,IAAI,EACd,KAAK,SAAW,EAChB,KAAK,SAAW,EAChB,KAAK,MAAwB,IAAI,YAAY,GAAG,EAChD,GAAK,KAAK,KAAK,EACf,KAAK,QAAU,EACf,KAAK,YAAc,EACnB,KAAK,SAAW,EAChB,KAAK,QAAU,EACf,KAAK,QAAU,EACf,KAAK,WAAa,EAClB,KAAK,QAAU,EACf,KAAK,OAAS,EACd,KAAK,OAAS,EACd,KAAK,SAAW,CACjB,CACD,EACI,GAAqB,GAAS,CACjC,GAAI,CAAC,EAAM,MAAO,GAClB,IAAM,EAAI,EAAK,MAEf,MADA,EAAI,CAAC,GAAK,EAAE,OAAS,GAAQ,EAAE,SAAW,IAAc,EAAE,SAAW,IAAc,EAAE,SAAW,IAAe,EAAE,SAAW,IAAc,EAAE,SAAW,IAAiB,EAAE,SAAW,IAAc,EAAE,SAAW,IAAc,EAAE,SAAW,GAE5O,EACI,GAAoB,GAAS,CAChC,GAAI,GAAkB,CAAI,EAAG,OAAOA,GAAI,EAAM,EAAE,EAChD,EAAK,SAAW,EAAK,UAAY,EACjC,EAAK,UAAY,EACjB,IAAM,EAAI,EAAK,MAQf,MAPA,GAAE,QAAU,EACZ,EAAE,YAAc,EACZ,EAAE,KAAO,IAAG,EAAE,KAAO,CAAC,EAAE,MAC5B,EAAE,OAAS,EAAE,OAAS,EAAI,GAAa,EAAE,KAAO,GAAa,GAC7D,EAAK,MAAQ,EAAE,OAAS,EAAI,EAAI,EAChC,EAAE,WAAa,GACf,GAAS,CAAC,EACH,CACR,EACI,GAAgB,GAAS,CAC5B,IAAM,EAAM,GAAiB,CAAI,EAEjC,OADI,IAAQ,GAAG,GAAQ,EAAK,KAAK,EAC1B,CACR,EAMI,IAAgB,EAAM,EAAO,EAAQ,EAAY,EAAU,EAAU,IAAe,CACvF,GAAI,CAAC,EAAM,MAAO,GAClB,IAAI,EAAO,EASX,GARI,IAAU,KAAI,EAAQ,GACtB,EAAa,GAChB,EAAO,EACP,EAAa,CAAC,GACJ,EAAa,KACvB,EAAO,EACP,GAAc,IAEX,EAAW,GAAK,EAAW,IAAiB,IAAW,GAAK,EAAa,GAAK,EAAa,IAAM,EAAQ,GAAK,EAAQ,GAAK,EAAW,GAAK,EAAW,GAAK,IAAe,GAAK,IAAS,EAAG,OAAOA,GAAI,EAAM,EAAE,EAC9M,IAAe,IAAG,EAAa,GACnC,IAAM,EAAI,IAAI,GA0Bd,MAzBA,GAAK,MAAQ,EACb,EAAE,KAAO,EACT,EAAE,OAAS,GACX,EAAE,KAAO,EACT,EAAE,OAAS,KACX,EAAE,OAAS,EACX,EAAE,OAAS,GAAK,EAAE,OAClB,EAAE,OAAS,EAAE,OAAS,EACtB,EAAE,YAAc,KAChB,EAAE,UAAY,EAAW,EACrB,CAAC,EAAE,aAAe,EAAE,UAAY,KAAI,EAAE,UAAY,IACtD,EAAE,UAAY,GAAK,EAAE,UACrB,EAAE,UAAY,EAAE,UAAY,EAC5B,EAAE,WAAa,CAAC,GAAG,EAAE,UAAY,EAAY,GAAK,GAClD,EAAE,OAAS,IAAI,WAAW,EAAE,OAAS,CAAC,EACtC,EAAE,KAAO,IAAI,YAAY,EAAE,SAAS,EACpC,EAAE,KAAO,IAAI,YAAY,EAAE,MAAM,EACjC,EAAE,YAAc,GAAK,EAAW,EAChC,EAAE,iBAAmB,EAAE,YAAc,EACrC,EAAE,YAAc,IAAI,WAAW,EAAE,gBAAgB,EACjD,EAAE,QAAU,EAAE,YACd,EAAE,SAAW,EAAE,YAAc,GAAK,EAClC,EAAE,MAAQ,EACV,EAAE,SAAW,EACb,EAAE,OAAS,EACJ,GAAa,CAAI,CACzB,EAII,IAAa,EAAM,IAAU,CAChC,GAAI,GAAkB,CAAI,GAAK,EAAQ,GAAK,EAAQ,EAAG,OAAO,EAAOA,GAAI,EAAM,EAAE,EAAI,GACrF,IAAM,EAAI,EAAK,MACf,GAAI,CAAC,EAAK,QAAU,EAAK,WAAa,GAAK,CAAC,EAAK,OAAS,EAAE,SAAW,IAAgB,IAAU,EAAG,OAAOA,GAAI,EAAM,EAAK,YAAc,EAAI,GAAK,EAAE,EACnJ,IAAM,EAAY,EAAE,WAEpB,GADA,EAAE,WAAa,EACX,EAAE,UAAY,EAEjB,IADA,EAAc,CAAI,EACd,EAAK,YAAc,EAEtB,MADA,GAAE,WAAa,GACR,CACR,MACM,GAAI,EAAK,WAAa,GAAK,GAAK,CAAK,GAAK,GAAK,CAAS,GAAK,IAAU,EAAG,OAAOA,GAAI,EAAM,EAAE,EACpG,GAAI,EAAE,SAAW,IAAgB,EAAK,WAAa,EAAG,OAAOA,GAAI,EAAM,EAAE,EAEzE,GADI,EAAE,SAAW,IAAc,EAAE,OAAS,IAAG,EAAE,OAAS,IACpD,EAAE,SAAW,GAAY,CAC5B,IAAI,EAAS,GAAK,EAAE,OAAS,GAAK,IAAM,EACpC,EAAc,GAgBlB,GAfA,AAGK,EAHD,EAAE,UAAY,GAAK,EAAE,MAAQ,EAAiB,EACzC,EAAE,MAAQ,EAAiB,EAC3B,EAAE,QAAU,EAAiB,EACnB,EACnB,GAAU,GAAe,EACrB,EAAE,WAAa,IAAG,GAAU,IAChC,GAAU,GAAK,EAAS,GACxB,GAAY,EAAG,CAAM,EACjB,EAAE,WAAa,IAClB,GAAY,EAAG,EAAK,QAAU,EAAE,EAChC,GAAY,EAAG,EAAK,MAAQ,KAAK,GAElC,EAAK,MAAQ,EACb,EAAE,OAAS,GACX,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,CAET,CACA,GAAI,EAAE,SAAW,GAKhB,IAJA,EAAK,MAAQ,EACb,EAAS,EAAG,EAAE,EACd,EAAS,EAAG,GAAG,EACf,EAAS,EAAG,CAAC,EACR,EAAE,OAeN,EAAS,EAAI,KAAE,OAAO,MAAiB,EAAE,OAAO,KAAO,EAAI,IAAO,EAAE,OAAO,MAAY,EAAJ,IAAW,EAAE,OAAO,KAAW,EAAJ,IAAW,EAAE,OAAO,QAAc,GAAJ,EAAO,EACnJ,EAAS,EAAG,EAAE,OAAO,KAAO,GAAG,EAC/B,EAAS,EAAG,EAAE,OAAO,MAAQ,EAAI,GAAG,EACpC,EAAS,EAAG,EAAE,OAAO,MAAQ,GAAK,GAAG,EACrC,EAAS,EAAG,EAAE,OAAO,MAAQ,GAAK,GAAG,EACrC,EAAS,EAAG,EAAE,QAAU,EAAI,EAAI,EAAE,UAAY,GAAK,EAAE,MAAQ,EAAI,EAAI,CAAC,EACtE,EAAS,EAAG,EAAE,OAAO,GAAK,GAAG,EACzB,EAAE,OAAO,OAAS,EAAE,OAAO,MAAM,SACpC,EAAS,EAAG,EAAE,OAAO,MAAM,OAAS,GAAG,EACvC,EAAS,EAAG,EAAE,OAAO,MAAM,QAAU,EAAI,GAAG,GAEzC,EAAE,OAAO,OAAM,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAS,CAAC,GAC7E,EAAE,QAAU,EACZ,EAAE,OAAS,QAlBX,GATA,EAAS,EAAG,CAAC,EACb,EAAS,EAAG,CAAC,EACb,EAAS,EAAG,CAAC,EACb,EAAS,EAAG,CAAC,EACb,EAAS,EAAG,CAAC,EACb,EAAS,EAAG,EAAE,QAAU,EAAI,EAAI,EAAE,UAAY,GAAK,EAAE,MAAQ,EAAI,EAAI,CAAC,EACtE,EAAS,EAAG,EAAO,EACnB,EAAE,OAAS,GACX,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,CAiBT,CAED,GAAI,EAAE,SAAW,GAAa,CAC7B,GAAI,EAAE,OAAO,MAAO,CACnB,IAAI,EAAM,EAAE,QACR,GAAQ,EAAE,OAAO,MAAM,OAAS,OAAS,EAAE,QAC/C,KAAO,EAAE,QAAU,EAAO,EAAE,kBAAkB,CAC7C,IAAI,EAAO,EAAE,iBAAmB,EAAE,QAMlC,GALA,EAAE,YAAY,IAAI,EAAE,OAAO,MAAM,SAAS,EAAE,QAAS,EAAE,QAAU,CAAI,EAAG,EAAE,OAAO,EACjF,EAAE,QAAU,EAAE,iBACV,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,GACxG,EAAE,SAAW,EACb,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,EAER,EAAM,EACN,GAAQ,CACT,CACA,IAAI,EAAe,IAAI,WAAW,EAAE,OAAO,KAAK,EAChD,EAAE,YAAY,IAAI,EAAa,SAAS,EAAE,QAAS,EAAE,QAAU,CAAI,EAAG,EAAE,OAAO,EAC/E,EAAE,SAAW,EACT,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,GACxG,EAAE,QAAU,CACb,CACA,EAAE,OAAS,EACZ,CACA,GAAI,EAAE,SAAW,GAAY,CAC5B,GAAI,EAAE,OAAO,KAAM,CAClB,IAAI,EAAM,EAAE,QACR,EACJ,EAAG,CACF,GAAI,EAAE,UAAY,EAAE,iBAAkB,CAGrC,GAFI,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,GACxG,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,EAER,EAAM,CACP,CACA,AACK,EADD,EAAE,QAAU,EAAE,OAAO,KAAK,OAAc,EAAE,OAAO,KAAK,WAAW,EAAE,SAAS,EAAI,IACzE,EACX,EAAS,EAAG,CAAG,CAChB,OAAS,IAAQ,GACb,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,GACxG,EAAE,QAAU,CACb,CACA,EAAE,OAAS,EACZ,CACA,GAAI,EAAE,SAAW,GAAe,CAC/B,GAAI,EAAE,OAAO,QAAS,CACrB,IAAI,EAAM,EAAE,QACR,EACJ,EAAG,CACF,GAAI,EAAE,UAAY,EAAE,iBAAkB,CAGrC,GAFI,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,GACxG,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,EAER,EAAM,CACP,CACA,AACK,EADD,EAAE,QAAU,EAAE,OAAO,QAAQ,OAAc,EAAE,OAAO,QAAQ,WAAW,EAAE,SAAS,EAAI,IAC/E,EACX,EAAS,EAAG,CAAG,CAChB,OAAS,IAAQ,GACb,EAAE,OAAO,MAAQ,EAAE,QAAU,IAAK,EAAK,MAAQ,EAAM,EAAK,MAAO,EAAE,YAAa,EAAE,QAAU,EAAK,CAAG,EACzG,CACA,EAAE,OAAS,EACZ,CACA,GAAI,EAAE,SAAW,GAAY,CAC5B,GAAI,EAAE,OAAO,KAAM,CAClB,GAAI,EAAE,QAAU,EAAI,EAAE,mBACrB,EAAc,CAAI,EACd,EAAE,UAAY,GAEjB,MADA,GAAE,WAAa,GACR,EAGT,EAAS,EAAG,EAAK,MAAQ,GAAG,EAC5B,EAAS,EAAG,EAAK,OAAS,EAAI,GAAG,EACjC,EAAK,MAAQ,CACd,CAGA,GAFA,EAAE,OAAS,GACX,EAAc,CAAI,EACd,EAAE,UAAY,EAEjB,MADA,GAAE,WAAa,GACR,CAET,CACA,GAAI,EAAK,WAAa,GAAK,EAAE,YAAc,GAAK,IAAU,GAAK,EAAE,SAAW,GAAc,CACzF,IAAI,EAAS,EAAE,QAAU,EAAI,GAAe,EAAG,CAAK,EAAI,EAAE,WAAa,EAAI,GAAa,EAAG,CAAK,EAAI,EAAE,WAAa,EAAI,GAAY,EAAG,CAAK,EAAI,GAAoB,EAAE,MAAM,CAAC,KAAK,EAAG,CAAK,EAEzL,IADI,IAAW,IAAqB,IAAW,MAAgB,EAAE,OAAS,IACtE,IAAW,GAAgB,IAAW,GAEzC,OADI,EAAK,YAAc,IAAG,EAAE,WAAa,IAClC,EAER,GAAI,IAAW,KACV,IAAU,EAAG,GAAU,CAAC,EACnB,IAAU,IAClB,GAAiB,EAAG,EAAG,EAAG,EAAK,EAC3B,IAAU,IACY,GAAK,EAAE,IAAI,EAChC,EAAE,YAAc,IACnB,EAAE,SAAW,EACb,EAAE,YAAc,EAChB,EAAE,OAAS,KAId,EAAc,CAAI,EACd,EAAK,YAAc,GAEtB,MADA,GAAE,WAAa,GACR,CAGV,CAkBA,OAjBI,IAAU,EACV,EAAE,MAAQ,EAAU,GACpB,EAAE,OAAS,GACd,EAAS,EAAG,EAAK,MAAQ,GAAG,EAC5B,EAAS,EAAG,EAAK,OAAS,EAAI,GAAG,EACjC,EAAS,EAAG,EAAK,OAAS,GAAK,GAAG,EAClC,EAAS,EAAG,EAAK,OAAS,GAAK,GAAG,EAClC,EAAS,EAAG,EAAK,SAAW,GAAG,EAC/B,EAAS,EAAG,EAAK,UAAY,EAAI,GAAG,EACpC,EAAS,EAAG,EAAK,UAAY,GAAK,GAAG,EACrC,EAAS,EAAG,EAAK,UAAY,GAAK,GAAG,IAErC,GAAY,EAAG,EAAK,QAAU,EAAE,EAChC,GAAY,EAAG,EAAK,MAAQ,KAAK,GAElC,EAAc,CAAI,EACd,EAAE,KAAO,IAAG,EAAE,KAAO,CAAC,EAAE,MACrB,IAAE,UAAY,IAjBG,CAkBzB,EACI,GAAc,GAAS,CAC1B,GAAI,GAAkB,CAAI,EAAG,MAAO,GACpC,IAAM,EAAS,EAAK,MAAM,OAE1B,MADA,GAAK,MAAQ,KACN,IAAW,GAAaA,GAAI,EAAM,EAAE,EAAI,CAChD,EACI,IAAwB,EAAM,IAAe,CAChD,IAAI,EAAa,EAAW,OAC5B,GAAI,GAAkB,CAAI,EAAG,MAAO,GACpC,IAAM,EAAI,EAAK,MACT,EAAO,EAAE,KACf,GAAI,IAAS,GAAK,IAAS,GAAK,EAAE,SAAW,IAAc,EAAE,UAAW,MAAO,GAG/E,GAFI,IAAS,IAAG,EAAK,MAAQ,GAAQ,EAAK,MAAO,EAAY,EAAY,CAAC,GAC1E,EAAE,KAAO,EACL,GAAc,EAAE,OAAQ,CACvB,IAAS,IAEZ,GAAK,EAAE,IAAI,EACX,EAAE,SAAW,EACb,EAAE,YAAc,EAChB,EAAE,OAAS,GAEZ,IAAI,EAAU,IAAI,WAAW,EAAE,MAAM,EACrC,EAAQ,IAAI,EAAW,SAAS,EAAa,EAAE,OAAQ,CAAU,EAAG,CAAC,EACrE,EAAa,EACb,EAAa,EAAE,MAChB,CACA,IAAM,EAAQ,EAAK,SACb,EAAO,EAAK,QACZ,EAAQ,EAAK,MAKnB,IAJA,EAAK,SAAW,EAChB,EAAK,QAAU,EACf,EAAK,MAAQ,EACb,GAAY,CAAC,EACN,EAAE,WAAa,GAAW,CAChC,IAAI,EAAM,EAAE,SACR,EAAI,EAAE,WAAa,EAAY,GACnC,GACC,GAAc,EAAG,CAAG,EACpB,UACQ,EAAE,GACX,EAAE,SAAW,EACb,EAAE,UAAY,EAAY,EAC1B,GAAY,CAAC,CACd,CAWA,MAVA,GAAE,UAAY,EAAE,UAChB,EAAE,YAAc,EAAE,SAClB,EAAE,OAAS,EAAE,UACb,EAAE,UAAY,EACd,EAAE,aAAe,EAAE,YAAc,EAAY,EAC7C,EAAE,gBAAkB,EACpB,EAAK,QAAU,EACf,EAAK,MAAQ,EACb,EAAK,SAAW,EAChB,EAAE,KAAO,EACF,CACR,EAGI,GAAQ,MACR,GAAS,MACb,SAAS,GAAa,EAAM,EAAO,CAClC,IAAI,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EAAO,EACL,EAAQ,EAAK,MACnB,EAAM,EAAK,QACX,EAAQ,EAAK,MACb,EAAO,GAAO,EAAK,SAAW,GAC9B,EAAO,EAAK,SACZ,EAAS,EAAK,OACd,EAAM,GAAQ,EAAQ,EAAK,WAC3B,EAAM,GAAQ,EAAK,UAAY,KAC/B,EAAO,EAAM,KACb,EAAQ,EAAM,MACd,EAAQ,EAAM,MACd,EAAQ,EAAM,MACd,EAAW,EAAM,OACjB,EAAO,EAAM,KACb,EAAO,EAAM,KACb,EAAQ,EAAM,QACd,EAAQ,EAAM,SACd,GAAS,GAAK,EAAM,SAAW,EAC/B,GAAS,GAAK,EAAM,UAAY,EAChC,IAAK,EAAG,CACH,EAAO,KACV,GAAQ,EAAM,MAAU,EACxB,GAAQ,EACR,GAAQ,EAAM,MAAU,EACxB,GAAQ,GAET,EAAO,EAAM,EAAO,GACpB,MAAO,OAAS,CAKf,GAJA,EAAK,IAAS,GACd,KAAU,EACV,GAAQ,EACR,EAAK,IAAS,GAAK,IACf,IAAO,EAAG,EAAO,KAAU,EAAO,WACjC,GAAI,EAAK,GAAI,CACjB,EAAM,EAAO,MACb,GAAM,GACF,IACC,EAAO,IACV,GAAQ,EAAM,MAAU,EACxB,GAAQ,GAET,GAAO,GAAQ,GAAK,GAAM,EAC1B,KAAU,EACV,GAAQ,GAEL,EAAO,KACV,GAAQ,EAAM,MAAU,EACxB,GAAQ,EACR,GAAQ,EAAM,MAAU,EACxB,GAAQ,GAET,EAAO,EAAM,EAAO,GACpB,OAAQ,OAAS,CAKhB,GAJA,EAAK,IAAS,GACd,KAAU,EACV,GAAQ,EACR,EAAK,IAAS,GAAK,IACf,EAAK,GAAI,CAYZ,GAXA,EAAO,EAAO,MACd,GAAM,GACF,EAAO,IACV,GAAQ,EAAM,MAAU,EACxB,GAAQ,EACJ,EAAO,IACV,GAAQ,EAAM,MAAU,EACxB,GAAQ,IAGV,GAAQ,GAAQ,GAAK,GAAM,EACvB,EAAO,EAAM,CAChB,EAAK,IAAM,gCACX,EAAM,KAAO,GACb,MAAM,GACP,CAIA,GAHA,KAAU,EACV,GAAQ,EACR,EAAK,EAAO,EACR,EAAO,EAAI,CAEd,GADA,EAAK,EAAO,EACR,EAAK,GACJ,EAAM,KAAM,CACf,EAAK,IAAM,gCACX,EAAM,KAAO,GACb,MAAM,GACP,CAID,GAFA,EAAO,EACP,EAAc,EACV,IAAU,EAEb,IADA,GAAQ,EAAQ,EACZ,EAAK,EAAK,CACb,GAAO,EACP,EACC,GAAO,KAAU,EAAS,WACpB,EAAE,GACT,EAAO,EAAO,EACd,EAAc,CACf,OACM,GAAI,EAAQ,EAGlB,IAFA,GAAQ,EAAQ,EAAQ,EACxB,GAAM,EACF,EAAK,EAAK,CACb,GAAO,EACP,EACC,GAAO,KAAU,EAAS,WACpB,EAAE,GAET,GADA,EAAO,EACH,EAAQ,EAAK,CAChB,EAAK,EACL,GAAO,EACP,EACC,GAAO,KAAU,EAAS,WACpB,EAAE,GACT,EAAO,EAAO,EACd,EAAc,CACf,CACD,OAGA,GADA,GAAQ,EAAQ,EACZ,EAAK,EAAK,CACb,GAAO,EACP,EACC,GAAO,KAAU,EAAS,WACpB,EAAE,GACT,EAAO,EAAO,EACd,EAAc,CACf,CAED,KAAO,EAAM,GACZ,EAAO,KAAU,EAAY,KAC7B,EAAO,KAAU,EAAY,KAC7B,EAAO,KAAU,EAAY,KAC7B,GAAO,EAEJ,IACH,EAAO,KAAU,EAAY,KACzB,EAAM,IAAG,EAAO,KAAU,EAAY,MAE5C,KAAO,CACN,EAAO,EAAO,EACd,EACC,GAAO,KAAU,EAAO,KACxB,EAAO,KAAU,EAAO,KACxB,EAAO,KAAU,EAAO,KACxB,GAAO,QACC,EAAM,GACX,IACH,EAAO,KAAU,EAAO,KACpB,EAAM,IAAG,EAAO,KAAU,EAAO,MAEvC,CACD,MAAO,GAAK,EAAK,GAGV,CACN,EAAK,IAAM,wBACX,EAAM,KAAO,GACb,MAAM,GACP,KAP4B,CAC3B,EAAO,GAAO,EAAO,QAAU,GAAQ,GAAK,GAAM,IAClD,SAAS,MACV,CAKA,KACD,CACD,MAAO,GAAA,EAAK,EAAK,IAAW,CAC3B,EAAO,GAAO,EAAO,QAAU,GAAQ,GAAK,GAAM,IAClD,SAAS,KACV,MAAO,GAAI,EAAK,GAAI,CACnB,EAAM,KAAO,GACb,MAAM,GACP,KAAO,CACN,EAAK,IAAM,8BACX,EAAM,KAAO,GACb,MAAM,GACP,CACA,KACD,CACD,OAAS,EAAM,GAAQ,EAAO,GAC9B,EAAM,GAAQ,EACd,GAAO,EACP,GAAQ,GAAO,EACf,IAAS,GAAK,GAAQ,EACtB,EAAK,QAAU,EACf,EAAK,SAAW,EAChB,EAAK,SAAW,EAAM,EAAO,GAAK,EAAO,GAAO,GAAK,EAAM,GAC3D,EAAK,UAAY,EAAO,EAAM,KAAO,EAAM,GAAQ,KAAO,EAAO,GACjE,EAAM,KAAO,EACb,EAAM,KAAO,CACd,CAGA,IAAI,GAAU,GACV,GAAgB,IAChB,GAAiB,IACjB,GAAU,EACV,GAAS,EACT,GAAU,EACV,GAAQ,IAAI,YAAY,CAC3B,EACA,EACA,EACA,EACA,EACA,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,IACA,IACA,IACA,IACA,EACA,CACD,CAAC,EACG,GAAO,IAAI,WAAW,CACzB,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,EACD,CAAC,EACG,GAAQ,IAAI,YAAY,CAC3B,EACA,EACA,EACA,EACA,EACA,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,IACA,IACA,IACA,IACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,MACA,MACA,EACA,CACD,CAAC,EACG,GAAO,IAAI,WAAW,CACzB,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,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CACA,wCACF,EACA,CACE,8CACA,6CACF,EACA,CACE,mDACA,kDACF,EACA,CACE,yCACA,wCACF,EACA,CACE,mDACA,kDACF,EACA,CACE,oDACA,oDACF,EACA,CACE,qDACA,oDACF,EACA,CACE,mDACA,iDACF,EACA,CACE,sDACA,oDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,uDACA,sDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,iDACA,mDACF,EACA,CACE,iDACA,mDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,2DACA,0DACF,EACA,CACE,oDACA,mDACF,EACA,CACE,qDACA,iDACF,EACA,CACE,wDACA,sDACF,EACA,CACE,qDACA,iDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,2CACA,yCACF,EACA,CACE,gEACA,+DACF,EACA,CACE,iEACA,gEACF,EACA,CACE,gEACA,+DACF,EACA,CACE,+DACA,8DACF,EACA,CACE,qDACA,oDACF,EACA,CACE,wDACA,uDACF,EACA,CACE,gEACA,+DACF,EACA,CACE,wDACA,uDACF,EACA,CACE,wDACA,uDACF,EACA,CACE,gEACA,+DACF,EACA,CACE,iEACA,gEACF,EACA,CACE,gEACA,+DACF,EACA,CACE,+DACA,8DACF,EACA,CACE,gEACA,+DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,gDACA,+CACF,EACA,CACE,2DACA,0DACF,EACA,CACE,8DACA,6DACF,EACA,CACE,6DACA,4DACF,EACA,CACE,yDACA,wDACF,EACA,CACE,2DACA,0DACF,EACA,CACE,6DACA,4DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,qEACA,oEACF,EACA,CACE,6DACA,4DACF,EACA,CACE,+DACA,8DACF,EACA,CACE,iEACA,gEACF,EACA,CACE,0CACA,yCACF,EACA,CACE,+DACA,8DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,8DACA,6DACF,EACA,CACE,6DACA,4DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,+DACA,8DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,uDACA,sDACF,EACA,CACE,4DACA,2DACF,EACA,CACE,8DACA,6DACF,EACA,CACE,qDACA,oDACF,EACA,CACE,+DACA,8DACF,EACA,CACE,6DACA,4DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,+DACA,8DACF,EACA,CACE,uDACA,sDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,uDACA,sDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,kEACA,iEACF,EACA,CACE,oEACA,mEACF,EACA,CACE,kEACA,iDACF,EACA,CACE,sEACA,qEACF,EACA,CACE,6DACA,4DACF,EACA,CACE,iEACA,gEACF,EACA,CACE,qDACA,oDACF,EACA,CACE,2DACA,0DACF,EACA,CACE,qEACA,oEACF,EACA,CACE,yDACA,wDACF,EACA,CACE,uEACA,6DACF,EACA,CACE,2EACA,iEACF,EACA,CACE,wDACA,uDACF,EACA,CACE,iEACA,6DACF,EACA,CACE,qDACA,oDACF,EACA,CACE,qEACA,iEACF,EACA,CACE,2DACA,0DACF,EACA,CACE,sDACA,qDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,2CACA,0CACF,EACA,CACE,0CACA,yCACF,EACA,CACE,2CACA,0CACF,EACA,CACE,0CACA,wCACF,EACA,CACE,4CACA,2CACF,EACA,CACE,kDACA,iDACF,EACA,CACE,4CACA,iDACF,EACA,CACE,+CACA,8CACF,EACA,CACE,oDACA,2CACF,EACA,CACE,gDACA,8CACF,EACA,CACE,+CACA,8CACF,EACA,CACE,+CACA,2CACF,EACA,CACE,8CACA,8CACF,EACA,CACE,qDACA,8CACF,EACA,CACE,sDACA,8CACF,EACA,CACE,+CACA,8CACF,EACA,CACE,yCACA,+CACF,EACA,CACE,+CACA,8CACF,EACA,CACE,iDACA,gDACF,EACA,CACE,+CACA,8CACF,EACA,CACE,iDACA,2CACF,EACA,CACE,mDACA,+CACF,EACA,CACE,0DACA,+CACF,EACA,CACE,gDACA,+CACF,EACA,CACE,uDACA,+CACF,EACA,CACE,oDACA,2CACF,EACA,CACE,4CACA,2CACF,EACA,CACE,wDACA,uDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,0CACA,+CACF,EACA,CACE,mDACA,kDACF,EACA,CACE,+CACA,iDACF,EACA,CACE,gDACA,iDACF,EACA,CACE,+CACA,iDACF,EACA,CACE,+CACA,6CACF,EACA,CACE,8CACA,iDACF,EACA,CACE,+CACA,iDACF,EACA,CACE,8CACA,6CACF,EACA,CACE,iDACA,gDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,+CACA,8CACF,EACA,CACE,4CACA,mEACF,EACA,CACE,6CACA,+CACF,EACA,CACE,8CACA,+CACF,EACA,CACE,4CACA,kFACF,EACA,CACE,6CACA,+CACF,EACA,CACE,8CACA,+CACF,EACA,CACE,6CACA,+CACF,EACA,CACE,8CACA,6CACF,EACA,CACE,8CACA,+CACF,EACA,CACE,8CACA,6CACF,EACA,CACE,8CACA,6CACF,EACA,CACE,4CACA,+CACF,EACA,CACE,6CACA,+CACF,EACA,CACE,yDACA,+CACF,EACA,CACE,+CACA,kFACF,EACA,CACE,+CACA,8CACF,EACA,CACE,4CACA,+CACF,EACA,CACE,2CACA,+CACF,EACA,CACE,gDACA,+CACF,EACA,CACE,4CACA,kFACF,EACA,CACE,4CACA,kFACF,EACA,CACE,+CACA,kFACF,EACA,CACE,sDACA,kFACF,EACA,CACE,iDACA,kFACF,EACA,CACE,+CACA,mDACF,EACA,CACE,4CACA,2CACF,EACA,CACE,yDACA,+CACF,EACA,CACE,6CACA,mEACF,EACA,CACE,4CACA,+CACF,EACA,CACE,6CACA,+CACF,EACA,CACE,6CACA,+CACF,EACA,CACE,iDACA,kFACF,EACA,CACE,4CACA,+CACF,EACA,CACE,6CACA,+CACF,EACA,CACE,gDACA,+CACF,EACA,CACE,qDACA,oDACF,EACA,CACE,gDACA,+CACF,EACA,CACE,mDACA,kDACF,EACA,CACE,sDACA,qDACF,EACA,CACE,8CACA,6CACF,EACA,CACE,oDACA,mDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,wDACA,uDACF,EACA,CACE,0CACA,+CACF,EACA,CACE,2CACA,0CACF,EACA,CACE,+CACA,8CACF,EACA,CACE,mDACA,kDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,gDACA,+CACF,EACA,CACE,uDACA,sDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,gDACA,+CACF,EACA,CACE,sDACA,qDACF,EACA,CACE,kDACA,iDACF,EACA,CACE,oDACA,mDACF,EACA,CACE,uDACA,sDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,sDACA,qDACF,EACA,CACE,qDACA,oDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,mDACA,kDACF,EACA,CACE,gDACA,+CACF,EACA,CACE,yCACA,wCACF,EACA,CACE,oDACA,8CACF,EACA,CACE,gDACA,gDACF,EACA,CACE,uDACA,gDACF,EACA,CACE,kDACA,gDACF,EACA,CACE,iDACA,6CACF,EACA,CACE,wDACA,6CACF,EACA,CACE,iDACA,2CACF,EACA,CACE,6CACA,gDACF,EACA,CACE,mEACA,wDACF,EACA,CACE,gEACA,uDACF,EACA,CACE,mEACA,kDACF,EACA,CACE,mEACA,mDACF,EACA,CACE,iEACA,mDACF,EACA,CACE,2DACA,8CACF,EACA,CACE,6DACA,8CACF,EACA,CACE,0CACA,yCACF,EACA,CACE,6CACA,4CACF,EACA,CACE,6CACA,4CACF,EACA,CACE,qDACA,oDACF,EACA,CACE,iDACA,gDACF,EACA,CACE,+CACA,8CACF,EACA,CACE,mDACA,kDACF,EACA,CACE,4CACA,2CACF,EACA,CACE,yDACA,wDACF,EACA,CAAC,yBAA0B,iCAAiC,EAC5D,CAAC,qBAAsB,6BAA6B,EACpD,CAAC,iCAAkC,yCAAyC,EAC5E,CAAC,mBAAoB,2BAA2B,EAChD,CAAC,uBAAwB,+BAA+B,EACxD,CAAC,mBAAoB,2BAA2B,EAChD,CAAC,qBAAsB,6BAA6B,EACpD,CAAC,oCAAqC,2BAA2B,EACjE,CAAC,2CAA4C,0BAA0B,EACvE,CAAC,oCAAqC,2BAA2B,EACjE,CACE,kCACA,0CACF,EACA,CAAC,6BAA8B,4BAA4B,EAC3D,CAAC,+BAAgC,8BAA8B,EAC/D,CACE,mCACA,8CACF,EACA,CAAC,iCAAkC,gCAAgC,EACnE,CACE,4CACA,2CACF,EACA,CAAC,+BAAgC,uCAAuC,EACxE,CAAC,2BAA4B,0BAA0B,EACvD,CAAC,iCAAkC,gCAAgC,EACnE,CACE,8CACA,sCACF,EACA,CAAC,8BAA+B,6BAA6B,EAC7D,CAAC,kCAAmC,iCAAiC,EACrE,CAAC,iCAAkC,gCAAgC,EACnE,CAAC,0BAA2B,4BAA4B,EACxD,CAAC,2BAA4B,0BAA0B,EACvD,CAAC,iCAAkC,gCAAgC,EACnE,CAAC,4BAA6B,2BAA2B,EACzD,CAAC,8BAA+B,6BAA6B,EAC7D,CAAC,iCAAkC,gCAAgC,EACnE,CAAC,iCAAkC,mCAAmC,EACtE,CAAC,sBAAuB,8BAA8B,EACtD,CAAC,gCAAiC,wCAAwC,EAC1E,CAAC,uBAAwB,+BAA+B,EACxD,CAAC,8BAA+B,sCAAsC,EACtE,CAAC,uBAAwB,+BAA+B,EACxD,CAAC,sBAAuB,8BAA8B,EACtD,CAAC,mBAAoB,2BAA2B,EAChD,CAAC,mBAAoB,2BAA2B,EAChD,CAAC,wBAAyB,gCAAgC,EAC1D,CAAC,kBAAmB,0BAA0B,EAC9C,CACE,kCACA,sDACF,CACF,CAAC,EA6iBY,GAAmD,IAAI,IAAI,CACtE,CAAC,0BAA2B,uBAAuB,EACnD,CAAC,mCAAoC,qCAAqC,CAC5E,CAAC,ECxkDY,GAAsB,CACjC,EAAG,WACH,EAAG,WACH,EAAG,WACH,EAAG,UACL,EAEA,SAAgB,GAAW,EAAsB,CAC/C,IAAM,EAAQ,GAAU,CAAI,EACtB,EAAO,IAAI,SAAS,EAAM,OAAQ,EAAM,WAAY,EAAE,EAC5D,MAAO,CACL,EAAG,EAAK,UAAU,EAAG,EAAK,EAC1B,EAAG,EAAK,UAAU,EAAG,EAAK,EAC1B,EAAG,EAAK,UAAU,EAAG,EAAK,EAC1B,EAAG,EAAK,UAAU,GAAI,EAAK,CAC7B,CACF,CAEA,SAAgB,GAAW,EAAsB,CAC/C,IAAM,EAAQ,IAAI,WAAW,EAAE,EACzB,EAAO,IAAI,SAAS,EAAM,MAAM,EAKtC,OAJA,EAAK,UAAU,EAAG,EAAK,EAAG,EAAK,EAC/B,EAAK,UAAU,EAAG,EAAK,EAAG,EAAK,EAC/B,EAAK,UAAU,EAAG,EAAK,EAAG,EAAK,EAC/B,EAAK,UAAU,GAAI,EAAK,EAAG,EAAK,EACzB,GAAc,MAAM,KAAK,CAAK,CAAC,CACxC,CChCA,IAAa,GAAU,IAA2C,CAChE,KAAM,SACN,UACF,GAEa,EAAQ,IAAsC,CACzD,KAAM,OACN,SACF,4TCZM,GAAc,IAAI,YAClB,GAAc,IAAI,YAAY,QAAS,CAAE,MAAO,EAAK,CAAC,EAEtD,IAAa,EAAW,IAAiB,CAC7C,GAAI,CAAC,OAAO,cAAc,CAAC,EACzB,MAAU,WAAW,SAAS,EAAK,GAAG,EAAE,uBAAuB,CACnE,EAEa,GAAS,GAAkB,EAAE,GAAG,GAAI,EACpC,IAAU,EAAe,IAAe,EAAE,GAAG,EAAI,IAAO,GAAI,EAIzE,SAAgB,GAAK,EAAe,EAAW,CAC7C,GAAI,EAAI,GAAK,EAAI,KAAO,CAAC,OAAO,UAAU,CAAC,EACzC,MAAU,WAAW,gCAAgC,GAAG,EACtD,GAAK,KAEA,EAAI,KAEX,EAAE,GAAG,GAAI,EAJG,EAAE,GAAG,CAAC,CAOtB,CAGA,SAAgB,GAAO,EAAe,EAAW,CAE/C,GADA,GAAU,EAAG,MAAM,EACf,EAAI,EAAG,MAAU,WAAW,8BAA8B,GAAG,EAC7D,GAAK,IAAK,EAAE,GAAG,CAAC,EACX,GAAK,KACZ,EAAE,GAAG,GAAI,EACT,EAAE,GAAG,CAAC,GACG,GAAK,OACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,GACA,GAAK,YACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,IAET,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,OAAO,CAAC,CAAC,EAErB,CAIA,SAAgB,GAAM,EAAe,EAAW,CAC9C,GAAU,EAAG,KAAK,EACd,GAAK,EACH,EAAI,IAAK,EAAE,GAAG,CAAC,EACV,GAAK,OACZ,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,GACA,GAAK,YACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,IAET,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,OAAO,CAAC,CAAC,GAIf,EAAI,IAAK,EAAE,GAAG,IAAQ,CAAC,EAClB,GAAK,MACZ,EAAE,GAAG,GAAI,EACT,EAAE,GAAG,CAAC,GACG,GAAK,QACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,GACA,GAAK,aACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,IAET,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,OAAO,CAAC,CAAC,EAGvB,CAIA,SAAgB,GAAM,EAAe,EAAW,CAC1C,IAAM,KAAK,MAAM,CAAC,GAAK,EAAI,OAAS,EAAI,OAAQ,GAAM,EAAG,IAAM,EAAI,EAAI,CAAC,GAE1E,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,EAEb,CAGA,SAAgB,GAAM,EAAe,EAAW,CAC1C,IAAM,KAAK,MAAM,CAAC,GAAK,EAAI,YAAc,EAAI,YAC/C,GAAM,EAAG,IAAM,EAAI,EAAI,CAAC,GAExB,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAC,EAEb,CAEA,SAAgB,EAAM,EAAe,EAAW,CAC9C,IAAM,EAAQ,GAAY,OAAO,CAAC,EAC5B,EAAM,EAAM,OACd,EAAM,GAAI,EAAE,GAAG,IAAO,CAAG,EACpB,EAAM,KACb,EAAE,GAAG,GAAI,EACT,EAAE,GAAG,CAAG,GACC,GAAO,OAChB,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,IAEX,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,GAEb,EAAE,MAAM,CAAK,CACf,CAEA,SAAgB,GAAY,EAAe,EAAa,CAClD,EAAM,KACR,EAAE,GAAG,GAAI,EACT,EAAE,GAAG,CAAG,GACC,GAAO,OAChB,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,IAEX,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,EAEf,CAEA,SAAgB,GAAc,EAAe,EAAa,CACpD,EAAM,GAAI,EAAE,GAAG,IAAO,CAAG,EACpB,GAAO,OACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,IAEX,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,EAEf,CAEA,SAAgB,GAAY,EAAe,EAAa,CAClD,EAAM,GAAI,EAAE,GAAG,IAAO,CAAG,EACpB,GAAO,OACd,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,IAEX,EAAE,GAAG,GAAI,EACT,EAAE,MAAM,CAAG,EAEf,CAIA,IAAM,GAAc,GAAsB,CACxC,GACE,EAAI,cAA8B,GAClC,EAAI,OAAO,UAAuB,EAElC,MAAU,WACR,sBAAsB,EAAE,+BAC1B,EACF,OAAO,OAAO,CAAC,CACjB,EAEM,IAAa,EAAgB,IAA4B,CAC7D,MAAU,UACR,6BAA6B,EAAO,SAAS,EAAE,EAAE,OAAO,GAC1D,CACF,EAEM,GAAY,IAAe,EAAI,MAAU,EACzC,GAAY,IAAe,EAAI,MAAU,IAG/C,SAAgB,GAAM,EAAuB,CAC3C,IAAM,EAAI,EAAE,GAAG,EACf,GAAI,GAAS,CAAC,EAAG,OAAO,EACxB,GAAI,GAAS,CAAC,EAAG,OAAO,EAAI,IAC5B,OAAQ,EAAR,CACE,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,GAAW,EAAE,MAAM,CAAC,EAC7B,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,GAAW,EAAE,MAAM,CAAC,EAC7B,QACE,OAAO,GAAU,EAAG,SAAS,CACjC,CACF,CAQA,SAAgB,GAAO,EAAuB,CAC5C,IAAM,EAAI,EAAE,GAAG,EAEf,GADI,GAAS,CAAC,GACV,GAAS,CAAC,EAAG,OAAO,EACxB,OAAQ,EAAR,CACE,IAAK,KACL,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,GAAW,EAAE,MAAM,CAAC,EAC7B,QACE,OAAO,GAAU,EAAG,MAAM,CAC9B,CACF,CAGA,SAAgB,GAAM,EAAuB,CAC3C,IAAM,EAAI,EAAE,GAAG,EACf,GAAI,GAAS,CAAC,EAAG,OAAO,EACxB,GAAI,GAAS,CAAC,EAAG,OAAO,EAAI,IAC5B,OAAQ,EAAR,CACE,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,QACE,OAAO,GAAU,EAAG,SAAS,CACjC,CACF,CAGA,SAAgB,GAAM,EAAuB,CAC3C,IAAM,EAAI,EAAE,GAAG,EACf,GAAI,GAAS,CAAC,EAAG,OAAO,EACxB,GAAI,GAAS,CAAC,EAAG,OAAO,EAAI,IAC5B,OAAQ,EAAR,CACE,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,GAAG,EACd,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,IAAK,KACH,OAAO,EAAE,MAAM,EACjB,QACE,OAAO,GAAU,EAAG,SAAS,CACjC,CACF,CAEA,SAAgB,GAAO,EAAwB,CAC7C,IAAM,EAAI,EAAE,GAAG,EAGf,OAFI,IAAM,IAAa,GACnB,IAAM,IAAa,GAChB,GAAU,EAAG,MAAM,CAC5B,CAEA,SAAgB,EAAM,EAAuB,CAC3C,IAAM,EAAI,EAAE,GAAG,EACX,EACJ,IAAK,EAAI,MAAU,IAAM,EAAM,EAAI,QAC9B,GAAI,IAAM,IAAM,EAAM,EAAE,GAAG,OAC3B,GAAI,IAAM,IAAM,EAAM,EAAE,MAAM,OAC9B,GAAI,IAAM,IAAM,EAAM,EAAE,MAAM,OAC9B,OAAO,GAAU,EAAG,KAAK,EAC9B,OAAO,GAAY,OAAO,EAAE,MAAM,CAAG,CAAC,CACxC,CAEA,SAAgB,GAAS,EAAuB,CAC9C,IAAM,EAAI,EAAE,GAAG,EAIf,OAHI,IAAM,IAAa,EAAE,GAAG,EACxB,IAAM,IAAa,EAAE,MAAM,EAC3B,IAAM,IAAa,EAAE,MAAM,EACxB,GAAU,EAAG,KAAK,CAC3B,CAEA,SAAgB,GAAW,EAAuB,CAChD,IAAM,EAAI,EAAE,GAAG,EAIf,OAHK,EAAI,MAAU,IAAa,EAAI,GAChC,IAAM,IAAa,EAAE,MAAM,EAC3B,IAAM,IAAa,EAAE,MAAM,EACxB,GAAU,EAAG,OAAO,CAC7B,CAEA,SAAgB,GAAS,EAAuB,CAC9C,IAAM,EAAI,EAAE,GAAG,EAIf,OAHK,EAAI,MAAU,IAAa,EAAI,GAChC,IAAM,IAAa,EAAE,MAAM,EAC3B,IAAM,IAAa,EAAE,MAAM,EACxB,GAAU,EAAG,KAAK,CAC3B,CAEA,SAAgB,GAAM,EAAqB,CACzC,IAAM,EAAI,EAAE,GAAG,EACX,IAAM,KAAM,GAAU,EAAG,KAAK,CACpC,CCxTA,IAAM,GAAiB,GACrB,EACG,QAAQ,oBAAqB,GAAG,CAAC,CACjC,QAAQ,cAAe,GAAG,CAAC,CAC3B,QAAQ,WAAY,GAAG,EAGtB,GAAQ,OAAO,GAAG,yBAExB,SAAS,GAAgB,EAAqB,CAC5C,IAAM,EAAI,EAAI,QAAQ,KAAM,EAAE,EAG9B,OAFI,EAAE,WAAW,IAAI,EAAU,SAAS,EAAE,MAAM,CAAC,EAAG,CAAC,EACjD,EAAE,WAAW,IAAI,EAAU,SAAS,EAAE,MAAM,CAAC,EAAG,EAAE,EAC/C,SAAS,EAAG,EAAE,CACvB,CAEA,SAAgB,GAAgB,EAA0B,CACxD,IAAM,EAAM,GAAc,CAAI,EACxB,EAAQ,IAAI,IACZ,EAAW,IAAI,IACf,EAAU,IAAI,IACd,EAAS,4DACT,EAAc,IAAI,OACtB,OAAO,GAAG,KAAK,GAAM,8EACvB,EACM,EAAW,IAAI,OAAO,OAAO,GAAG,IAAI,GAAM,EAAE,EAC5C,EAAS,IAAI,OACjB,OAAO,GAAG,4CACZ,EAEI,EAAU,EACV,EACJ,KAAQ,EAAQ,EAAO,KAAK,CAAG,GAAI,CACjC,GAAI,EAAI,MAAM,EAAS,EAAM,KAAK,CAAC,CAAC,KAAK,IAAM,GAC7C,MAAU,MAAM,uCAAuC,EAAM,IAAI,EACnE,EAAU,EAAO,UACjB,GAAM,EAAG,EAAS,EAAM,GAAQ,EAC1B,EAAQ,EACX,MAAM,GAAG,CAAC,CACV,IAAI,GAAK,EAAE,KAAK,CAAC,CAAC,CAClB,OAAO,GAAK,IAAM,EAAE,EAEvB,GAAI,IAAY,OAAQ,CACtB,IAAM,EAAS,IAAI,IACnB,IAAK,IAAM,KAAQ,EAAO,CACxB,IAAM,EAAI,EAAY,KAAK,CAAI,EAC/B,GAAI,CAAC,EACH,MAAU,MAAM,kCAAkC,EAAK,OAAO,GAAM,EACtE,EAAO,IAAI,EAAE,GAAI,GAAgB,EAAE,EAAE,CAAC,CACxC,CACA,EAAM,IAAI,EAAM,CAAM,CACxB,MAAO,GAAI,IAAY,UAAW,CAChC,IAAM,EAAoB,CAAC,EAC3B,IAAK,IAAM,KAAQ,EAAO,CACxB,GAAI,CAAC,EAAS,KAAK,CAAI,EACrB,MAAU,MACR,sCAAsC,EAAK,OAAO,GACpD,EACF,EAAQ,KAAK,CAAI,CACnB,CACA,EAAS,IAAI,EAAM,CAAO,CAC5B,KAAO,CACL,IAAM,EAAQ,IAAI,IAClB,IAAK,IAAM,KAAQ,EAAO,CACxB,IAAM,EAAI,EAAO,KAAK,CAAI,EAC1B,GAAI,CAAC,EACH,MAAU,MACR,uCAAuC,EAAK,OAAO,GACrD,EACF,GAAM,EAAG,EAAM,EAAI,EAAS,GAAU,EACtC,EAAM,IACJ,EACA,EACI,CAAE,KAAM,EAAS,YAAc,QAAS,KAAM,CAAG,EACjD,CAAE,KAAM,OAAQ,KAAM,CAAG,CAC/B,CACF,CACA,EAAQ,IAAI,EAAM,CAAK,CACzB,CACF,CACA,GAAI,EAAI,MAAM,CAAO,CAAC,CAAC,KAAK,IAAM,GAChC,MAAU,MAAM,qCAAqC,EACvD,MAAO,CAAE,QAAO,WAAU,SAAQ,CACpC,CC9EA,IAAa,GAAoD,CAC/D,qBAAsB,CACpB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,sBAAuB,CACrB,iBAAkB,MAClB,iBAAkB,KACpB,EACA,qBAAsB,CACpB,gBAAiB,CAAC,KAAK,EACvB,qBAAsB,CAAC,KAAK,EAC5B,qBAAsB,CAAC,KAAK,EAC5B,0BAA2B,CAAC,KAAK,EACjC,mBAAoB,CAAC,KAAK,EAC1B,mBAAoB,CAAC,KAAK,EAC1B,yBAA0B,CAAC,KAAK,EAChC,uBAAwB,CAAC,KAAK,EAC9B,wBAAyB,CAAC,uBAAuB,EACjD,0BAA2B,KAC7B,CACF,CACF,EACA,qBAAsB,CACpB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,OAAQ,CACN,EAAG,MACH,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,qBAAsB,CACpB,QAAS,CAAC,SAAU,IAAI,EACxB,UAAW,CAAC,KAAK,EACjB,aAAc,CAAC,KAAK,EACpB,aAAc,CAAC,KAAK,EACpB,YAAa,CAAC,KAAK,EACnB,gBAAiB,CAAC,KAAK,EACvB,WAAY,CAAC,KAAK,CACpB,CACF,CACF,EACA,0BAA2B,CACzB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,oBAAqB,CACnB,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,UAAW,CACT,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,0BAA2B,CACzB,eAAgB,CAAC,qBAAqB,EACtC,aAAc,CAAC,WAAW,EAC1B,WAAY,CAAC,KAAK,EAClB,UAAW,CAAC,KAAK,EACjB,cAAe,CAAC,KAAK,EACrB,SAAU,CAAC,KAAK,CAClB,CACF,CACF,EACA,qBAAsB,CACpB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,gBAAiB,CACf,MAAO,CAAC,KAAM,IAAI,CACpB,EACA,kBAAmB,CACjB,EAAG,KACH,EAAG,KACH,EAAG,KACH,EAAG,IACL,EACA,iBAAkB,CAChB,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,wBAAyB,CACvB,WAAY,MACZ,SAAU,KACZ,EACA,6BAA8B,CAC5B,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,qBAAsB,CACpB,6BAA8B,MAC9B,kBAAmB,CAAC,yBAAyB,EAC7C,WAAY,CAAC,kBAAkB,EAC/B,iBAAkB,CAAC,KAAK,EACxB,aAAc,CAAC,KAAK,EACpB,qBAAsB,CAAC,KAAK,EAC5B,kBAAmB,CAAC,+BAAgC,IAAI,EACxD,aAAc,CAAC,KAAM,IAAI,EACzB,sBAAuB,kBACvB,uBAAwB,kBACxB,uBAAwB,kBACxB,uBAAwB,kBACxB,sBAAuB,kBACvB,2BAA4B,kBAC5B,uBAAwB,kBACxB,gBAAiB,kBACjB,gBAAiB,CAAC,KAAM,IAAI,EAC5B,gBAAiB,CAAC,oBAAqB,IAAI,EAC3C,iBAAkB,MACpB,CACF,CACF,EACA,oBAAqB,CACnB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,gBAAiB,CACf,MAAO,CAAC,KAAM,IAAI,CACpB,EACA,oBAAqB,CACnB,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,2BAA4B,CAC1B,kBAAmB,MACnB,mBAAoB,MACpB,UAAW,KACb,EACA,sBAAuB,CACrB,kBAAmB,MACnB,mBAAoB,MACpB,UAAW,KACb,EACA,4BAA6B,CAC3B,oBAAqB,MACrB,WAAY,sBACZ,kBAAmB,MACnB,mBAAoB,MACpB,UAAW,KACb,EACA,oBAAqB,CACnB,kBAAmB,CAAC,6BAA6B,EACjD,iBAAkB,CAAC,4BAA4B,EAC/C,kBAAmB,CAAC,uBAAuB,EAC3C,iBAAkB,CAAC,uBAAuB,EAC1C,wBAAyB,iBAC3B,CACF,CACF,EACA,yBAA0B,CACxB,MAAO,CAAC,EACR,SAAU,CAAC,EACX,QAAS,CACP,iCAAkC,CAChC,UAAW,MACX,aAAc,KAChB,EACA,OAAQ,CACN,EAAG,MACH,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,SAAU,CACR,EAAG,MACH,EAAG,MACH,EAAG,KACL,EACA,yBAA0B,CACxB,sBAAuB,CAAC,kCAAkC,EAC1D,sBAAuB,CAAC,KAAK,EAC7B,kBAAmB,CAAC,KAAK,EACzB,sBAAuB,CAAC,KAAK,EAC7B,4BAA6B,CAAC,WAAY,IAAI,EAC9C,8BAA+B,CAAC,SAAU,IAAI,EAC9C,sBAAuB,CAAC,KAAK,EAC7B,6BAA8B,CAAC,KAAK,CACtC,CACF,CACF,EACA,6BAA8B,CAC5B,MAAO,CACL,cAAe,CACb,wBAAyB,EACzB,sBAAuB,EACvB,uBAAwB,EACxB,qBAAsB,EACtB,mCAAoC,CACtC,EACA,qBAAsB,CACpB,+BAAgC,EAChC,+BAAgC,EAChC,gCAAiC,EACjC,kCAAmC,EACnC,iDAAkD,CACpD,EACA,4BAA6B,CAC3B,oCAAqC,EACrC,sCAAuC,EACvC,qCAAsC,EACtC,+DAAgE,CAClE,EACA,mBAAoB,CAClB,yBAA0B,EAC1B,0BAA2B,EAC3B,4BAA6B,EAC7B,6CAA8C,CAChD,EACA,kBAAmB,CACjB,4BAA6B,EAC7B,0BAA2B,EAC3B,0BAA2B,EAC3B,2BAA4B,EAC5B,2BAA4B,EAC5B,2BAA4B,EAC5B,0BAA2B,EAC3B,0BAA2B,EAC3B,0BAA2B,EAC3B,6BAA8B,EAC9B,4BAA6B,GAC7B,2CAA4C,EAC9C,EACA,WAAY,CACV,gBAAiB,EACjB,gBAAiB,EACjB,gBAAiB,EACjB,kBAAmB,CACrB,EACA,gBAAiB,CACf,8BAA+B,EAC/B,8BAA+B,EAC/B,8BAA+B,EAC/B,8BAA+B,EAC/B,8BAA+B,EAC/B,8BAA+B,EAC/B,uBAAwB,CAC1B,EACA,eAAgB,CACd,0BAA2B,EAC3B,wBAAyB,EACzB,qCAAsC,EACtC,uBAAwB,EACxB,wBAAyB,EACzB,2BAA4B,EAC5B,qCAAsC,CACxC,EACA,2BAA4B,CAC1B,mCAAoC,EACpC,qCAAsC,EACtC,qCAAsC,EACtC,6DAA8D,CAChE,EACA,0BAA2B,CACzB,qCAAsC,EACtC,mCAAoC,EACpC,oCAAqC,EACrC,kCAAmC,EACnC,2DAA4D,CAC9D,EACA,wBAAyB,CACvB,oCAAqC,EACrC,oCAAqC,EACrC,oCAAqC,EACrC,oCAAqC,EACrC,uDAAwD,CAC1D,EACA,cAAe,CACb,sBAAuB,EACvB,sBAAuB,EACvB,yBAA0B,EAC1B,mCAAoC,CACtC,EACA,gBAAiB,CACf,yBAA0B,EAC1B,4BAA6B,EAC7B,2BAA4B,EAC5B,4BAA6B,EAC7B,wBAAyB,EACzB,sCAAuC,EACvC,yBAA0B,EAC1B,uCAAwC,CAC1C,EACA,eAAgB,CACd,uBAAwB,EACxB,0BAA2B,EAC3B,2BAA4B,EAC5B,gCAAiC,EACjC,iCAAkC,EAClC,qCAAsC,CACxC,EACA,eAAgB,CACd,uBAAwB,EACxB,0BAA2B,EAC3B,yBAA0B,EAC1B,gCAAiC,EACjC,+BAAgC,EAChC,0BAA2B,EAC3B,qCAAsC,CACxC,EACA,gBAAiB,CACf,2BAA4B,EAC5B,wBAAyB,EACzB,0BAA2B,EAC3B,8BAA+B,EAC/B,uCAAwC,CAC1C,EACA,yBAA0B,CACxB,uCAAwC,EACxC,8CAA+C,EAC/C,yDAA0D,CAC5D,CACF,EACA,SAAU,CACR,sBAAuB,CACrB,uBACA,sBACA,qBACA,uBACA,uBACA,wBACA,qBACA,uBACA,4BACA,2BACF,EACA,0BAA2B,CACzB,qCACA,gCACA,6CACA,oCACA,oCACA,qCACA,qCACA,mCACA,uCACA,wCACA,mCACA,8CACA,gDACA,iDACA,0CACA,mCACF,EACA,qBAAsB,CACpB,kBACA,aACA,iBACA,0BACA,iBACA,iBACA,kBACA,kBACA,gBACA,oBACA,qBACA,gBACA,2BACA,6BACA,8BACA,sBACF,EACA,yBAA0B,CACxB,MACA,MACA,SACA,UACA,OACA,aACF,EACA,iBAAkB,CAChB,MACA,MACA,OACA,cACA,gBACA,SACA,UACA,OACA,MACA,cACA,sBACF,CACF,EACA,QAAS,CACP,gCAAiC,CAC/B,SAAU,OACV,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"}