mapshaper 0.6.16 → 0.6.18

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.16";
+  var VERSION = "0.6.18";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -7154,6 +7154,1907 @@
     getOutputFileBase: getOutputFileBase
   });
 
+  // Integer Utility
+  var UINT32_MAX = 4294967295;
+  // DataView extension to handle int64 / uint64,
+  // where the actual range is 53-bits integer (a.k.a. safe integer)
+  function setUint64(view, offset, value) {
+      var high = value / 4294967296;
+      var low = value; // high bits are truncated by DataView
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+  }
+  function setInt64(view, offset, value) {
+      var high = Math.floor(value / 4294967296);
+      var low = value; // high bits are truncated by DataView
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+  }
+  function getInt64(view, offset) {
+      var high = view.getInt32(offset);
+      var low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+  }
+  function getUint64(view, offset) {
+      var high = view.getUint32(offset);
+      var low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+  }
+
+  var _a$1, _b$1, _c;
+  var TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a$1 = process === null || process === void 0 ? void 0 : process.env) === null || _a$1 === void 0 ? void 0 : _a$1["TEXT_ENCODING"]) !== "never") &&
+      typeof TextEncoder !== "undefined" &&
+      typeof TextDecoder !== "undefined";
+  function utf8Count(str) {
+      var strLength = str.length;
+      var byteLength = 0;
+      var pos = 0;
+      while (pos < strLength) {
+          var value = str.charCodeAt(pos++);
+          if ((value & 0xffffff80) === 0) {
+              // 1-byte
+              byteLength++;
+              continue;
+          }
+          else if ((value & 0xfffff800) === 0) {
+              // 2-bytes
+              byteLength += 2;
+          }
+          else {
+              // handle surrogate pair
+              if (value >= 0xd800 && value <= 0xdbff) {
+                  // high surrogate
+                  if (pos < strLength) {
+                      var extra = str.charCodeAt(pos);
+                      if ((extra & 0xfc00) === 0xdc00) {
+                          ++pos;
+                          value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                      }
+                  }
+              }
+              if ((value & 0xffff0000) === 0) {
+                  // 3-byte
+                  byteLength += 3;
+              }
+              else {
+                  // 4-byte
+                  byteLength += 4;
+              }
+          }
+      }
+      return byteLength;
+  }
+  function utf8EncodeJs(str, output, outputOffset) {
+      var strLength = str.length;
+      var offset = outputOffset;
+      var pos = 0;
+      while (pos < strLength) {
+          var value = str.charCodeAt(pos++);
+          if ((value & 0xffffff80) === 0) {
+              // 1-byte
+              output[offset++] = value;
+              continue;
+          }
+          else if ((value & 0xfffff800) === 0) {
+              // 2-bytes
+              output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+          }
+          else {
+              // handle surrogate pair
+              if (value >= 0xd800 && value <= 0xdbff) {
+                  // high surrogate
+                  if (pos < strLength) {
+                      var extra = str.charCodeAt(pos);
+                      if ((extra & 0xfc00) === 0xdc00) {
+                          ++pos;
+                          value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                      }
+                  }
+              }
+              if ((value & 0xffff0000) === 0) {
+                  // 3-byte
+                  output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                  output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+              }
+              else {
+                  // 4-byte
+                  output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                  output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                  output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+              }
+          }
+          output[offset++] = (value & 0x3f) | 0x80;
+      }
+  }
+  var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
+  var TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+      ? UINT32_MAX
+      : typeof process !== "undefined" && ((_b$1 = process === null || process === void 0 ? void 0 : process.env) === null || _b$1 === void 0 ? void 0 : _b$1["TEXT_ENCODING"]) !== "force"
+          ? 200
+          : 0;
+  function utf8EncodeTEencode(str, output, outputOffset) {
+      output.set(sharedTextEncoder.encode(str), outputOffset);
+  }
+  function utf8EncodeTEencodeInto(str, output, outputOffset) {
+      sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+  }
+  var utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+  var CHUNK_SIZE = 4096;
+  function utf8DecodeJs(bytes, inputOffset, byteLength) {
+      var offset = inputOffset;
+      var end = offset + byteLength;
+      var units = [];
+      var result = "";
+      while (offset < end) {
+          var byte1 = bytes[offset++];
+          if ((byte1 & 0x80) === 0) {
+              // 1 byte
+              units.push(byte1);
+          }
+          else if ((byte1 & 0xe0) === 0xc0) {
+              // 2 bytes
+              var byte2 = bytes[offset++] & 0x3f;
+              units.push(((byte1 & 0x1f) << 6) | byte2);
+          }
+          else if ((byte1 & 0xf0) === 0xe0) {
+              // 3 bytes
+              var byte2 = bytes[offset++] & 0x3f;
+              var byte3 = bytes[offset++] & 0x3f;
+              units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+          }
+          else if ((byte1 & 0xf8) === 0xf0) {
+              // 4 bytes
+              var byte2 = bytes[offset++] & 0x3f;
+              var byte3 = bytes[offset++] & 0x3f;
+              var byte4 = bytes[offset++] & 0x3f;
+              var unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+              if (unit > 0xffff) {
+                  unit -= 0x10000;
+                  units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                  unit = 0xdc00 | (unit & 0x3ff);
+              }
+              units.push(unit);
+          }
+          else {
+              units.push(byte1);
+          }
+          if (units.length >= CHUNK_SIZE) {
+              result += String.fromCharCode.apply(String, units);
+              units.length = 0;
+          }
+      }
+      if (units.length > 0) {
+          result += String.fromCharCode.apply(String, units);
+      }
+      return result;
+  }
+  var sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
+  var TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+      ? UINT32_MAX
+      : typeof process !== "undefined" && ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c["TEXT_DECODER"]) !== "force"
+          ? 200
+          : 0;
+  function utf8DecodeTD(bytes, inputOffset, byteLength) {
+      var stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+      return sharedTextDecoder.decode(stringBytes);
+  }
+
+  /**
+   * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+   */
+  var ExtData = /** @class */ (function () {
+      function ExtData(type, data) {
+          this.type = type;
+          this.data = data;
+      }
+      return ExtData;
+  }());
+
+  var __extends = (null && null.__extends) || (function () {
+      var extendStatics = function (d, b) {
+          extendStatics = Object.setPrototypeOf ||
+              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+              function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+          return extendStatics(d, b);
+      };
+      return function (d, b) {
+          if (typeof b !== "function" && b !== null)
+              throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() { this.constructor = d; }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+  })();
+  var DecodeError = /** @class */ (function (_super) {
+      __extends(DecodeError, _super);
+      function DecodeError(message) {
+          var _this = _super.call(this, message) || this;
+          // fix the prototype chain in a cross-platform way
+          var proto = Object.create(DecodeError.prototype);
+          Object.setPrototypeOf(_this, proto);
+          Object.defineProperty(_this, "name", {
+              configurable: true,
+              enumerable: false,
+              value: DecodeError.name,
+          });
+          return _this;
+      }
+      return DecodeError;
+  }(Error));
+
+  // https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+  var EXT_TIMESTAMP = -1;
+  var TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+  var TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+  function encodeTimeSpecToTimestamp(_a) {
+      var sec = _a.sec, nsec = _a.nsec;
+      if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+          // Here sec >= 0 && nsec >= 0
+          if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+              // timestamp 32 = { sec32 (unsigned) }
+              var rv = new Uint8Array(4);
+              var view = new DataView(rv.buffer);
+              view.setUint32(0, sec);
+              return rv;
+          }
+          else {
+              // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
+              var secHigh = sec / 0x100000000;
+              var secLow = sec & 0xffffffff;
+              var rv = new Uint8Array(8);
+              var view = new DataView(rv.buffer);
+              // nsec30 | secHigh2
+              view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
+              // secLow32
+              view.setUint32(4, secLow);
+              return rv;
+          }
+      }
+      else {
+          // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+          var rv = new Uint8Array(12);
+          var view = new DataView(rv.buffer);
+          view.setUint32(0, nsec);
+          setInt64(view, 4, sec);
+          return rv;
+      }
+  }
+  function encodeDateToTimeSpec(date) {
+      var msec = date.getTime();
+      var sec = Math.floor(msec / 1e3);
+      var nsec = (msec - sec * 1e3) * 1e6;
+      // Normalizes { sec, nsec } to ensure nsec is unsigned.
+      var nsecInSec = Math.floor(nsec / 1e9);
+      return {
+          sec: sec + nsecInSec,
+          nsec: nsec - nsecInSec * 1e9,
+      };
+  }
+  function encodeTimestampExtension(object) {
+      if (object instanceof Date) {
+          var timeSpec = encodeDateToTimeSpec(object);
+          return encodeTimeSpecToTimestamp(timeSpec);
+      }
+      else {
+          return null;
+      }
+  }
+  function decodeTimestampToTimeSpec(data) {
+      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      // data may be 32, 64, or 96 bits
+      switch (data.byteLength) {
+          case 4: {
+              // timestamp 32 = { sec32 }
+              var sec = view.getUint32(0);
+              var nsec = 0;
+              return { sec: sec, nsec: nsec };
+          }
+          case 8: {
+              // timestamp 64 = { nsec30, sec34 }
+              var nsec30AndSecHigh2 = view.getUint32(0);
+              var secLow32 = view.getUint32(4);
+              var sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+              var nsec = nsec30AndSecHigh2 >>> 2;
+              return { sec: sec, nsec: nsec };
+          }
+          case 12: {
+              // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+              var sec = getInt64(view, 4);
+              var nsec = view.getUint32(0);
+              return { sec: sec, nsec: nsec };
+          }
+          default:
+              throw new DecodeError("Unrecognized data size for timestamp (expected 4, 8, or 12): ".concat(data.length));
+      }
+  }
+  function decodeTimestampExtension(data) {
+      var timeSpec = decodeTimestampToTimeSpec(data);
+      return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+  }
+  var timestampExtension = {
+      type: EXT_TIMESTAMP,
+      encode: encodeTimestampExtension,
+      decode: decodeTimestampExtension,
+  };
+
+  // ExtensionCodec to handle MessagePack extensions
+  var ExtensionCodec = /** @class */ (function () {
+      function ExtensionCodec() {
+          // built-in extensions
+          this.builtInEncoders = [];
+          this.builtInDecoders = [];
+          // custom extensions
+          this.encoders = [];
+          this.decoders = [];
+          this.register(timestampExtension);
+      }
+      ExtensionCodec.prototype.register = function (_a) {
+          var type = _a.type, encode = _a.encode, decode = _a.decode;
+          if (type >= 0) {
+              // custom extensions
+              this.encoders[type] = encode;
+              this.decoders[type] = decode;
+          }
+          else {
+              // built-in extensions
+              var index = 1 + type;
+              this.builtInEncoders[index] = encode;
+              this.builtInDecoders[index] = decode;
+          }
+      };
+      ExtensionCodec.prototype.tryToEncode = function (object, context) {
+          // built-in extensions
+          for (var i = 0; i < this.builtInEncoders.length; i++) {
+              var encodeExt = this.builtInEncoders[i];
+              if (encodeExt != null) {
+                  var data = encodeExt(object, context);
+                  if (data != null) {
+                      var type = -1 - i;
+                      return new ExtData(type, data);
+                  }
+              }
+          }
+          // custom extensions
+          for (var i = 0; i < this.encoders.length; i++) {
+              var encodeExt = this.encoders[i];
+              if (encodeExt != null) {
+                  var data = encodeExt(object, context);
+                  if (data != null) {
+                      var type = i;
+                      return new ExtData(type, data);
+                  }
+              }
+          }
+          if (object instanceof ExtData) {
+              // to keep ExtData as is
+              return object;
+          }
+          return null;
+      };
+      ExtensionCodec.prototype.decode = function (data, type, context) {
+          var decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+          if (decodeExt) {
+              return decodeExt(data, type, context);
+          }
+          else {
+              // decode() does not fail, returns ExtData instead.
+              return new ExtData(type, data);
+          }
+      };
+      ExtensionCodec.defaultCodec = new ExtensionCodec();
+      return ExtensionCodec;
+  }());
+
+  function ensureUint8Array(buffer) {
+      if (buffer instanceof Uint8Array) {
+          return buffer;
+      }
+      else if (ArrayBuffer.isView(buffer)) {
+          return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      }
+      else if (buffer instanceof ArrayBuffer) {
+          return new Uint8Array(buffer);
+      }
+      else {
+          // ArrayLike<number>
+          return Uint8Array.from(buffer);
+      }
+  }
+  function createDataView(buffer) {
+      if (buffer instanceof ArrayBuffer) {
+          return new DataView(buffer);
+      }
+      var bufferView = ensureUint8Array(buffer);
+      return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
+  }
+
+  var DEFAULT_MAX_DEPTH = 100;
+  var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+  var Encoder = /** @class */ (function () {
+      function Encoder(extensionCodec, context, maxDepth, initialBufferSize, sortKeys, forceFloat32, ignoreUndefined, forceIntegerToFloat) {
+          if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }
+          if (context === void 0) { context = undefined; }
+          if (maxDepth === void 0) { maxDepth = DEFAULT_MAX_DEPTH; }
+          if (initialBufferSize === void 0) { initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE; }
+          if (sortKeys === void 0) { sortKeys = false; }
+          if (forceFloat32 === void 0) { forceFloat32 = false; }
+          if (ignoreUndefined === void 0) { ignoreUndefined = false; }
+          if (forceIntegerToFloat === void 0) { forceIntegerToFloat = false; }
+          this.extensionCodec = extensionCodec;
+          this.context = context;
+          this.maxDepth = maxDepth;
+          this.initialBufferSize = initialBufferSize;
+          this.sortKeys = sortKeys;
+          this.forceFloat32 = forceFloat32;
+          this.ignoreUndefined = ignoreUndefined;
+          this.forceIntegerToFloat = forceIntegerToFloat;
+          this.pos = 0;
+          this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+          this.bytes = new Uint8Array(this.view.buffer);
+      }
+      Encoder.prototype.reinitializeState = function () {
+          this.pos = 0;
+      };
+      /**
+       * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+       *
+       * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+       */
+      Encoder.prototype.encodeSharedRef = function (object) {
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.subarray(0, this.pos);
+      };
+      /**
+       * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+       */
+      Encoder.prototype.encode = function (object) {
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.slice(0, this.pos);
+      };
+      Encoder.prototype.doEncode = function (object, depth) {
+          if (depth > this.maxDepth) {
+              throw new Error("Too deep objects in depth ".concat(depth));
+          }
+          if (object == null) {
+              this.encodeNil();
+          }
+          else if (typeof object === "boolean") {
+              this.encodeBoolean(object);
+          }
+          else if (typeof object === "number") {
+              this.encodeNumber(object);
+          }
+          else if (typeof object === "string") {
+              this.encodeString(object);
+          }
+          else {
+              this.encodeObject(object, depth);
+          }
+      };
+      Encoder.prototype.ensureBufferSizeToWrite = function (sizeToWrite) {
+          var requiredSize = this.pos + sizeToWrite;
+          if (this.view.byteLength < requiredSize) {
+              this.resizeBuffer(requiredSize * 2);
+          }
+      };
+      Encoder.prototype.resizeBuffer = function (newSize) {
+          var newBuffer = new ArrayBuffer(newSize);
+          var newBytes = new Uint8Array(newBuffer);
+          var newView = new DataView(newBuffer);
+          newBytes.set(this.bytes);
+          this.view = newView;
+          this.bytes = newBytes;
+      };
+      Encoder.prototype.encodeNil = function () {
+          this.writeU8(0xc0);
+      };
+      Encoder.prototype.encodeBoolean = function (object) {
+          if (object === false) {
+              this.writeU8(0xc2);
+          }
+          else {
+              this.writeU8(0xc3);
+          }
+      };
+      Encoder.prototype.encodeNumber = function (object) {
+          if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {
+              if (object >= 0) {
+                  if (object < 0x80) {
+                      // positive fixint
+                      this.writeU8(object);
+                  }
+                  else if (object < 0x100) {
+                      // uint 8
+                      this.writeU8(0xcc);
+                      this.writeU8(object);
+                  }
+                  else if (object < 0x10000) {
+                      // uint 16
+                      this.writeU8(0xcd);
+                      this.writeU16(object);
+                  }
+                  else if (object < 0x100000000) {
+                      // uint 32
+                      this.writeU8(0xce);
+                      this.writeU32(object);
+                  }
+                  else {
+                      // uint 64
+                      this.writeU8(0xcf);
+                      this.writeU64(object);
+                  }
+              }
+              else {
+                  if (object >= -0x20) {
+                      // negative fixint
+                      this.writeU8(0xe0 | (object + 0x20));
+                  }
+                  else if (object >= -0x80) {
+                      // int 8
+                      this.writeU8(0xd0);
+                      this.writeI8(object);
+                  }
+                  else if (object >= -0x8000) {
+                      // int 16
+                      this.writeU8(0xd1);
+                      this.writeI16(object);
+                  }
+                  else if (object >= -0x80000000) {
+                      // int 32
+                      this.writeU8(0xd2);
+                      this.writeI32(object);
+                  }
+                  else {
+                      // int 64
+                      this.writeU8(0xd3);
+                      this.writeI64(object);
+                  }
+              }
+          }
+          else {
+              // non-integer numbers
+              if (this.forceFloat32) {
+                  // float 32
+                  this.writeU8(0xca);
+                  this.writeF32(object);
+              }
+              else {
+                  // float 64
+                  this.writeU8(0xcb);
+                  this.writeF64(object);
+              }
+          }
+      };
+      Encoder.prototype.writeStringHeader = function (byteLength) {
+          if (byteLength < 32) {
+              // fixstr
+              this.writeU8(0xa0 + byteLength);
+          }
+          else if (byteLength < 0x100) {
+              // str 8
+              this.writeU8(0xd9);
+              this.writeU8(byteLength);
+          }
+          else if (byteLength < 0x10000) {
+              // str 16
+              this.writeU8(0xda);
+              this.writeU16(byteLength);
+          }
+          else if (byteLength < 0x100000000) {
+              // str 32
+              this.writeU8(0xdb);
+              this.writeU32(byteLength);
+          }
+          else {
+              throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
+          }
+      };
+      Encoder.prototype.encodeString = function (object) {
+          var maxHeaderSize = 1 + 4;
+          var strLength = object.length;
+          if (strLength > TEXT_ENCODER_THRESHOLD) {
+              var byteLength = utf8Count(object);
+              this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+              this.writeStringHeader(byteLength);
+              utf8EncodeTE(object, this.bytes, this.pos);
+              this.pos += byteLength;
+          }
+          else {
+              var byteLength = utf8Count(object);
+              this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+              this.writeStringHeader(byteLength);
+              utf8EncodeJs(object, this.bytes, this.pos);
+              this.pos += byteLength;
+          }
+      };
+      Encoder.prototype.encodeObject = function (object, depth) {
+          // try to encode objects with custom codec first of non-primitives
+          var ext = this.extensionCodec.tryToEncode(object, this.context);
+          if (ext != null) {
+              this.encodeExtension(ext);
+          }
+          else if (Array.isArray(object)) {
+              this.encodeArray(object, depth);
+          }
+          else if (ArrayBuffer.isView(object)) {
+              this.encodeBinary(object);
+          }
+          else if (typeof object === "object") {
+              this.encodeMap(object, depth);
+          }
+          else {
+              // symbol, function and other special object come here unless extensionCodec handles them.
+              throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
+          }
+      };
+      Encoder.prototype.encodeBinary = function (object) {
+          var size = object.byteLength;
+          if (size < 0x100) {
+              // bin 8
+              this.writeU8(0xc4);
+              this.writeU8(size);
+          }
+          else if (size < 0x10000) {
+              // bin 16
+              this.writeU8(0xc5);
+              this.writeU16(size);
+          }
+          else if (size < 0x100000000) {
+              // bin 32
+              this.writeU8(0xc6);
+              this.writeU32(size);
+          }
+          else {
+              throw new Error("Too large binary: ".concat(size));
+          }
+          var bytes = ensureUint8Array(object);
+          this.writeU8a(bytes);
+      };
+      Encoder.prototype.encodeArray = function (object, depth) {
+          var size = object.length;
+          if (size < 16) {
+              // fixarray
+              this.writeU8(0x90 + size);
+          }
+          else if (size < 0x10000) {
+              // array 16
+              this.writeU8(0xdc);
+              this.writeU16(size);
+          }
+          else if (size < 0x100000000) {
+              // array 32
+              this.writeU8(0xdd);
+              this.writeU32(size);
+          }
+          else {
+              throw new Error("Too large array: ".concat(size));
+          }
+          for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
+              var item = object_1[_i];
+              this.doEncode(item, depth + 1);
+          }
+      };
+      Encoder.prototype.countWithoutUndefined = function (object, keys) {
+          var count = 0;
+          for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+              var key = keys_1[_i];
+              if (object[key] !== undefined) {
+                  count++;
+              }
+          }
+          return count;
+      };
+      Encoder.prototype.encodeMap = function (object, depth) {
+          var keys = Object.keys(object);
+          if (this.sortKeys) {
+              keys.sort();
+          }
+          var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+          if (size < 16) {
+              // fixmap
+              this.writeU8(0x80 + size);
+          }
+          else if (size < 0x10000) {
+              // map 16
+              this.writeU8(0xde);
+              this.writeU16(size);
+          }
+          else if (size < 0x100000000) {
+              // map 32
+              this.writeU8(0xdf);
+              this.writeU32(size);
+          }
+          else {
+              throw new Error("Too large map object: ".concat(size));
+          }
+          for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
+              var key = keys_2[_i];
+              var value = object[key];
+              if (!(this.ignoreUndefined && value === undefined)) {
+                  this.encodeString(key);
+                  this.doEncode(value, depth + 1);
+              }
+          }
+      };
+      Encoder.prototype.encodeExtension = function (ext) {
+          var size = ext.data.length;
+          if (size === 1) {
+              // fixext 1
+              this.writeU8(0xd4);
+          }
+          else if (size === 2) {
+              // fixext 2
+              this.writeU8(0xd5);
+          }
+          else if (size === 4) {
+              // fixext 4
+              this.writeU8(0xd6);
+          }
+          else if (size === 8) {
+              // fixext 8
+              this.writeU8(0xd7);
+          }
+          else if (size === 16) {
+              // fixext 16
+              this.writeU8(0xd8);
+          }
+          else if (size < 0x100) {
+              // ext 8
+              this.writeU8(0xc7);
+              this.writeU8(size);
+          }
+          else if (size < 0x10000) {
+              // ext 16
+              this.writeU8(0xc8);
+              this.writeU16(size);
+          }
+          else if (size < 0x100000000) {
+              // ext 32
+              this.writeU8(0xc9);
+              this.writeU32(size);
+          }
+          else {
+              throw new Error("Too large extension object: ".concat(size));
+          }
+          this.writeI8(ext.type);
+          this.writeU8a(ext.data);
+      };
+      Encoder.prototype.writeU8 = function (value) {
+          this.ensureBufferSizeToWrite(1);
+          this.view.setUint8(this.pos, value);
+          this.pos++;
+      };
+      Encoder.prototype.writeU8a = function (values) {
+          var size = values.length;
+          this.ensureBufferSizeToWrite(size);
+          this.bytes.set(values, this.pos);
+          this.pos += size;
+      };
+      Encoder.prototype.writeI8 = function (value) {
+          this.ensureBufferSizeToWrite(1);
+          this.view.setInt8(this.pos, value);
+          this.pos++;
+      };
+      Encoder.prototype.writeU16 = function (value) {
+          this.ensureBufferSizeToWrite(2);
+          this.view.setUint16(this.pos, value);
+          this.pos += 2;
+      };
+      Encoder.prototype.writeI16 = function (value) {
+          this.ensureBufferSizeToWrite(2);
+          this.view.setInt16(this.pos, value);
+          this.pos += 2;
+      };
+      Encoder.prototype.writeU32 = function (value) {
+          this.ensureBufferSizeToWrite(4);
+          this.view.setUint32(this.pos, value);
+          this.pos += 4;
+      };
+      Encoder.prototype.writeI32 = function (value) {
+          this.ensureBufferSizeToWrite(4);
+          this.view.setInt32(this.pos, value);
+          this.pos += 4;
+      };
+      Encoder.prototype.writeF32 = function (value) {
+          this.ensureBufferSizeToWrite(4);
+          this.view.setFloat32(this.pos, value);
+          this.pos += 4;
+      };
+      Encoder.prototype.writeF64 = function (value) {
+          this.ensureBufferSizeToWrite(8);
+          this.view.setFloat64(this.pos, value);
+          this.pos += 8;
+      };
+      Encoder.prototype.writeU64 = function (value) {
+          this.ensureBufferSizeToWrite(8);
+          setUint64(this.view, this.pos, value);
+          this.pos += 8;
+      };
+      Encoder.prototype.writeI64 = function (value) {
+          this.ensureBufferSizeToWrite(8);
+          setInt64(this.view, this.pos, value);
+          this.pos += 8;
+      };
+      return Encoder;
+  }());
+
+  var defaultEncodeOptions = {};
+  /**
+   * It encodes `value` in the MessagePack format and
+   * returns a byte buffer.
+   *
+   * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+   */
+  function encode(value, options) {
+      if (options === void 0) { options = defaultEncodeOptions; }
+      var encoder = new Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat);
+      return encoder.encodeSharedRef(value);
+  }
+
+  function prettyByte(byte) {
+      return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
+  }
+
+  var DEFAULT_MAX_KEY_LENGTH = 16;
+  var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+  var CachedKeyDecoder = /** @class */ (function () {
+      function CachedKeyDecoder(maxKeyLength, maxLengthPerKey) {
+          if (maxKeyLength === void 0) { maxKeyLength = DEFAULT_MAX_KEY_LENGTH; }
+          if (maxLengthPerKey === void 0) { maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY; }
+          this.maxKeyLength = maxKeyLength;
+          this.maxLengthPerKey = maxLengthPerKey;
+          this.hit = 0;
+          this.miss = 0;
+          // avoid `new Array(N)`, which makes a sparse array,
+          // because a sparse array is typically slower than a non-sparse array.
+          this.caches = [];
+          for (var i = 0; i < this.maxKeyLength; i++) {
+              this.caches.push([]);
+          }
+      }
+      CachedKeyDecoder.prototype.canBeCached = function (byteLength) {
+          return byteLength > 0 && byteLength <= this.maxKeyLength;
+      };
+      CachedKeyDecoder.prototype.find = function (bytes, inputOffset, byteLength) {
+          var records = this.caches[byteLength - 1];
+          FIND_CHUNK: for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
+              var record = records_1[_i];
+              var recordBytes = record.bytes;
+              for (var j = 0; j < byteLength; j++) {
+                  if (recordBytes[j] !== bytes[inputOffset + j]) {
+                      continue FIND_CHUNK;
+                  }
+              }
+              return record.str;
+          }
+          return null;
+      };
+      CachedKeyDecoder.prototype.store = function (bytes, value) {
+          var records = this.caches[bytes.length - 1];
+          var record = { bytes: bytes, str: value };
+          if (records.length >= this.maxLengthPerKey) {
+              // `records` are full!
+              // Set `record` to an arbitrary position.
+              records[(Math.random() * records.length) | 0] = record;
+          }
+          else {
+              records.push(record);
+          }
+      };
+      CachedKeyDecoder.prototype.decode = function (bytes, inputOffset, byteLength) {
+          var cachedValue = this.find(bytes, inputOffset, byteLength);
+          if (cachedValue != null) {
+              this.hit++;
+              return cachedValue;
+          }
+          this.miss++;
+          var str = utf8DecodeJs(bytes, inputOffset, byteLength);
+          // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+          var slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+          this.store(slicedCopyOfBytes, str);
+          return str;
+      };
+      return CachedKeyDecoder;
+  }());
+
+  var __awaiter$1 = (null && null.__awaiter) || function (thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  };
+  var __generator$2 = (null && null.__generator) || function (thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (_) try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+              if (y = 0, t) op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) _.ops.pop();
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      }
+  };
+  var __asyncValues = (null && null.__asyncValues) || function (o) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var m = o[Symbol.asyncIterator], i;
+      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+  };
+  var __await$1 = (null && null.__await) || function (v) { return this instanceof __await$1 ? (this.v = v, this) : new __await$1(v); };
+  var __asyncGenerator$1 = (null && null.__asyncGenerator) || function (thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+      function step(r) { r.value instanceof __await$1 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+      function fulfill(value) { resume("next", value); }
+      function reject(value) { resume("throw", value); }
+      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+  };
+  var isValidMapKeyType = function (key) {
+      var keyType = typeof key;
+      return keyType === "string" || keyType === "number";
+  };
+  var HEAD_BYTE_REQUIRED = -1;
+  var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+  var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+  // IE11: Hack to support IE11.
+  // IE11: Drop this hack and just use RangeError when IE11 is obsolete.
+  var DataViewIndexOutOfBoundsError = (function () {
+      try {
+          // IE11: The spec says it should throw RangeError,
+          // IE11: but in IE11 it throws TypeError.
+          EMPTY_VIEW.getInt8(0);
+      }
+      catch (e) {
+          return e.constructor;
+      }
+      throw new Error("never reached");
+  })();
+  var MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
+  var sharedCachedKeyDecoder = new CachedKeyDecoder();
+  var Decoder = /** @class */ (function () {
+      function Decoder(extensionCodec, context, maxStrLength, maxBinLength, maxArrayLength, maxMapLength, maxExtLength, keyDecoder) {
+          if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }
+          if (context === void 0) { context = undefined; }
+          if (maxStrLength === void 0) { maxStrLength = UINT32_MAX; }
+          if (maxBinLength === void 0) { maxBinLength = UINT32_MAX; }
+          if (maxArrayLength === void 0) { maxArrayLength = UINT32_MAX; }
+          if (maxMapLength === void 0) { maxMapLength = UINT32_MAX; }
+          if (maxExtLength === void 0) { maxExtLength = UINT32_MAX; }
+          if (keyDecoder === void 0) { keyDecoder = sharedCachedKeyDecoder; }
+          this.extensionCodec = extensionCodec;
+          this.context = context;
+          this.maxStrLength = maxStrLength;
+          this.maxBinLength = maxBinLength;
+          this.maxArrayLength = maxArrayLength;
+          this.maxMapLength = maxMapLength;
+          this.maxExtLength = maxExtLength;
+          this.keyDecoder = keyDecoder;
+          this.totalPos = 0;
+          this.pos = 0;
+          this.view = EMPTY_VIEW;
+          this.bytes = EMPTY_BYTES;
+          this.headByte = HEAD_BYTE_REQUIRED;
+          this.stack = [];
+      }
+      Decoder.prototype.reinitializeState = function () {
+          this.totalPos = 0;
+          this.headByte = HEAD_BYTE_REQUIRED;
+          this.stack.length = 0;
+          // view, bytes, and pos will be re-initialized in setBuffer()
+      };
+      Decoder.prototype.setBuffer = function (buffer) {
+          this.bytes = ensureUint8Array(buffer);
+          this.view = createDataView(this.bytes);
+          this.pos = 0;
+      };
+      Decoder.prototype.appendBuffer = function (buffer) {
+          if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+              this.setBuffer(buffer);
+          }
+          else {
+              var remainingData = this.bytes.subarray(this.pos);
+              var newData = ensureUint8Array(buffer);
+              // concat remainingData + newData
+              var newBuffer = new Uint8Array(remainingData.length + newData.length);
+              newBuffer.set(remainingData);
+              newBuffer.set(newData, remainingData.length);
+              this.setBuffer(newBuffer);
+          }
+      };
+      Decoder.prototype.hasRemaining = function (size) {
+          return this.view.byteLength - this.pos >= size;
+      };
+      Decoder.prototype.createExtraByteError = function (posToShow) {
+          var _a = this, view = _a.view, pos = _a.pos;
+          return new RangeError("Extra ".concat(view.byteLength - pos, " of ").concat(view.byteLength, " byte(s) found at buffer[").concat(posToShow, "]"));
+      };
+      /**
+       * @throws {@link DecodeError}
+       * @throws {@link RangeError}
+       */
+      Decoder.prototype.decode = function (buffer) {
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          var object = this.doDecodeSync();
+          if (this.hasRemaining(1)) {
+              throw this.createExtraByteError(this.pos);
+          }
+          return object;
+      };
+      Decoder.prototype.decodeMulti = function (buffer) {
+          return __generator$2(this, function (_a) {
+              switch (_a.label) {
+                  case 0:
+                      this.reinitializeState();
+                      this.setBuffer(buffer);
+                      _a.label = 1;
+                  case 1:
+                      if (!this.hasRemaining(1)) return [3 /*break*/, 3];
+                      return [4 /*yield*/, this.doDecodeSync()];
+                  case 2:
+                      _a.sent();
+                      return [3 /*break*/, 1];
+                  case 3: return [2 /*return*/];
+              }
+          });
+      };
+      Decoder.prototype.decodeAsync = function (stream) {
+          var stream_1, stream_1_1;
+          var e_1, _a;
+          return __awaiter$1(this, void 0, void 0, function () {
+              var decoded, object, buffer, e_1_1, _b, headByte, pos, totalPos;
+              return __generator$2(this, function (_c) {
+                  switch (_c.label) {
+                      case 0:
+                          decoded = false;
+                          _c.label = 1;
+                      case 1:
+                          _c.trys.push([1, 6, 7, 12]);
+                          stream_1 = __asyncValues(stream);
+                          _c.label = 2;
+                      case 2: return [4 /*yield*/, stream_1.next()];
+                      case 3:
+                          if (!(stream_1_1 = _c.sent(), !stream_1_1.done)) return [3 /*break*/, 5];
+                          buffer = stream_1_1.value;
+                          if (decoded) {
+                              throw this.createExtraByteError(this.totalPos);
+                          }
+                          this.appendBuffer(buffer);
+                          try {
+                              object = this.doDecodeSync();
+                              decoded = true;
+                          }
+                          catch (e) {
+                              if (!(e instanceof DataViewIndexOutOfBoundsError)) {
+                                  throw e; // rethrow
+                              }
+                              // fallthrough
+                          }
+                          this.totalPos += this.pos;
+                          _c.label = 4;
+                      case 4: return [3 /*break*/, 2];
+                      case 5: return [3 /*break*/, 12];
+                      case 6:
+                          e_1_1 = _c.sent();
+                          e_1 = { error: e_1_1 };
+                          return [3 /*break*/, 12];
+                      case 7:
+                          _c.trys.push([7, , 10, 11]);
+                          if (!(stream_1_1 && !stream_1_1.done && (_a = stream_1.return))) return [3 /*break*/, 9];
+                          return [4 /*yield*/, _a.call(stream_1)];
+                      case 8:
+                          _c.sent();
+                          _c.label = 9;
+                      case 9: return [3 /*break*/, 11];
+                      case 10:
+                          if (e_1) throw e_1.error;
+                          return [7 /*endfinally*/];
+                      case 11: return [7 /*endfinally*/];
+                      case 12:
+                          if (decoded) {
+                              if (this.hasRemaining(1)) {
+                                  throw this.createExtraByteError(this.totalPos);
+                              }
+                              return [2 /*return*/, object];
+                          }
+                          _b = this, headByte = _b.headByte, pos = _b.pos, totalPos = _b.totalPos;
+                          throw new RangeError("Insufficient data in parsing ".concat(prettyByte(headByte), " at ").concat(totalPos, " (").concat(pos, " in the current buffer)"));
+                  }
+              });
+          });
+      };
+      Decoder.prototype.decodeArrayStream = function (stream) {
+          return this.decodeMultiAsync(stream, true);
+      };
+      Decoder.prototype.decodeStream = function (stream) {
+          return this.decodeMultiAsync(stream, false);
+      };
+      Decoder.prototype.decodeMultiAsync = function (stream, isArray) {
+          return __asyncGenerator$1(this, arguments, function decodeMultiAsync_1() {
+              var isArrayHeaderRequired, arrayItemsLeft, stream_2, stream_2_1, buffer, e_2, e_3_1;
+              var e_3, _a;
+              return __generator$2(this, function (_b) {
+                  switch (_b.label) {
+                      case 0:
+                          isArrayHeaderRequired = isArray;
+                          arrayItemsLeft = -1;
+                          _b.label = 1;
+                      case 1:
+                          _b.trys.push([1, 13, 14, 19]);
+                          stream_2 = __asyncValues(stream);
+                          _b.label = 2;
+                      case 2: return [4 /*yield*/, __await$1(stream_2.next())];
+                      case 3:
+                          if (!(stream_2_1 = _b.sent(), !stream_2_1.done)) return [3 /*break*/, 12];
+                          buffer = stream_2_1.value;
+                          if (isArray && arrayItemsLeft === 0) {
+                              throw this.createExtraByteError(this.totalPos);
+                          }
+                          this.appendBuffer(buffer);
+                          if (isArrayHeaderRequired) {
+                              arrayItemsLeft = this.readArraySize();
+                              isArrayHeaderRequired = false;
+                              this.complete();
+                          }
+                          _b.label = 4;
+                      case 4:
+                          _b.trys.push([4, 9, , 10]);
+                          _b.label = 5;
+                      case 5:
+                          if (!true) return [3 /*break*/, 8];
+                          return [4 /*yield*/, __await$1(this.doDecodeSync())];
+                      case 6: return [4 /*yield*/, _b.sent()];
+                      case 7:
+                          _b.sent();
+                          if (--arrayItemsLeft === 0) {
+                              return [3 /*break*/, 8];
+                          }
+                          return [3 /*break*/, 5];
+                      case 8: return [3 /*break*/, 10];
+                      case 9:
+                          e_2 = _b.sent();
+                          if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
+                              throw e_2; // rethrow
+                          }
+                          return [3 /*break*/, 10];
+                      case 10:
+                          this.totalPos += this.pos;
+                          _b.label = 11;
+                      case 11: return [3 /*break*/, 2];
+                      case 12: return [3 /*break*/, 19];
+                      case 13:
+                          e_3_1 = _b.sent();
+                          e_3 = { error: e_3_1 };
+                          return [3 /*break*/, 19];
+                      case 14:
+                          _b.trys.push([14, , 17, 18]);
+                          if (!(stream_2_1 && !stream_2_1.done && (_a = stream_2.return))) return [3 /*break*/, 16];
+                          return [4 /*yield*/, __await$1(_a.call(stream_2))];
+                      case 15:
+                          _b.sent();
+                          _b.label = 16;
+                      case 16: return [3 /*break*/, 18];
+                      case 17:
+                          if (e_3) throw e_3.error;
+                          return [7 /*endfinally*/];
+                      case 18: return [7 /*endfinally*/];
+                      case 19: return [2 /*return*/];
+                  }
+              });
+          });
+      };
+      Decoder.prototype.doDecodeSync = function () {
+          DECODE: while (true) {
+              var headByte = this.readHeadByte();
+              var object = void 0;
+              if (headByte >= 0xe0) {
+                  // negative fixint (111x xxxx) 0xe0 - 0xff
+                  object = headByte - 0x100;
+              }
+              else if (headByte < 0xc0) {
+                  if (headByte < 0x80) {
+                      // positive fixint (0xxx xxxx) 0x00 - 0x7f
+                      object = headByte;
+                  }
+                  else if (headByte < 0x90) {
+                      // fixmap (1000 xxxx) 0x80 - 0x8f
+                      var size = headByte - 0x80;
+                      if (size !== 0) {
+                          this.pushMapState(size);
+                          this.complete();
+                          continue DECODE;
+                      }
+                      else {
+                          object = {};
+                      }
+                  }
+                  else if (headByte < 0xa0) {
+                      // fixarray (1001 xxxx) 0x90 - 0x9f
+                      var size = headByte - 0x90;
+                      if (size !== 0) {
+                          this.pushArrayState(size);
+                          this.complete();
+                          continue DECODE;
+                      }
+                      else {
+                          object = [];
+                      }
+                  }
+                  else {
+                      // fixstr (101x xxxx) 0xa0 - 0xbf
+                      var byteLength = headByte - 0xa0;
+                      object = this.decodeUtf8String(byteLength, 0);
+                  }
+              }
+              else if (headByte === 0xc0) {
+                  // nil
+                  object = null;
+              }
+              else if (headByte === 0xc2) {
+                  // false
+                  object = false;
+              }
+              else if (headByte === 0xc3) {
+                  // true
+                  object = true;
+              }
+              else if (headByte === 0xca) {
+                  // float 32
+                  object = this.readF32();
+              }
+              else if (headByte === 0xcb) {
+                  // float 64
+                  object = this.readF64();
+              }
+              else if (headByte === 0xcc) {
+                  // uint 8
+                  object = this.readU8();
+              }
+              else if (headByte === 0xcd) {
+                  // uint 16
+                  object = this.readU16();
+              }
+              else if (headByte === 0xce) {
+                  // uint 32
+                  object = this.readU32();
+              }
+              else if (headByte === 0xcf) {
+                  // uint 64
+                  object = this.readU64();
+              }
+              else if (headByte === 0xd0) {
+                  // int 8
+                  object = this.readI8();
+              }
+              else if (headByte === 0xd1) {
+                  // int 16
+                  object = this.readI16();
+              }
+              else if (headByte === 0xd2) {
+                  // int 32
+                  object = this.readI32();
+              }
+              else if (headByte === 0xd3) {
+                  // int 64
+                  object = this.readI64();
+              }
+              else if (headByte === 0xd9) {
+                  // str 8
+                  var byteLength = this.lookU8();
+                  object = this.decodeUtf8String(byteLength, 1);
+              }
+              else if (headByte === 0xda) {
+                  // str 16
+                  var byteLength = this.lookU16();
+                  object = this.decodeUtf8String(byteLength, 2);
+              }
+              else if (headByte === 0xdb) {
+                  // str 32
+                  var byteLength = this.lookU32();
+                  object = this.decodeUtf8String(byteLength, 4);
+              }
+              else if (headByte === 0xdc) {
+                  // array 16
+                  var size = this.readU16();
+                  if (size !== 0) {
+                      this.pushArrayState(size);
+                      this.complete();
+                      continue DECODE;
+                  }
+                  else {
+                      object = [];
+                  }
+              }
+              else if (headByte === 0xdd) {
+                  // array 32
+                  var size = this.readU32();
+                  if (size !== 0) {
+                      this.pushArrayState(size);
+                      this.complete();
+                      continue DECODE;
+                  }
+                  else {
+                      object = [];
+                  }
+              }
+              else if (headByte === 0xde) {
+                  // map 16
+                  var size = this.readU16();
+                  if (size !== 0) {
+                      this.pushMapState(size);
+                      this.complete();
+                      continue DECODE;
+                  }
+                  else {
+                      object = {};
+                  }
+              }
+              else if (headByte === 0xdf) {
+                  // map 32
+                  var size = this.readU32();
+                  if (size !== 0) {
+                      this.pushMapState(size);
+                      this.complete();
+                      continue DECODE;
+                  }
+                  else {
+                      object = {};
+                  }
+              }
+              else if (headByte === 0xc4) {
+                  // bin 8
+                  var size = this.lookU8();
+                  object = this.decodeBinary(size, 1);
+              }
+              else if (headByte === 0xc5) {
+                  // bin 16
+                  var size = this.lookU16();
+                  object = this.decodeBinary(size, 2);
+              }
+              else if (headByte === 0xc6) {
+                  // bin 32
+                  var size = this.lookU32();
+                  object = this.decodeBinary(size, 4);
+              }
+              else if (headByte === 0xd4) {
+                  // fixext 1
+                  object = this.decodeExtension(1, 0);
+              }
+              else if (headByte === 0xd5) {
+                  // fixext 2
+                  object = this.decodeExtension(2, 0);
+              }
+              else if (headByte === 0xd6) {
+                  // fixext 4
+                  object = this.decodeExtension(4, 0);
+              }
+              else if (headByte === 0xd7) {
+                  // fixext 8
+                  object = this.decodeExtension(8, 0);
+              }
+              else if (headByte === 0xd8) {
+                  // fixext 16
+                  object = this.decodeExtension(16, 0);
+              }
+              else if (headByte === 0xc7) {
+                  // ext 8
+                  var size = this.lookU8();
+                  object = this.decodeExtension(size, 1);
+              }
+              else if (headByte === 0xc8) {
+                  // ext 16
+                  var size = this.lookU16();
+                  object = this.decodeExtension(size, 2);
+              }
+              else if (headByte === 0xc9) {
+                  // ext 32
+                  var size = this.lookU32();
+                  object = this.decodeExtension(size, 4);
+              }
+              else {
+                  throw new DecodeError("Unrecognized type byte: ".concat(prettyByte(headByte)));
+              }
+              this.complete();
+              var stack = this.stack;
+              while (stack.length > 0) {
+                  // arrays and maps
+                  var state = stack[stack.length - 1];
+                  if (state.type === 0 /* State.ARRAY */) {
+                      state.array[state.position] = object;
+                      state.position++;
+                      if (state.position === state.size) {
+                          stack.pop();
+                          object = state.array;
+                      }
+                      else {
+                          continue DECODE;
+                      }
+                  }
+                  else if (state.type === 1 /* State.MAP_KEY */) {
+                      if (!isValidMapKeyType(object)) {
+                          throw new DecodeError("The type of key must be string or number but " + typeof object);
+                      }
+                      if (object === "__proto__") {
+                          throw new DecodeError("The key __proto__ is not allowed");
+                      }
+                      state.key = object;
+                      state.type = 2 /* State.MAP_VALUE */;
+                      continue DECODE;
+                  }
+                  else {
+                      // it must be `state.type === State.MAP_VALUE` here
+                      state.map[state.key] = object;
+                      state.readCount++;
+                      if (state.readCount === state.size) {
+                          stack.pop();
+                          object = state.map;
+                      }
+                      else {
+                          state.key = null;
+                          state.type = 1 /* State.MAP_KEY */;
+                          continue DECODE;
+                      }
+                  }
+              }
+              return object;
+          }
+      };
+      Decoder.prototype.readHeadByte = function () {
+          if (this.headByte === HEAD_BYTE_REQUIRED) {
+              this.headByte = this.readU8();
+              // console.log("headByte", prettyByte(this.headByte));
+          }
+          return this.headByte;
+      };
+      Decoder.prototype.complete = function () {
+          this.headByte = HEAD_BYTE_REQUIRED;
+      };
+      Decoder.prototype.readArraySize = function () {
+          var headByte = this.readHeadByte();
+          switch (headByte) {
+              case 0xdc:
+                  return this.readU16();
+              case 0xdd:
+                  return this.readU32();
+              default: {
+                  if (headByte < 0xa0) {
+                      return headByte - 0x90;
+                  }
+                  else {
+                      throw new DecodeError("Unrecognized array type byte: ".concat(prettyByte(headByte)));
+                  }
+              }
+          }
+      };
+      Decoder.prototype.pushMapState = function (size) {
+          if (size > this.maxMapLength) {
+              throw new DecodeError("Max length exceeded: map length (".concat(size, ") > maxMapLengthLength (").concat(this.maxMapLength, ")"));
+          }
+          this.stack.push({
+              type: 1 /* State.MAP_KEY */,
+              size: size,
+              key: null,
+              readCount: 0,
+              map: {},
+          });
+      };
+      Decoder.prototype.pushArrayState = function (size) {
+          if (size > this.maxArrayLength) {
+              throw new DecodeError("Max length exceeded: array length (".concat(size, ") > maxArrayLength (").concat(this.maxArrayLength, ")"));
+          }
+          this.stack.push({
+              type: 0 /* State.ARRAY */,
+              size: size,
+              array: new Array(size),
+              position: 0,
+          });
+      };
+      Decoder.prototype.decodeUtf8String = function (byteLength, headerOffset) {
+          var _a;
+          if (byteLength > this.maxStrLength) {
+              throw new DecodeError("Max length exceeded: UTF-8 byte length (".concat(byteLength, ") > maxStrLength (").concat(this.maxStrLength, ")"));
+          }
+          if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+              throw MORE_DATA;
+          }
+          var offset = this.pos + headerOffset;
+          var object;
+          if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) {
+              object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+          }
+          else if (byteLength > TEXT_DECODER_THRESHOLD) {
+              object = utf8DecodeTD(this.bytes, offset, byteLength);
+          }
+          else {
+              object = utf8DecodeJs(this.bytes, offset, byteLength);
+          }
+          this.pos += headerOffset + byteLength;
+          return object;
+      };
+      Decoder.prototype.stateIsMapKey = function () {
+          if (this.stack.length > 0) {
+              var state = this.stack[this.stack.length - 1];
+              return state.type === 1 /* State.MAP_KEY */;
+          }
+          return false;
+      };
+      Decoder.prototype.decodeBinary = function (byteLength, headOffset) {
+          if (byteLength > this.maxBinLength) {
+              throw new DecodeError("Max length exceeded: bin length (".concat(byteLength, ") > maxBinLength (").concat(this.maxBinLength, ")"));
+          }
+          if (!this.hasRemaining(byteLength + headOffset)) {
+              throw MORE_DATA;
+          }
+          var offset = this.pos + headOffset;
+          var object = this.bytes.subarray(offset, offset + byteLength);
+          this.pos += headOffset + byteLength;
+          return object;
+      };
+      Decoder.prototype.decodeExtension = function (size, headOffset) {
+          if (size > this.maxExtLength) {
+              throw new DecodeError("Max length exceeded: ext length (".concat(size, ") > maxExtLength (").concat(this.maxExtLength, ")"));
+          }
+          var extType = this.view.getInt8(this.pos + headOffset);
+          var data = this.decodeBinary(size, headOffset + 1 /* extType */);
+          return this.extensionCodec.decode(data, extType, this.context);
+      };
+      Decoder.prototype.lookU8 = function () {
+          return this.view.getUint8(this.pos);
+      };
+      Decoder.prototype.lookU16 = function () {
+          return this.view.getUint16(this.pos);
+      };
+      Decoder.prototype.lookU32 = function () {
+          return this.view.getUint32(this.pos);
+      };
+      Decoder.prototype.readU8 = function () {
+          var value = this.view.getUint8(this.pos);
+          this.pos++;
+          return value;
+      };
+      Decoder.prototype.readI8 = function () {
+          var value = this.view.getInt8(this.pos);
+          this.pos++;
+          return value;
+      };
+      Decoder.prototype.readU16 = function () {
+          var value = this.view.getUint16(this.pos);
+          this.pos += 2;
+          return value;
+      };
+      Decoder.prototype.readI16 = function () {
+          var value = this.view.getInt16(this.pos);
+          this.pos += 2;
+          return value;
+      };
+      Decoder.prototype.readU32 = function () {
+          var value = this.view.getUint32(this.pos);
+          this.pos += 4;
+          return value;
+      };
+      Decoder.prototype.readI32 = function () {
+          var value = this.view.getInt32(this.pos);
+          this.pos += 4;
+          return value;
+      };
+      Decoder.prototype.readU64 = function () {
+          var value = getUint64(this.view, this.pos);
+          this.pos += 8;
+          return value;
+      };
+      Decoder.prototype.readI64 = function () {
+          var value = getInt64(this.view, this.pos);
+          this.pos += 8;
+          return value;
+      };
+      Decoder.prototype.readF32 = function () {
+          var value = this.view.getFloat32(this.pos);
+          this.pos += 4;
+          return value;
+      };
+      Decoder.prototype.readF64 = function () {
+          var value = this.view.getFloat64(this.pos);
+          this.pos += 8;
+          return value;
+      };
+      return Decoder;
+  }());
+
+  var defaultDecodeOptions = {};
+  /**
+   * It decodes a single MessagePack object in a buffer.
+   *
+   * This is a synchronous decoding function.
+   * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.
+   *
+   * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+   * @throws {@link DecodeError} if the buffer contains invalid data.
+   */
+  function decode(buffer, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      var decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+      return decoder.decode(buffer);
+  }
+  /**
+   * It decodes multiple MessagePack objects in a buffer.
+   * This is corresponding to {@link decodeMultiStream()}.
+   *
+   * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+   * @throws {@link DecodeError} if the buffer contains invalid data.
+   */
+  function decodeMulti(buffer, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      var decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+      return decoder.decodeMulti(buffer);
+  }
+
+  // utility for whatwg streams
+  var __generator$1 = (null && null.__generator) || function (thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (_) try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+              if (y = 0, t) op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) _.ops.pop();
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      }
+  };
+  var __await = (null && null.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); };
+  var __asyncGenerator = (null && null.__asyncGenerator) || function (thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+      function fulfill(value) { resume("next", value); }
+      function reject(value) { resume("throw", value); }
+      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+  };
+  function isAsyncIterable(object) {
+      return object[Symbol.asyncIterator] != null;
+  }
+  function assertNonNull(value) {
+      if (value == null) {
+          throw new Error("Assertion Failure: value must not be null nor undefined");
+      }
+  }
+  function asyncIterableFromStream(stream) {
+      return __asyncGenerator(this, arguments, function asyncIterableFromStream_1() {
+          var reader, _a, done, value;
+          return __generator$1(this, function (_b) {
+              switch (_b.label) {
+                  case 0:
+                      reader = stream.getReader();
+                      _b.label = 1;
+                  case 1:
+                      _b.trys.push([1, , 9, 10]);
+                      _b.label = 2;
+                  case 2:
+                      if (!true) return [3 /*break*/, 8];
+                      return [4 /*yield*/, __await(reader.read())];
+                  case 3:
+                      _a = _b.sent(), done = _a.done, value = _a.value;
+                      if (!done) return [3 /*break*/, 5];
+                      return [4 /*yield*/, __await(void 0)];
+                  case 4: return [2 /*return*/, _b.sent()];
+                  case 5:
+                      assertNonNull(value);
+                      return [4 /*yield*/, __await(value)];
+                  case 6: return [4 /*yield*/, _b.sent()];
+                  case 7:
+                      _b.sent();
+                      return [3 /*break*/, 2];
+                  case 8: return [3 /*break*/, 10];
+                  case 9:
+                      reader.releaseLock();
+                      return [7 /*endfinally*/];
+                  case 10: return [2 /*return*/];
+              }
+          });
+      });
+  }
+  function ensureAsyncIterable(streamLike) {
+      if (isAsyncIterable(streamLike)) {
+          return streamLike;
+      }
+      else {
+          return asyncIterableFromStream(streamLike);
+      }
+  }
+
+  var __awaiter = (null && null.__awaiter) || function (thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  };
+  var __generator = (null && null.__generator) || function (thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (_) try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+              if (y = 0, t) op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) _.ops.pop();
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      }
+  };
+  /**
+   * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+   * @throws {@link DecodeError} if the buffer contains invalid data.
+   */
+  function decodeAsync(streamLike, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      return __awaiter(this, void 0, void 0, function () {
+          var stream, decoder;
+          return __generator(this, function (_a) {
+              stream = ensureAsyncIterable(streamLike);
+              decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+              return [2 /*return*/, decoder.decodeAsync(stream)];
+          });
+      });
+  }
+  /**
+   * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+   * @throws {@link DecodeError} if the buffer contains invalid data.
+   */
+  function decodeArrayStream(streamLike, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      var stream = ensureAsyncIterable(streamLike);
+      var decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+      return decoder.decodeArrayStream(stream);
+  }
+  /**
+   * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+   * @throws {@link DecodeError} if the buffer contains invalid data.
+   */
+  function decodeMultiStream(streamLike, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      var stream = ensureAsyncIterable(streamLike);
+      var decoder = new Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+      return decoder.decodeStream(stream);
+  }
+  /**
+   * @deprecated Use {@link decodeMultiStream()} instead.
+   */
+  function decodeStream(streamLike, options) {
+      if (options === void 0) { options = defaultDecodeOptions; }
+      return decodeMultiStream(streamLike, options);
+  }
+
+  // Main Functions:
+
+  var PACKAGE_EXT = 'msx';
+
+  function packDatasets(datasets, opts) {
+    var obj = exportDatasets$1(datasets);
+    // encode options: see https://github.com/msgpack/msgpack-javascript
+    // initialBufferSize  number  2048
+    // ignoreUndefined boolean false
+    var content = encode(obj, {});
+    return [{
+      content: content,
+      filename: opts.file || 'output.' + PACKAGE_EXT
+    }];
+  }
+
+  // gui: (optional) gui instance
+  //
+  function exportDatasets$1(datasets) {
+    // TODO: add targets
+    // TODO: add gui state
+    return {
+      version: 1,
+      datasets: datasets.map(exportDataset)
+    };
+  }
+
+  // TODO..
+  // export function serializeSession(catalog) {
+  //   var obj = exportDatasets(catalog.getDatasets());
+  //   return BSON.serialize(obj);
+  // }
+
+  function exportDataset(dataset) {
+    return Object.assign(dataset, {
+      arcs: dataset.arcs ? exportArcs(dataset.arcs) : null,
+      info: dataset.info ? exportInfo(dataset.info) : null,
+      layers: (dataset.layers || []).map(exportLayer)
+    });
+  }
+
+  function typedArrayToBuffer(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+  }
+
+  function exportArcs(arcs) {
+    var data = arcs.getVertexData();
+    var obj = {
+      nn: typedArrayToBuffer(data.nn),
+      xx: typedArrayToBuffer(data.xx),
+      yy: typedArrayToBuffer(data.yy)
+    };
+    return obj;
+  }
+
+  function exportLayer(lyr) {
+    return {
+      name: lyr.name || null,
+      geometry_type: lyr.geometry_type || null,
+      shapes: lyr.shapes || null,
+      data: lyr.data ? lyr.data.getRecords() : null,
+      menu_order: lyr.menu_order || null,
+      pinned: lyr.pinned || false
+    };
+  }
+
+  function exportInfo(info) {
+    // TODO: export CRS
+    return info;
+  }
+
   // Guess the type of a data file from file extension, or return null if not sure
   function guessInputFileType(file) {
     var ext = getFileExtension(file || '').toLowerCase(),
@@ -7164,8 +9065,8 @@
       type = 'json';
     } else if (ext == 'csv' || ext == 'tsv' || ext == 'txt' || ext == 'tab') {
       type = 'text';
-    } else if (ext == 'mshp') {
-      type = 'mshp';
+    } else if (ext == PACKAGE_EXT) {
+      type = PACKAGE_EXT;
     }
     return type;
   }
@@ -7212,8 +9113,8 @@
     return !!type && type != 'gz' && type != 'zip';
   }
 
-  function isMshpFile(file) {
-    return /\.mshp$/.test(file);
+  function isPackageFile(file) {
+    return file.endsWith('.' + PACKAGE_EXT);
   }
 
   function isZipFile(file) {
@@ -7242,7 +9143,7 @@
       dbf: 'DBF',
       kml: 'KML',
       kmz: 'KMZ',
-      mshp: 'Mapshaper project',
+      [PACKAGE_EXT]: 'Mapshaper project',
       shapefile: 'Shapefile',
       svg: 'SVG'
     }[fmt] || '';
@@ -7251,13 +9152,13 @@
   // Assumes file at @path is one of Mapshaper's supported file types
   function isSupportedBinaryInputType(path) {
     var ext = getFileExtension(path).toLowerCase();
-    return ext == 'shp' || ext == 'shx' || ext == 'dbf' || ext == 'mshp'; // GUI also supports zip files
+    return ext == 'shp' || ext == 'shx' || ext == 'dbf' || ext == PACKAGE_EXT; // GUI also supports zip files
   }
 
   function isImportableAsBinary(path) {
     var type = guessInputFileType(path);
     return isSupportedBinaryInputType(path) || isZipFile(path) ||
-      isGzipFile(path) || isKmzFile(path) || isMshpFile(path) ||
+      isGzipFile(path) || isKmzFile(path) || isPackageFile(path) ||
       type == 'json' || type == 'text';
   }
 
@@ -7277,7 +9178,7 @@
     couldBeDsvFile: couldBeDsvFile,
     looksLikeImportableFile: looksLikeImportableFile,
     looksLikeContentFile: looksLikeContentFile,
-    isMshpFile: isMshpFile,
+    isPackageFile: isPackageFile,
     isZipFile: isZipFile,
     isKmzFile: isKmzFile,
     isGzipFile: isGzipFile,
@@ -9836,8 +11737,10 @@
     if (buf instanceof ArrayBuffer) {
       buf = new Uint8Array(buf);
     }
-    var obj = unzip(buf, {filter: fflateFilter}, cb);
-    return fflatePostprocess(obj);
+    unzip(buf, {filter: fflateFilter}, function(err, data) {
+      if (err) cb(err);
+      cb(null, fflatePostprocess(data));
+    });
   }
 
   function zipSync(files) {
@@ -19163,69 +21066,6 @@ ${svg}
     }];
   }
 
-  function exportBSON(datasets, opts) {
-    var { serialize } = require('bson');
-    var obj = exportDatasets$1(datasets);
-    var content = serialize(obj);
-    return [{
-      content: content,
-      filename: opts.file || 'output.mshp'
-    }];
-  }
-
-  // gui: (optional) gui instance
-  //
-  function exportDatasets$1(datasets) {
-    // TODO: add targets
-    // TODO: add gui state
-    return {
-      version: 1,
-      datasets: datasets.map(exportDataset)
-    };
-  }
-
-  // TODO..
-  // export function serializeSession(catalog) {
-  //   var obj = exportDatasets(catalog.getDatasets());
-  //   return BSON.serialize(obj);
-  // }
-
-  function exportDataset(dataset) {
-    return Object.assign(dataset, {
-      arcs: dataset.arcs ? exportArcs(dataset.arcs) : null,
-      info: dataset.info ? exportInfo(dataset.info) : null,
-      layers: (dataset.layers || []).map(exportLayer)
-    });
-  }
-
-  function typedArrayToBuffer(arr) {
-    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-  }
-
-  function exportArcs(arcs) {
-    var data = arcs.getVertexData();
-    var obj = {
-      nn: typedArrayToBuffer(data.nn),
-      xx: typedArrayToBuffer(data.xx),
-      yy: typedArrayToBuffer(data.yy)
-    };
-    return obj;
-  }
-
-  function exportLayer(lyr) {
-    return {
-      name: lyr.name || null,
-      geometry_type: lyr.geometry_type || null,
-      shapes: lyr.shapes || null,
-      data: lyr.data ? lyr.data.getRecords() : null
-    };
-  }
-
-  function exportInfo(info) {
-    // TODO: export CRS
-    return info;
-  }
-
   function exportRecordsAsFixedWidthString(fields, records, opts) {
     var rows = [], col;
     for (var i=0; i<fields.length; i++) {
@@ -20288,8 +22128,8 @@ ${svg}
   function exportDatasets(datasets, opts) {
     var format = getOutputFormat(datasets[0], opts);
     var files;
-    if (format == 'mshp') {
-      return exportBSON(datasets, opts);
+    if (format == PACKAGE_EXT) {
+      return packDatasets(datasets, opts);
     }
     if (format == 'kml' || format == 'svg' || format == 'topojson' || format == 'geojson' && opts.combine_layers) {
       // multi-layer formats: combine multiple datasets into one
@@ -20312,7 +22152,7 @@ ${svg}
     }
     files = datasets.reduce(function(memo, dataset) {
       if (runningInBrowser()) {
-        utils.sortOn(dataset.layers, 'stack_id', true);
+        utils.sortOn(dataset.layers, 'menu_order', true);
       } else {
         // kludge to export layers in order that target= option or previous
         // -target command matched them (useful mainly for SVG output)
@@ -20392,7 +22232,7 @@ ${svg}
   }
 
   var exporters = {
-    bson: exportBSON,
+    bson: packDatasets,
     geojson: exportGeoJSON2,
     topojson: exportTopoJSON,
     shapefile: exportShapefile,
@@ -21715,10 +23555,12 @@ ${svg}
         }
 
         if (!optDef) {
+          // REMOVING quote trimming -- it prevents the use of quoted commands in -run (for example)
           // token is not a defined option; add it to _ array for later processing
           // Stripping surrounding quotes here, although this may not be necessary since
           // (some, most, all?) shells seem to remove quotes.
-          cmd._.push(utils.trimQuotes(token));
+          // cmd._.push(utils.trimQuotes(token));
+          cmd._.push(token);
           return;
         }
 
@@ -25366,9 +27208,9 @@ ${svg}
       stop("Unsupported Shapefile type:", shpType);
     }
     if (ShpType.isZType(shpType)) {
-      message("Warning: Shapefile Z data will be lost.");
+      verbose("Warning: Shapefile Z data will be lost.");
     } else if (ShpType.isMType(shpType)) {
-      message("Warning: Shapefile M data will be lost.");
+      verbose("Warning: Shapefile M data will be lost.");
     }
 
     // TODO: test cases: null shape; non-null shape with no valid parts
@@ -26568,6 +28410,9 @@ ${svg}
     if (obj.cpg) {
       // TODO: consider using the input encoding as the default output encoding
       dataset.info.cpg = obj.cpg.content;
+      if (typeof dataset.info.cpg != 'string') {
+        error('Invalid encoding argument, expected a string');
+      }
     }
     return dataset;
   }
@@ -26603,12 +28448,8 @@ ${svg}
   // Import datasets contained in a BSON blob
   // Return command target as a dataset
   //
-  function importBSON(buf) {
-    var { deserialize } = require('bson');
-    var obj = deserialize(buf, {
-      promoteBuffers: true,
-      promoteValues: true
-    });
+  function unpackSession(buf) {
+    var obj = decode(buf, {});
     if (!isValidSession(obj)) {
       stop('Invalid mapshaper session data object');
     }
@@ -26681,10 +28522,10 @@ ${svg}
       stop('Missing importable files');
     }
 
-    // special case: .mshp file
-    if (files.some(isMshpFile)) {
+    // special case: package file
+    if (files.some(isPackageFile)) {
       if (files.length > 1) {
-        stop('Expected a single mshp file');
+        stop('Expected a single package file');
       }
       dataset = importMshpFile(files[0], catalog, opts);
       return dataset;
@@ -26707,7 +28548,7 @@ ${svg}
 
   function importMshpFile(file, catalog, opts) {
     var buf = cli.readFile(file, null, opts.input);
-    var obj = importBSON(buf);
+    var obj = unpackSession(buf);
     obj.datasets.forEach(function(dataset) {
       catalog.addDataset(dataset);
     });
@@ -42437,7 +44278,7 @@ ${svg}
     var ctx = getBaseContext();
     var output, targetData;
     // TODO: throw an informative error if target is used when there are multiple targets
-    if (targets.length == 1) {
+    if (targets && targets.length == 1) {
       targetData = getRunCommandData(targets[0]);
       Object.defineProperty(ctx, 'target', {value: targetData});
     }
@@ -44635,6 +46476,7 @@ ${svg}
   function commandAcceptsEmptyTarget(name) {
     return name == 'graticule' || name == 'i' || name == 'help' ||
       name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
+      name == 'require' || name == 'run' || name == 'define' ||
       name == 'include' || name == 'print' || name == 'comment' || name == 'if' || name == 'elif' ||
       name == 'else' || name == 'endif' || name == 'stop';
   }