@slicemachine/manager 0.1.1-dev-plugins.4 → 0.1.1-dev-plugins.5

package/dist/__node_modules/@msgpack/msgpack/dist.es5_esm/Decoder.js

@@ -0,0 +1,801 @@
+import { prettyByte } from "./utils/prettyByte.js";
+import { ExtensionCodec } from "./ExtensionCodec.js";
+import { getUint64, getInt64, UINT32_MAX } from "./utils/int.js";
+import { TEXT_DECODER_THRESHOLD, utf8DecodeTD, utf8DecodeJs } from "./utils/utf8.js";
+import { ensureUint8Array, createDataView } from "./utils/typedArrays.js";
+import { CachedKeyDecoder } from "./CachedKeyDecoder.js";
+import { DecodeError } from "./DecodeError.js";
+var __awaiter = globalThis && globalThis.__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 = globalThis && globalThis.__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 = globalThis && globalThis.__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(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+};
+var __await = globalThis && globalThis.__await || function(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncGenerator = globalThis && globalThis.__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]);
+  }
+};
+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);
+var DataViewIndexOutOfBoundsError = function() {
+  try {
+    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 = function() {
+  function Decoder2(extensionCodec, context, maxStrLength, maxBinLength, maxArrayLength, maxMapLength, maxExtLength, keyDecoder) {
+    if (extensionCodec === void 0) {
+      extensionCodec = ExtensionCodec.defaultCodec;
+    }
+    if (context === void 0) {
+      context = void 0;
+    }
+    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 = [];
+  }
+  Decoder2.prototype.reinitializeState = function() {
+    this.totalPos = 0;
+    this.headByte = HEAD_BYTE_REQUIRED;
+    this.stack.length = 0;
+  };
+  Decoder2.prototype.setBuffer = function(buffer) {
+    this.bytes = ensureUint8Array(buffer);
+    this.view = createDataView(this.bytes);
+    this.pos = 0;
+  };
+  Decoder2.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);
+      var newBuffer = new Uint8Array(remainingData.length + newData.length);
+      newBuffer.set(remainingData);
+      newBuffer.set(newData, remainingData.length);
+      this.setBuffer(newBuffer);
+    }
+  };
+  Decoder2.prototype.hasRemaining = function(size) {
+    return this.view.byteLength - this.pos >= size;
+  };
+  Decoder2.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, "]"));
+  };
+  Decoder2.prototype.decode = function(buffer) {
+    this.reinitializeState();
+    this.setBuffer(buffer);
+    var object = this.doDecodeSync();
+    if (this.hasRemaining(1)) {
+      throw this.createExtraByteError(this.pos);
+    }
+    return object;
+  };
+  Decoder2.prototype.decodeMulti = function(buffer) {
+    return __generator(this, function(_a) {
+      switch (_a.label) {
+        case 0:
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          _a.label = 1;
+        case 1:
+          if (!this.hasRemaining(1))
+            return [3, 3];
+          return [4, this.doDecodeSync()];
+        case 2:
+          _a.sent();
+          return [3, 1];
+        case 3:
+          return [
+            2
+            /*return*/
+          ];
+      }
+    });
+  };
+  Decoder2.prototype.decodeAsync = function(stream) {
+    var stream_1, stream_1_1;
+    var e_1, _a;
+    return __awaiter(this, void 0, void 0, function() {
+      var decoded, object, buffer, e_1_1, _b, headByte, pos, totalPos;
+      return __generator(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, stream_1.next()];
+          case 3:
+            if (!(stream_1_1 = _c.sent(), !stream_1_1.done))
+              return [3, 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;
+              }
+            }
+            this.totalPos += this.pos;
+            _c.label = 4;
+          case 4:
+            return [3, 2];
+          case 5:
+            return [3, 12];
+          case 6:
+            e_1_1 = _c.sent();
+            e_1 = { error: e_1_1 };
+            return [3, 12];
+          case 7:
+            _c.trys.push([7, , 10, 11]);
+            if (!(stream_1_1 && !stream_1_1.done && (_a = stream_1.return)))
+              return [3, 9];
+            return [4, _a.call(stream_1)];
+          case 8:
+            _c.sent();
+            _c.label = 9;
+          case 9:
+            return [3, 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, 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)"));
+        }
+      });
+    });
+  };
+  Decoder2.prototype.decodeArrayStream = function(stream) {
+    return this.decodeMultiAsync(stream, true);
+  };
+  Decoder2.prototype.decodeStream = function(stream) {
+    return this.decodeMultiAsync(stream, false);
+  };
+  Decoder2.prototype.decodeMultiAsync = function(stream, isArray) {
+    return __asyncGenerator(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(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, __await(stream_2.next())];
+          case 3:
+            if (!(stream_2_1 = _b.sent(), !stream_2_1.done))
+              return [3, 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:
+            return [4, __await(this.doDecodeSync())];
+          case 6:
+            return [4, _b.sent()];
+          case 7:
+            _b.sent();
+            if (--arrayItemsLeft === 0) {
+              return [3, 8];
+            }
+            return [3, 5];
+          case 8:
+            return [3, 10];
+          case 9:
+            e_2 = _b.sent();
+            if (!(e_2 instanceof DataViewIndexOutOfBoundsError)) {
+              throw e_2;
+            }
+            return [3, 10];
+          case 10:
+            this.totalPos += this.pos;
+            _b.label = 11;
+          case 11:
+            return [3, 2];
+          case 12:
+            return [3, 19];
+          case 13:
+            e_3_1 = _b.sent();
+            e_3 = { error: e_3_1 };
+            return [3, 19];
+          case 14:
+            _b.trys.push([14, , 17, 18]);
+            if (!(stream_2_1 && !stream_2_1.done && (_a = stream_2.return)))
+              return [3, 16];
+            return [4, __await(_a.call(stream_2))];
+          case 15:
+            _b.sent();
+            _b.label = 16;
+          case 16:
+            return [3, 18];
+          case 17:
+            if (e_3)
+              throw e_3.error;
+            return [
+              7
+              /*endfinally*/
+            ];
+          case 18:
+            return [
+              7
+              /*endfinally*/
+            ];
+          case 19:
+            return [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  };
+  Decoder2.prototype.doDecodeSync = function() {
+    DECODE:
+      while (true) {
+        var headByte = this.readHeadByte();
+        var object = void 0;
+        if (headByte >= 224) {
+          object = headByte - 256;
+        } else if (headByte < 192) {
+          if (headByte < 128) {
+            object = headByte;
+          } else if (headByte < 144) {
+            var size = headByte - 128;
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte < 160) {
+            var size = headByte - 144;
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else {
+            var byteLength = headByte - 160;
+            object = this.decodeUtf8String(byteLength, 0);
+          }
+        } else if (headByte === 192) {
+          object = null;
+        } else if (headByte === 194) {
+          object = false;
+        } else if (headByte === 195) {
+          object = true;
+        } else if (headByte === 202) {
+          object = this.readF32();
+        } else if (headByte === 203) {
+          object = this.readF64();
+        } else if (headByte === 204) {
+          object = this.readU8();
+        } else if (headByte === 205) {
+          object = this.readU16();
+        } else if (headByte === 206) {
+          object = this.readU32();
+        } else if (headByte === 207) {
+          object = this.readU64();
+        } else if (headByte === 208) {
+          object = this.readI8();
+        } else if (headByte === 209) {
+          object = this.readI16();
+        } else if (headByte === 210) {
+          object = this.readI32();
+        } else if (headByte === 211) {
+          object = this.readI64();
+        } else if (headByte === 217) {
+          var byteLength = this.lookU8();
+          object = this.decodeUtf8String(byteLength, 1);
+        } else if (headByte === 218) {
+          var byteLength = this.lookU16();
+          object = this.decodeUtf8String(byteLength, 2);
+        } else if (headByte === 219) {
+          var byteLength = this.lookU32();
+          object = this.decodeUtf8String(byteLength, 4);
+        } else if (headByte === 220) {
+          var size = this.readU16();
+          if (size !== 0) {
+            this.pushArrayState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = [];
+          }
+        } else if (headByte === 221) {
+          var size = this.readU32();
+          if (size !== 0) {
+            this.pushArrayState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = [];
+          }
+        } else if (headByte === 222) {
+          var size = this.readU16();
+          if (size !== 0) {
+            this.pushMapState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = {};
+          }
+        } else if (headByte === 223) {
+          var size = this.readU32();
+          if (size !== 0) {
+            this.pushMapState(size);
+            this.complete();
+            continue DECODE;
+          } else {
+            object = {};
+          }
+        } else if (headByte === 196) {
+          var size = this.lookU8();
+          object = this.decodeBinary(size, 1);
+        } else if (headByte === 197) {
+          var size = this.lookU16();
+          object = this.decodeBinary(size, 2);
+        } else if (headByte === 198) {
+          var size = this.lookU32();
+          object = this.decodeBinary(size, 4);
+        } else if (headByte === 212) {
+          object = this.decodeExtension(1, 0);
+        } else if (headByte === 213) {
+          object = this.decodeExtension(2, 0);
+        } else if (headByte === 214) {
+          object = this.decodeExtension(4, 0);
+        } else if (headByte === 215) {
+          object = this.decodeExtension(8, 0);
+        } else if (headByte === 216) {
+          object = this.decodeExtension(16, 0);
+        } else if (headByte === 199) {
+          var size = this.lookU8();
+          object = this.decodeExtension(size, 1);
+        } else if (headByte === 200) {
+          var size = this.lookU16();
+          object = this.decodeExtension(size, 2);
+        } else if (headByte === 201) {
+          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) {
+          var state = stack[stack.length - 1];
+          if (state.type === 0) {
+            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) {
+            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;
+            continue DECODE;
+          } else {
+            state.map[state.key] = object;
+            state.readCount++;
+            if (state.readCount === state.size) {
+              stack.pop();
+              object = state.map;
+            } else {
+              state.key = null;
+              state.type = 1;
+              continue DECODE;
+            }
+          }
+        }
+        return object;
+      }
+  };
+  Decoder2.prototype.readHeadByte = function() {
+    if (this.headByte === HEAD_BYTE_REQUIRED) {
+      this.headByte = this.readU8();
+    }
+    return this.headByte;
+  };
+  Decoder2.prototype.complete = function() {
+    this.headByte = HEAD_BYTE_REQUIRED;
+  };
+  Decoder2.prototype.readArraySize = function() {
+    var headByte = this.readHeadByte();
+    switch (headByte) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (headByte < 160) {
+          return headByte - 144;
+        } else {
+          throw new DecodeError("Unrecognized array type byte: ".concat(prettyByte(headByte)));
+        }
+      }
+    }
+  };
+  Decoder2.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,
+      size,
+      key: null,
+      readCount: 0,
+      map: {}
+    });
+  };
+  Decoder2.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,
+      size,
+      array: new Array(size),
+      position: 0
+    });
+  };
+  Decoder2.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;
+  };
+  Decoder2.prototype.stateIsMapKey = function() {
+    if (this.stack.length > 0) {
+      var state = this.stack[this.stack.length - 1];
+      return state.type === 1;
+    }
+    return false;
+  };
+  Decoder2.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;
+  };
+  Decoder2.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);
+  };
+  Decoder2.prototype.lookU8 = function() {
+    return this.view.getUint8(this.pos);
+  };
+  Decoder2.prototype.lookU16 = function() {
+    return this.view.getUint16(this.pos);
+  };
+  Decoder2.prototype.lookU32 = function() {
+    return this.view.getUint32(this.pos);
+  };
+  Decoder2.prototype.readU8 = function() {
+    var value = this.view.getUint8(this.pos);
+    this.pos++;
+    return value;
+  };
+  Decoder2.prototype.readI8 = function() {
+    var value = this.view.getInt8(this.pos);
+    this.pos++;
+    return value;
+  };
+  Decoder2.prototype.readU16 = function() {
+    var value = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return value;
+  };
+  Decoder2.prototype.readI16 = function() {
+    var value = this.view.getInt16(this.pos);
+    this.pos += 2;
+    return value;
+  };
+  Decoder2.prototype.readU32 = function() {
+    var value = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return value;
+  };
+  Decoder2.prototype.readI32 = function() {
+    var value = this.view.getInt32(this.pos);
+    this.pos += 4;
+    return value;
+  };
+  Decoder2.prototype.readU64 = function() {
+    var value = getUint64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  };
+  Decoder2.prototype.readI64 = function() {
+    var value = getInt64(this.view, this.pos);
+    this.pos += 8;
+    return value;
+  };
+  Decoder2.prototype.readF32 = function() {
+    var value = this.view.getFloat32(this.pos);
+    this.pos += 4;
+    return value;
+  };
+  Decoder2.prototype.readF64 = function() {
+    var value = this.view.getFloat64(this.pos);
+    this.pos += 8;
+    return value;
+  };
+  return Decoder2;
+}();
+export {
+  DataViewIndexOutOfBoundsError,
+  Decoder
+};
+//# sourceMappingURL=Decoder.js.map