@andrew_l/tl-pack 0.2.15 → 0.2.16

package/dist/shared/{tl-pack.CkwM-fIb.mjs → tl-pack.CxheH0R_.mjs}

@@ -1,5 +1,5 @@
 import pako from 'pako';
-import { isPlainObject } from '@andrew_l/toolkit';
+import { noop as noop$1, crc32, assert, isPlainObject } from '@andrew_l/toolkit';
 
 var CORE_TYPES = /* @__PURE__ */ ((CORE_TYPES2) => {
   CORE_TYPES2[CORE_TYPES2["None"] = 0] = "None";
@@ -25,6 +25,7 @@ var CORE_TYPES = /* @__PURE__ */ ((CORE_TYPES2) => {
   CORE_TYPES2[CORE_TYPES2["Repeat"] = 20] = "Repeat";
   CORE_TYPES2[CORE_TYPES2["Checksum"] = 21] = "Checksum";
   CORE_TYPES2[CORE_TYPES2["GZIP"] = 25] = "GZIP";
+  CORE_TYPES2[CORE_TYPES2["Structure"] = 26] = "Structure";
   return CORE_TYPES2;
 })(CORE_TYPES || {});
 const MAX_BUFFER_SIZE = 2144337920;
@@ -79,1074 +80,1501 @@ class Dictionary {
   }
 }
 
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-const fromCharCode = String.fromCharCode;
-const int32 = new Int32Array(2);
-const float32 = new Float32Array(int32.buffer);
-const float64 = new Float64Array(int32.buffer);
-function byteArrayAllocate(length) {
-  return new Uint8Array(length);
-}
-function coreType(value) {
-  switch (typeof value) {
-    case "string": {
-      return CORE_TYPES.String;
-    }
-    case "boolean": {
-      return value ? CORE_TYPES.BoolTrue : CORE_TYPES.BoolFalse;
-    }
-    case "number": {
-      if (Math.trunc(value) === value) {
-        if (value >= 0 && value <= 255) {
-          return CORE_TYPES.UInt8;
-        } else if (value >= 0 && value <= 65535) {
-          return CORE_TYPES.UInt16;
-        } else if (value >= 0 && value <= 4294967295) {
-          return CORE_TYPES.UInt32;
-        } else if (value >= -128 && value <= 127) {
-          return CORE_TYPES.Int8;
-        } else if (value >= -32768 && value <= 32767) {
-          return CORE_TYPES.Int16;
-        } else if (value >= -2147483648 && value <= 2147483647) {
-          return CORE_TYPES.Int32;
-        }
+const noop = Symbol();
+const NO_CONSTRUCTOR = /* @__PURE__ */ new Set([
+  CORE_TYPES.BoolFalse,
+  CORE_TYPES.BoolTrue,
+  CORE_TYPES.Null
+]);
+const SUPPORT_COMPRESSION = /* @__PURE__ */ new Set([CORE_TYPES.String]);
+const NOOP_DICTIONARY$1 = new Dictionary();
+class BinaryWriter {
+  withGzip;
+  target;
+  dictionary;
+  dictionaryExtended;
+  extensions;
+  structures;
+  _last;
+  offsetChecksum;
+  _repeat;
+  offset;
+  constructor({
+    gzip = false,
+    dictionary = NOOP_DICTIONARY$1,
+    extensions,
+    structures
+  } = {}) {
+    this.offset = 0;
+    this.offsetChecksum = 0;
+    this.extensions = /* @__PURE__ */ new Map();
+    this.structures = /* @__PURE__ */ new Map();
+    this.withGzip = gzip;
+    this.target = byteArrayAllocate(8192);
+    this._last = noop;
+    if (extensions) {
+      for (const ext of extensions) {
+        this.extensions.set(ext.token, ext);
       }
-      return CORE_TYPES.Double;
     }
-    case "object": {
-      if (value === null) return CORE_TYPES.Null;
-      if (value instanceof Date) {
-        return CORE_TYPES.Date;
-      }
-      if (Array.isArray(value)) {
-        return CORE_TYPES.Vector;
-      }
-      if (isPlainObject(value)) {
-        return CORE_TYPES.Map;
+    if (structures) {
+      for (const struct of structures) {
+        this.structures.set(struct.extension.token, struct);
       }
     }
+    if (Array.isArray(dictionary)) {
+      this.dictionary = new Dictionary(dictionary);
+    } else {
+      this.dictionary = dictionary;
+    }
+    this.dictionaryExtended = new Dictionary(void 0, this.dictionary.size);
   }
-  return CORE_TYPES.None;
-}
-function utf8Read(target, length, offset) {
-  let result;
-  if (length < 16) {
-    if (result = utf8ReadShort(target, length, offset)) return result;
+  /**
+   * Reset internal state
+   */
+  reset() {
+    this.offset = 0;
+    this.offsetChecksum = 0;
+    this._last = noop;
+    this._repeat = void 0;
+    this.dictionaryExtended = new Dictionary(void 0, this.dictionary.size);
+    return this;
   }
-  if (length > 64 && decoder)
-    return decoder.decode(target.subarray(offset, offset += length));
-  const end = offset + length;
-  const units = [];
-  result = "";
-  while (offset < end) {
-    const byte1 = target[offset++];
-    if ((byte1 & 128) === 0) {
-      units.push(byte1);
-    } else if ((byte1 & 224) === 192) {
-      const byte2 = target[offset++] & 63;
-      units.push((byte1 & 31) << 6 | byte2);
-    } else if ((byte1 & 240) === 224) {
-      const byte2 = target[offset++] & 63;
-      const byte3 = target[offset++] & 63;
-      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
-    } else if ((byte1 & 248) === 240) {
-      const byte2 = target[offset++] & 63;
-      const byte3 = target[offset++] & 63;
-      const byte4 = target[offset++] & 63;
-      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
-      if (unit > 65535) {
-        unit -= 65536;
-        units.push(unit >>> 10 & 1023 | 55296);
-        unit = 56320 | unit & 1023;
-      }
-      units.push(unit);
+  allocate(size) {
+    const position = this.offset + size;
+    if (this.safeEnd < position) {
+      this.makeRoom(position);
+    }
+    return this;
+  }
+  makeRoom(end) {
+    let start = 0;
+    let newSize = 0;
+    let target = this.target;
+    if (end > 16777216) {
+      if (end - start > MAX_BUFFER_SIZE)
+        throw new Error(
+          "Packed buffer would be larger than maximum buffer size"
+        );
+      newSize = Math.min(
+        MAX_BUFFER_SIZE,
+        Math.round(
+          Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096
+        ) * 4096
+      );
     } else {
-      units.push(byte1);
+      newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
     }
-    if (units.length >= 4096) {
-      result += fromCharCode.apply(String, units);
-      units.length = 0;
+    const newBuffer = byteArrayAllocate(newSize);
+    end = Math.min(end, target.length);
+    newBuffer.set(target.slice(start, end));
+    this.target = newBuffer;
+  }
+  get safeEnd() {
+    return this.target.length - 10;
+  }
+  getBuffer() {
+    return this.target.subarray(0, this.offset);
+  }
+  writeByte(value) {
+    this.allocate(1);
+    this.target[this.offset++] = value;
+    return this;
+  }
+  writeBool(value) {
+    if (value) {
+      this.writeByte(CORE_TYPES.BoolTrue);
+    } else {
+      this.writeByte(CORE_TYPES.BoolFalse);
     }
+    return this;
   }
-  if (units.length > 0) {
-    result += fromCharCode.apply(String, units);
+  writeNull() {
+    this.writeByte(CORE_TYPES.Null);
+    return this;
   }
-  return result;
-}
-function utf8ReadShort(target, length, offset) {
-  if (length < 4) {
-    if (length < 2) {
-      if (length === 0) return "";
-      else {
-        let a = target[offset++];
-        if ((a & 128) > 1) {
-          offset -= 1;
-          return;
-        }
-        return fromCharCode(a);
-      }
+  writeInt32(value, signed = true) {
+    this.allocate(4);
+    if (signed) {
+      this.target[this.offset++] = value;
+      this.target[this.offset++] = value >> 8;
+      this.target[this.offset++] = value >> 16;
+      this.target[this.offset++] = value >> 24;
     } else {
-      let a = target[offset++];
-      let b = target[offset++];
-      if ((a & 128) > 0 || (b & 128) > 0) {
-        offset -= 2;
-        return;
-      }
-      if (length < 3) return fromCharCode(a, b);
-      let c = target[offset++];
-      if ((c & 128) > 0) {
-        offset -= 3;
-        return;
-      }
-      return fromCharCode(a, b, c);
+      this.target[this.offset++] = value;
+      this.target[this.offset++] = value >> 8;
+      this.target[this.offset++] = value >> 16;
+      this.target[this.offset++] = value >> 24;
     }
-  } else {
-    let a = target[offset++];
-    let b = target[offset++];
-    let c = target[offset++];
-    let d = target[offset++];
-    if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
-      offset -= 4;
-      return;
+    return this;
+  }
+  writeInt16(value, signed = true) {
+    this.allocate(2);
+    if (signed) {
+      this.target[this.offset++] = value;
+      this.target[this.offset++] = value >> 8;
+    } else {
+      this.target[this.offset++] = value;
+      this.target[this.offset++] = value >> 8;
     }
-    if (length < 6) {
-      if (length === 4) return fromCharCode(a, b, c, d);
-      else {
-        let e = target[offset++];
-        if ((e & 128) > 0) {
-          offset -= 5;
-          return;
-        }
-        return fromCharCode(a, b, c, d, e);
-      }
-    } else if (length < 8) {
-      let e = target[offset++];
-      let f = target[offset++];
-      if ((e & 128) > 0 || (f & 128) > 0) {
-        offset -= 6;
-        return;
-      }
-      if (length < 7) return fromCharCode(a, b, c, d, e, f);
-      let g = target[offset++];
-      if ((g & 128) > 0) {
-        offset -= 7;
-        return;
-      }
-      return fromCharCode(a, b, c, d, e, f, g);
+    return this;
+  }
+  writeInt8(value, signed = true) {
+    this.allocate(1);
+    this.target[this.offset++] = value;
+    return this;
+  }
+  writeFloat(value) {
+    this.allocate(4);
+    float32[0] = value;
+    this.writeInt32(int32[0]);
+    return this;
+  }
+  writeDouble(value) {
+    this.allocate(8);
+    float64[0] = value;
+    this.writeInt32(int32[0], false);
+    this.writeInt32(int32[1], false);
+    return this;
+  }
+  writeDate(value) {
+    let timestamp = 0;
+    if (value instanceof Date) {
+      timestamp = value.getTime();
+    } else if (typeof value === "number") {
+      timestamp = value;
+    }
+    this.writeDouble(timestamp);
+    return this;
+  }
+  writeString(value) {
+    const strLength = value.length;
+    let start = this.offset;
+    let require = strLength << 2;
+    if (require < 254) {
+      require += 1;
+      this.offset += 1;
     } else {
-      let e = target[offset++];
-      let f = target[offset++];
-      let g = target[offset++];
-      let h = target[offset++];
-      if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
-        offset -= 8;
-        return;
-      }
-      if (length < 10) {
-        if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
-        else {
-          let i = target[offset++];
-          if ((i & 128) > 0) {
-            offset -= 9;
-            return;
-          }
-          return fromCharCode(a, b, c, d, e, f, g, h, i);
-        }
-      } else if (length < 12) {
-        let i = target[offset++];
-        let j = target[offset++];
-        if ((i & 128) > 0 || (j & 128) > 0) {
-          offset -= 10;
-          return;
-        }
-        if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
-        let k = target[offset++];
-        if ((k & 128) > 0) {
-          offset -= 11;
-          return;
-        }
-        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+      require += 4;
+      this.offset += 4;
+    }
+    this.allocate(require);
+    const bytes = utf8Write(this.target, value, this.offset);
+    if (require < 254) {
+      this.target[start++] = bytes;
+    } else {
+      this.target[start++] = 254;
+      this.target[start++] = bytes % 256;
+      this.target[start++] = (bytes >> 8) % 256;
+      this.target[start++] = (bytes >> 16) % 256;
+    }
+    this.offset += bytes;
+    return this;
+  }
+  writeChecksum(withConstructor = true) {
+    const bytes = this.target.slice(this.offsetChecksum, this.offset);
+    let sum = 0;
+    for (const val of bytes) {
+      sum += val;
+    }
+    if (withConstructor) {
+      this.writeByte(CORE_TYPES.Checksum);
+    }
+    this.writeInt32(sum);
+    this.offsetChecksum = this.offset;
+    return this;
+  }
+  writeBytes(value) {
+    const length = value.length;
+    this.writeLength(length);
+    this.allocate(length);
+    this.target.set(value, this.offset);
+    this.offset += length;
+    return this;
+  }
+  writeLength(value) {
+    if (value < 254) {
+      this.allocate(1);
+      this.target[this.offset++] = value;
+    } else {
+      this.allocate(4);
+      this.target[this.offset++] = 254;
+      this.target[this.offset++] = value % 256;
+      this.target[this.offset++] = (value >> 8) % 256;
+      this.target[this.offset++] = (value >> 16) % 256;
+    }
+    return this;
+  }
+  writeVector(value) {
+    const length = value.length;
+    this.writeLength(length);
+    for (let i = 0; i < length; i++) {
+      if (value[i] === void 0) {
+        this.writeNull();
       } else {
-        let i = target[offset++];
-        let j = target[offset++];
-        let k = target[offset++];
-        let l = target[offset++];
-        if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
-          offset -= 12;
-          return;
-        }
-        if (length < 14) {
-          if (length === 12)
-            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
-          else {
-            let m = target[offset++];
-            if ((m & 128) > 0) {
-              offset -= 13;
-              return;
-            }
-            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
-          }
-        } else {
-          let m = target[offset++];
-          let n = target[offset++];
-          if ((m & 128) > 0 || (n & 128) > 0) {
-            offset -= 14;
-            return;
-          }
-          if (length < 15)
-            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
-          let o = target[offset++];
-          if ((o & 128) > 0) {
-            offset -= 15;
-            return;
-          }
-          return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
-        }
+        this.writeObject(value[i]);
       }
     }
+    return this;
   }
-}
-const utf8Write = function(target, value, offset) {
-  return value.length < 64 ? utf8WriteShort(target, value, offset) : encoder.encodeInto(value, target.subarray(offset)).written;
-};
-const utf8WriteShort = (target, value, offset) => {
-  let i, c1, c2, strPosition = offset;
-  const strLength = value.length;
-  for (i = 0; i < strLength; i++) {
-    c1 = value.charCodeAt(i);
-    if (c1 < 128) {
-      target[strPosition++] = c1;
-    } else if (c1 < 2048) {
-      target[strPosition++] = c1 >> 6 | 192;
-      target[strPosition++] = c1 & 63 | 128;
-    } else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
-      c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
-      i++;
-      target[strPosition++] = c1 >> 18 | 240;
-      target[strPosition++] = c1 >> 12 & 63 | 128;
-      target[strPosition++] = c1 >> 6 & 63 | 128;
-      target[strPosition++] = c1 & 63 | 128;
+  writeMap(object) {
+    for (const key in object) {
+      if (object[key] === void 0) continue;
+      this._last = noop;
+      this.wireDictionary(key);
+      this.writeObject(object[key]);
+    }
+    this.writeByte(CORE_TYPES.None);
+    return this;
+  }
+  wireDictionary(value) {
+    let idx = null;
+    idx = this.dictionary.getIndex(value);
+    if (idx === null) {
+      idx = this.dictionaryExtended.getIndex(value);
+    }
+    if (idx === null) {
+      this.dictionaryExtended.maybeInsert(value);
+      this.writeCore(CORE_TYPES.DictValue, value);
     } else {
-      target[strPosition++] = c1 >> 12 | 224;
-      target[strPosition++] = c1 >> 6 & 63 | 128;
-      target[strPosition++] = c1 & 63 | 128;
+      this.writeCore(CORE_TYPES.DictIndex, idx);
     }
+    return this;
   }
-  return strPosition - offset;
-};
-
-class BinaryReader {
-  target;
-  _last;
-  _lastObject;
-  dictionary;
-  dictionaryExtended;
-  extensions;
-  _repeat;
-  _checksumOffset;
-  offset;
-  length;
-  /**
-   * Small utility class to read binary data.
-   */
-  constructor(data, options) {
-    this.target = data;
+  writeStructure(value) {
+    const ctor = value.constructor;
+    this.writeInt32(ctor.extension.token, false);
+    ctor.extension.encode.call(this, value.value);
+    return this;
+  }
+  writeGzip(value) {
+    const compressed = pako.deflateRaw(value, { level: 9 });
+    this.writeBytes(compressed);
+    return this;
+  }
+  encode(value) {
     this.offset = 0;
-    this._checksumOffset = 0;
-    this.length = data.length;
-    this.extensions = /* @__PURE__ */ new Map();
-    if (options && options.extensions) {
-      options.extensions.forEach((ext) => {
-        this.extensions.set(ext.token, ext);
-      });
+    this.offsetChecksum = 0;
+    this._last = noop;
+    this._repeat = void 0;
+    this.target = byteArrayAllocate(256);
+    this.writeObject(value);
+    return this.getBuffer();
+  }
+  startDynamicVector() {
+    this.writeByte(CORE_TYPES.VectorDynamic);
+    return this;
+  }
+  endDynamicVector() {
+    this.writeByte(CORE_TYPES.None);
+    return this;
+  }
+  _writeCustom(value) {
+    const start = this.offset;
+    this.allocate(1);
+    this.offset++;
+    let edgeExt;
+    for (const ext of this.extensions.values()) {
+      if (ext.token === -1) {
+        edgeExt = ext;
+        continue;
+      }
+      ext.encode.call(this, value);
+      const processed = start + 1 < this.offset;
+      if (processed) {
+        const end = this.offset;
+        this.offset = start;
+        this.writeByte(ext.token);
+        this.offset = end;
+        return true;
+      }
+    }
+    this.offset = start;
+    if (edgeExt) {
+      edgeExt.encode.call(this, value);
+      return start < this.offset;
+    }
+    return false;
+  }
+  writeObject(value) {
+    if (value === void 0) return this;
+    const constructorId = coreType(value);
+    if (constructorId === CORE_TYPES.None) {
+      if (this._writeCustom(value)) {
+        return this;
+      }
+      throw new TypeError(`Invalid core type of ${value}`);
     }
-    if (!options) {
-      this.dictionary = new Dictionary();
-    } else if (options.dictionary instanceof Dictionary) {
-      this.dictionary = options.dictionary;
-    } else if (Array.isArray(options.dictionary)) {
-      this.dictionary = new Dictionary(options.dictionary);
+    if (this._last === value) {
+      this.writeRepeat();
     } else {
-      this.dictionary = new Dictionary();
+      this._last = value;
+      this._repeat = void 0;
+      this.writeCore(constructorId, value);
     }
-    this.dictionaryExtended = new Dictionary(void 0, this.dictionary.size);
+    return this;
   }
-  readByte() {
-    this.assertRead(1);
-    this._last = this.target[this.offset++];
-    return this._last;
+  writeObjectGzip(value) {
+    const writer = new BinaryWriter();
+    writer.extensions = this.extensions;
+    writer.dictionary = this.dictionary;
+    writer.structures = this.structures;
+    writer.dictionaryExtended = this.dictionaryExtended;
+    writer.writeObject(value);
+    this.writeCore(CORE_TYPES.GZIP, writer.getBuffer());
+    return this;
   }
-  readInt32(signed = true) {
-    this.assertRead(4);
-    this._last = this.target[this.offset++] | this.target[this.offset++] << 8 | this.target[this.offset++] << 16 | this.target[this.offset++] << 24;
-    if (!signed) {
-      this._last = this._last >>> 0;
+  writeCore(constructorId, value) {
+    if (this.withGzip && SUPPORT_COMPRESSION.has(constructorId)) {
+      this.writeObjectGzip(value);
+      return this;
+    } else if (!NO_CONSTRUCTOR.has(constructorId)) {
+      this.writeByte(constructorId);
     }
-    return this._last;
-  }
-  readInt16(signed = true) {
-    this.assertRead(2);
-    this._last = this.target[this.offset++] | this.target[this.offset++] << 8;
-    if (signed) {
-      this._last = this._last << 16 >> 16;
+    switch (constructorId) {
+      case CORE_TYPES.Structure: {
+        return this.writeStructure(value);
+      }
+      case CORE_TYPES.Binary: {
+        return this.writeBytes(value);
+      }
+      case CORE_TYPES.GZIP: {
+        return this.writeGzip(value);
+      }
+      case CORE_TYPES.DictIndex: {
+        return this.writeLength(value);
+      }
+      case CORE_TYPES.DictValue: {
+        return this.writeString(value);
+      }
+      case CORE_TYPES.BoolFalse: {
+        return this.writeBool(value);
+      }
+      case CORE_TYPES.BoolTrue: {
+        return this.writeBool(value);
+      }
+      case CORE_TYPES.Date: {
+        return this.writeDate(value);
+      }
+      case CORE_TYPES.Int32: {
+        return this.writeInt32(value);
+      }
+      case CORE_TYPES.Int16: {
+        return this.writeInt16(value);
+      }
+      case CORE_TYPES.Int8: {
+        return this.writeInt8(value);
+      }
+      case CORE_TYPES.UInt32: {
+        return this.writeInt32(value, false);
+      }
+      case CORE_TYPES.UInt16: {
+        return this.writeInt16(value, false);
+      }
+      case CORE_TYPES.UInt8: {
+        return this.writeInt8(value, false);
+      }
+      case CORE_TYPES.Double: {
+        return this.writeDouble(value);
+      }
+      case CORE_TYPES.Float: {
+        return this.writeFloat(value);
+      }
+      case CORE_TYPES.Null: {
+        return this.writeNull();
+      }
+      case CORE_TYPES.String: {
+        if (value.length <= 16) {
+          this.offset--;
+          return this.wireDictionary(value);
+        }
+        return this.writeString(value);
+      }
+      case CORE_TYPES.Vector: {
+        return this.writeVector(value);
+      }
+      case CORE_TYPES.Map: {
+        return this.writeMap(value);
+      }
     }
-    return this._last;
+    return this;
   }
-  readInt8(signed = true) {
-    this.assertRead(1);
-    this._last = this.target[this.offset++];
-    if (signed) {
-      this._last = this._last << 24 >> 24;
+  writeRepeat() {
+    if (!this._repeat) {
+      this.writeByte(CORE_TYPES.Repeat);
+      this._repeat = { count: 0, offset: this.offset };
     }
-    return this._last;
-  }
-  /**
-   * Reads a real floating point (4 bytes) value.
-   * @returns {number}
-   */
-  readFloat() {
-    this.assertRead(4);
-    int32[0] = this.readInt32();
-    this._last = float32[0];
-    return this._last;
+    this.offset = this._repeat.offset;
+    this._repeat.count++;
+    this.writeLength(this._repeat.count);
+    return this;
   }
-  /**
-   * Reads a real floating point (8 bytes) value.
-   * @returns {BigInteger}
-   */
-  readDouble() {
-    this.assertRead(8);
-    int32[0] = this.readInt32();
-    int32[1] = this.readInt32();
-    this._last = float64[0];
-    return this._last;
+}
+
+const CONSTRUCTOR_OPTIONAL = 1644261036;
+const CONSTRUCTOR_OPTIONAL_NULL = 570519212;
+const TYPE_HANDLERS = {
+  ["unknown"]: {
+    encode: function(value, key) {
+      this.writeObject(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readObject();
+    },
+    estimatedSizeBytes: 0
+  },
+  [CORE_TYPES.Map]: {
+    encode: function(value, key) {
+      this.writeMap(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readMap(false);
+    },
+    estimatedSizeBytes: 0
+  },
+  [CORE_TYPES.Binary]: {
+    encode: function(value, key) {
+      this.writeBytes(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readBytes();
+    },
+    estimatedSizeBytes: 0
+  },
+  [CORE_TYPES.Vector]: {
+    encode: function(value, key) {
+      this.writeVector(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readVector(false);
+    },
+    estimatedSizeBytes: 0
+  },
+  [Boolean.name]: {
+    encode: function(value, key) {
+      this.writeBool(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readBool();
+    },
+    estimatedSizeBytes: 1
+  },
+  [CORE_TYPES.Int8]: {
+    encode: function(value, key) {
+      this.writeInt8(value[key], true);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt8(true);
+    },
+    estimatedSizeBytes: 1
+  },
+  [CORE_TYPES.Int16]: {
+    encode: function(value, key) {
+      this.writeInt16(value[key], true);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt16(true);
+    },
+    estimatedSizeBytes: 2
+  },
+  [CORE_TYPES.Int32]: {
+    encode: function(value, key) {
+      this.writeInt32(value[key], true);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt32(true);
+    },
+    estimatedSizeBytes: 4
+  },
+  [CORE_TYPES.UInt8]: {
+    encode: function(value, key) {
+      this.writeInt8(value[key], false);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt8(false);
+    },
+    estimatedSizeBytes: 1
+  },
+  [CORE_TYPES.UInt16]: {
+    encode: function(value, key) {
+      this.writeInt16(value[key], false);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt16(false);
+    },
+    estimatedSizeBytes: 2
+  },
+  [CORE_TYPES.UInt32]: {
+    encode: function(value, key) {
+      this.writeInt32(value[key], false);
+    },
+    decode: function(result, key) {
+      result[key] = this.readInt32(false);
+    },
+    estimatedSizeBytes: 4
+  },
+  [CORE_TYPES.Double]: {
+    encode: function(value, key) {
+      this.writeDouble(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readDouble();
+    },
+    estimatedSizeBytes: 8
+  },
+  [CORE_TYPES.Date]: {
+    encode: function(value, key) {
+      this.writeDate(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readDate();
+    },
+    estimatedSizeBytes: 8
+  },
+  [CORE_TYPES.String]: {
+    encode: function(value, key) {
+      this.writeString(value[key]);
+    },
+    decode: function(result, key) {
+      result[key] = this.readString();
+    },
+    estimatedSizeBytes: 0
   }
-  /**
-   * Read the given amount of bytes, or -1 to read all remaining.
-   * @param length {number}
-   */
-  assertRead(length) {
-    if (this.length < this.offset + +length) {
-      const left = this.target.length - this.offset;
-      const result = this.target.subarray(this.offset, this.offset + left);
-      const err = new Error(
-        `No more data left to read (need ${length}, got ${left}: ${result}); last read ${this._last}`
+};
+TYPE_HANDLERS[Number.name] = TYPE_HANDLERS[CORE_TYPES.Double];
+TYPE_HANDLERS[String.name] = TYPE_HANDLERS[CORE_TYPES.String];
+TYPE_HANDLERS[Object.name] = TYPE_HANDLERS[CORE_TYPES.Map];
+TYPE_HANDLERS[Uint8Array.name] = TYPE_HANDLERS[CORE_TYPES.Binary];
+TYPE_HANDLERS[Array.name] = TYPE_HANDLERS[CORE_TYPES.Vector];
+TYPE_HANDLERS[Date.name] = TYPE_HANDLERS[CORE_TYPES.Date];
+function compileStructure(name, version, properties, checksum) {
+  const encodeFns = [];
+  const decodeFns = [];
+  const structures = [];
+  const structureId = crc32(name) >>> 0;
+  let estimatedSizeBytes = 1;
+  encodeFns.push(function() {
+    this.writeByte(version);
+  });
+  decodeFns.push(function() {
+    const ver = this.readByte();
+    assert.ok(
+      version === ver,
+      `Structure ${structureId} version mismatch: expected ${version}, got ${ver}`
+    );
+  });
+  const entries = Object.entries(properties);
+  const entriesLength = entries.length;
+  for (let i = 0; i < entriesLength; i++) {
+    const [key, prop] = entries[i];
+    const isRequired = prop.required === true;
+    const isArray = Array.isArray(prop.type);
+    const propType = Array.isArray(prop.type) ? prop.type[0] : prop.type;
+    if (isStructureType(propType)) {
+      encodeFns.push(
+        createStructureEncoder(key, propType, isRequired, isArray)
       );
-      err.incomplete = true;
-      Error.captureStackTrace(err, this.assertRead);
-      throw err;
-    }
-  }
-  assertConstructor(constructorId) {
-    const byte = this.readByte();
-    if (byte !== constructorId) {
-      throw new Error(
-        `Invalid constructor code, expected = ${CORE_TYPES[constructorId]}, got = ${CORE_TYPES[byte] || byte}, offset = ${this.offset - 1}`
+      decodeFns.push(createStructureDecoder(key, isRequired, isArray));
+      estimatedSizeBytes += propType.estimatedSizeBytes;
+      structures.push(propType);
+      continue;
+    }
+    const typeName = propType?.name || (propType === null ? "unknown" : propType);
+    const handler = TYPE_HANDLERS[typeName];
+    if (handler) {
+      encodeFns.push(
+        createBoundEncoder(handler.encode, key, isRequired, isArray)
+      );
+      decodeFns.push(
+        createBoundDecoder(handler.decode, key, isRequired, isArray)
+      );
+      estimatedSizeBytes += handler.estimatedSizeBytes;
+    } else {
+      throw new Error(`Unsupported property type: ${typeName || "unknown"}`);
+    }
+  }
+  if (checksum) {
+    estimatedSizeBytes += 4;
+    encodeFns.push(function() {
+      this.writeChecksum(false);
+    });
+    decodeFns.push(function() {
+      this.readChecksum(false);
+    });
+  }
+  const compiled = {
+    id: structureId,
+    encodeFns,
+    decodeFns,
+    structures,
+    estimatedSizeBytes
+  };
+  return compiled;
+}
+function isStructureType(type) {
+  return type?.prototype && Structure.prototype.isPrototypeOf(type.prototype);
+}
+function createStructureEncoder(key, StructureCtor, isRequired, isArray) {
+  return function(value) {
+    const hasValue = value[key] !== void 0 && value[key] !== null;
+    if (!hasValue) {
+      assert.ok(!isRequired, `Required property "${key}" is missing or null`);
+      if (value[key] === null) {
+        this.writeInt32(CONSTRUCTOR_OPTIONAL_NULL);
+      } else {
+        this.writeInt32(CONSTRUCTOR_OPTIONAL);
+      }
+    } else if (isArray) {
+      const arr = value[key];
+      assert.array(arr, `Expected property "${key}" to be array.`);
+      this.writeLength(arr.length);
+      for (let idx = 0; idx < arr.length; idx++) {
+        this.writeStructure(
+          arr[idx] instanceof Structure ? arr[idx] : new StructureCtor(arr[idx])
+        );
+      }
+    } else {
+      this.writeStructure(
+        value[key] instanceof Structure ? value[key] : new StructureCtor(value[key])
       );
     }
-  }
-  /**
-   * Gets the byte array representing the current buffer as a whole.
-   */
-  getBuffer() {
-    return this.target;
-  }
-  readNull() {
-    const value = this.readByte();
-    if (value === CORE_TYPES.Null) {
-      return null;
-    }
-    throw new Error(`Invalid boolean code ${value.toString(16)}`);
-  }
-  readLength() {
-    const firstByte = this.readByte();
-    if (firstByte === 254) {
-      return this.readByte() | this.readByte() << 8 | this.readByte() << 16;
+  };
+}
+function createStructureDecoder(key, isRequired, isArray) {
+  return function(result) {
+    let shouldRead = true;
+    if (!isRequired) {
+      shouldRead = !readMaybeInt32(this, CONSTRUCTOR_OPTIONAL);
+      if (shouldRead && readMaybeInt32(this, CONSTRUCTOR_OPTIONAL_NULL)) {
+        result[key] = null;
+        return;
+      }
     }
-    return firstByte;
-  }
-  readAll() {
-    const result = [];
-    while (this.length > this.offset) {
-      result.push(this.readObject());
+    if (shouldRead) {
+      if (isArray) {
+        const length = this.readLength();
+        const arrResult = Array.from({ length });
+        for (let idx = 0; idx < length; idx++) {
+          arrResult[idx] = this.readStructure(false);
+        }
+        result[key] = arrResult;
+      } else {
+        result[key] = this.readStructure(false);
+      }
     }
-    return result;
-  }
-  readBytes() {
-    const length = this.readLength();
-    this.assertRead(length);
-    const bytes = this.target.subarray(this.offset, this.offset + length);
-    this.offset += bytes.length;
-    this._last = bytes;
-    return bytes;
-  }
-  /**
-   * Reads encoded string.
-   */
-  readString() {
-    const length = this.readLength();
-    this.assertRead(length);
-    const result = utf8Read(this.target, length, this.offset);
-    this.offset += length;
-    this._last = result;
-    return result;
-  }
-  /**
-   * Reads a boolean value.
-   */
-  readBool() {
-    const value = this.readByte();
-    if (value === CORE_TYPES.BoolTrue) {
-      return true;
-    } else if (value === CORE_TYPES.BoolFalse) {
-      return false;
-    } else {
-      throw new Error(`Invalid boolean code ${value.toString(16)}`);
+  };
+}
+function readMaybeInt32(reader, expectedValue) {
+  let result = false;
+  if (reader.length >= reader.offset + 4) {
+    result = reader.readInt32() === expectedValue;
+    if (!result) {
+      reader.offset -= 4;
     }
   }
-  /**
-   * Reads and converts Unix time
-   * into a Javascript {Date} object.
-   */
-  readDate() {
-    const value = this.readDouble();
-    return new Date(value);
-  }
-  /**
-   * Reads a object.
-   */
-  readObject() {
-    if (this._repeat) {
-      if (this._repeat.pool > 0) {
-        --this._repeat.pool;
-        return this._repeat.value;
+  return result;
+}
+function createBoundEncoder(encodeFn, key, isRequired, isArray) {
+  return function(value) {
+    const hasValue = value[key] !== void 0 && value[key] !== null;
+    if (!hasValue) {
+      assert.ok(!isRequired, `Required property "${key}" is missing or null`);
+      if (value[key] === null) {
+        this.writeInt32(CONSTRUCTOR_OPTIONAL_NULL);
       } else {
-        this._repeat = void 0;
+        this.writeInt32(CONSTRUCTOR_OPTIONAL);
+      }
+    } else if (isArray) {
+      const arr = value[key];
+      assert.array(arr, `Expected property "${key}" to be array.`);
+      this.writeLength(arr.length);
+      for (let idx = 0; idx < arr.length; idx++) {
+        encodeFn.call(this, arr, idx);
       }
-    }
-    const constructorId = this.readByte();
-    const ext = this.extensions.get(constructorId);
-    let value;
-    if (ext) {
-      value = ext.decode.call(this);
     } else {
-      value = this._lastObject = this.readCore(constructorId);
+      encodeFn.call(this, value, key);
     }
-    return value;
-  }
-  readObjectGzip() {
-    const bytes = this.readGzip();
-    const reader = new BinaryReader(bytes);
-    reader.extensions = this.extensions;
-    reader.dictionary = this.dictionary;
-    reader.dictionaryExtended = this.dictionaryExtended;
-    return reader.readObject();
-  }
-  readGzip() {
-    return pako.inflateRaw(this.readBytes());
-  }
-  readCore(constructorId) {
-    switch (constructorId) {
-      case CORE_TYPES.None:
-        return this.readObject();
-      case CORE_TYPES.GZIP:
-        return this.readObjectGzip();
-      case CORE_TYPES.BoolTrue:
-        return true;
-      case CORE_TYPES.BoolFalse:
-        return false;
-      case CORE_TYPES.Vector:
-        return this.readVector(false);
-      case CORE_TYPES.VectorDynamic:
-        return this.readVectorDynamic(false);
-      case CORE_TYPES.Null:
-        return null;
-      case CORE_TYPES.Binary:
-        return this.readBytes();
-      case CORE_TYPES.String:
-        return this.readString();
-      case CORE_TYPES.Date:
-        return this.readDate();
-      case CORE_TYPES.Int32:
-        return this.readInt32();
-      case CORE_TYPES.Int16:
-        return this.readInt16();
-      case CORE_TYPES.Int8:
-        return this.readInt8();
-      case CORE_TYPES.UInt32:
-        return this.readInt32(false);
-      case CORE_TYPES.UInt16:
-        return this.readInt16(false);
-      case CORE_TYPES.UInt8:
-        return this.readInt8(false);
-      case CORE_TYPES.Float:
-        return this.readFloat();
-      case CORE_TYPES.Double:
-        return this.readDouble();
-      case CORE_TYPES.Map:
-        return this.readMap(false);
-      case CORE_TYPES.Checksum:
-        return void this.readChecksum(false);
-      case CORE_TYPES.DictIndex: {
-        const idx = this.readLength();
-        return this.getDictionaryValue(idx);
+  };
+}
+function createBoundDecoder(decodeFn, key, isRequired, isArray) {
+  return function(result) {
+    let shouldRead = true;
+    if (!isRequired) {
+      shouldRead = !readMaybeInt32(this, CONSTRUCTOR_OPTIONAL);
+      if (shouldRead && readMaybeInt32(this, CONSTRUCTOR_OPTIONAL_NULL)) {
+        result[key] = null;
+        return;
       }
-      case CORE_TYPES.DictValue: {
-        const value = this.readString();
-        this.dictionaryExtended.maybeInsert(value);
-        return value;
+    }
+    if (shouldRead) {
+      if (isArray) {
+        const length = this.readLength();
+        const arrResult = Array.from({ length });
+        for (let idx = 0; idx < length; idx++) {
+          decodeFn.call(this, arrResult, idx);
+        }
+        result[key] = arrResult;
+      } else {
+        decodeFn.call(this, result, key);
       }
-      case CORE_TYPES.Repeat: {
-        const size = this.readLength();
-        this._repeat = { pool: size - 1, value: this._lastObject };
-        return this._lastObject;
+    }
+  };
+}
+function defineStructure({
+  name,
+  properties,
+  version,
+  checksum = false
+}) {
+  const compiled = compileStructure(name, version, properties, checksum);
+  return class DefinedStructure extends Structure {
+    static estimatedSizeBytes = compiled.estimatedSizeBytes;
+    static structures = compiled.structures;
+    static extension = {
+      token: compiled.id,
+      encode(value) {
+        const fns = compiled.encodeFns;
+        const length = fns.length;
+        for (let i = 0; i < length; i++) {
+          fns[i].call(this, value);
+        }
+      },
+      decode() {
+        const result = {};
+        const fns = compiled.decodeFns;
+        const length = fns.length;
+        for (let i = 0; i < length; i++) {
+          fns[i].call(this, result);
+        }
+        return result;
       }
-    }
-    throw new Error(
-      `Invalid constructor = ${CORE_TYPES[constructorId] || constructorId}, offset = ${this.offset - 1}`
-    );
+    };
+  };
+}
+class Structure {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  toBuffer(options) {
+    const ctor = this.constructor;
+    const writer = new BinaryWriter(options);
+    ctor.extension.encode.call(writer, this.value);
+    return writer.getBuffer();
+  }
+  static fromBuffer(buffer, options = {}) {
+    const reader = new BinaryReader(buffer, {
+      ...options,
+      structures: options.structures ? this.structures.concat(options.structures) : this.structures
+    });
+    return this.extension.decode.call(reader);
+  }
+  static estimatedSizeBytes = -1;
+  static structures = [];
+  static extension = {
+    token: CORE_TYPES.Binary,
+    encode: noop$1,
+    decode: noop$1
+  };
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const fromCharCode = String.fromCharCode;
+const int32 = new Int32Array(2);
+const float32 = new Float32Array(int32.buffer);
+const float64 = new Float64Array(int32.buffer);
+function byteArrayAllocate(length) {
+  return new Uint8Array(length);
+}
+function coreType(value) {
+  if (value instanceof Structure) {
+    return CORE_TYPES.Structure;
+  } else if (value instanceof Uint8Array) {
+    return CORE_TYPES.Binary;
   }
-  getDictionaryValue(index) {
-    let value = null;
-    if (this.dictionary) {
-      value = this.dictionary.getValue(index);
+  switch (typeof value) {
+    case "string": {
+      return CORE_TYPES.String;
     }
-    if (value === null) {
-      value = this.dictionaryExtended.getValue(index);
+    case "boolean": {
+      return value ? CORE_TYPES.BoolTrue : CORE_TYPES.BoolFalse;
     }
-    return value;
-  }
-  readDictionary() {
-    const constructorId = this.readByte();
-    let key = null;
-    switch (constructorId) {
-      case CORE_TYPES.DictIndex: {
-        const idx = this.readLength();
-        key = this.getDictionaryValue(idx);
-        break;
+    case "number": {
+      if (Math.trunc(value) === value) {
+        if (value >= 0 && value <= 255) {
+          return CORE_TYPES.UInt8;
+        } else if (value >= 0 && value <= 65535) {
+          return CORE_TYPES.UInt16;
+        } else if (value >= 0 && value <= 4294967295) {
+          return CORE_TYPES.UInt32;
+        } else if (value >= -128 && value <= 127) {
+          return CORE_TYPES.Int8;
+        } else if (value >= -32768 && value <= 32767) {
+          return CORE_TYPES.Int16;
+        } else if (value >= -2147483648 && value <= 2147483647) {
+          return CORE_TYPES.Int32;
+        }
       }
-      case CORE_TYPES.DictValue: {
-        key = this.readString();
-        this.dictionaryExtended.maybeInsert(key);
-        break;
+      return CORE_TYPES.Double;
+    }
+    case "object": {
+      if (value === null) return CORE_TYPES.Null;
+      if (value instanceof Date) {
+        return CORE_TYPES.Date;
       }
-      case CORE_TYPES.None: {
-        key = null;
-        break;
+      if (Array.isArray(value)) {
+        return CORE_TYPES.Vector;
       }
-      default: {
-        this.seek(-1);
+      if (isPlainObject(value)) {
+        return CORE_TYPES.Map;
       }
     }
-    return key;
   }
-  readMap(checkConstructor = true) {
-    if (checkConstructor) {
-      this.assertConstructor(CORE_TYPES.Map);
+  return CORE_TYPES.None;
+}
+function utf8Read(target, length, offset) {
+  let result;
+  if (length < 16) {
+    if (result = utf8ReadShort(target, length, offset)) return result;
+  }
+  if (length > 64 && decoder)
+    return decoder.decode(target.subarray(offset, offset += length));
+  const end = offset + length;
+  const units = [];
+  result = "";
+  while (offset < end) {
+    const byte1 = target[offset++];
+    if ((byte1 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      const byte2 = target[offset++] & 63;
+      units.push((byte1 & 31) << 6 | byte2);
+    } else if ((byte1 & 240) === 224) {
+      const byte2 = target[offset++] & 63;
+      const byte3 = target[offset++] & 63;
+      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+    } else if ((byte1 & 248) === 240) {
+      const byte2 = target[offset++] & 63;
+      const byte3 = target[offset++] & 63;
+      const byte4 = target[offset++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+      }
+      units.push(unit);
+    } else {
+      units.push(byte1);
     }
-    const temp = {};
-    let key = this.readDictionary();
-    while (key !== null) {
-      temp[key] = this.readObject();
-      key = this.readDictionary();
+    if (units.length >= 4096) {
+      result += fromCharCode.apply(String, units);
+      units.length = 0;
     }
-    return temp;
   }
-  decode(value) {
-    this.target = value;
-    this._last = void 0;
-    this._lastObject = void 0;
-    this._repeat = void 0;
-    this.offset = 0;
-    this._checksumOffset = 0;
-    this.length = value.length;
-    return this.readObject();
+  if (units.length > 0) {
+    result += fromCharCode.apply(String, units);
   }
-  /**
-   * Reads a vector (a list) of objects.
-   */
-  readVector(checkConstructor = true) {
-    if (checkConstructor) {
-      this.assertConstructor(CORE_TYPES.Vector);
-    }
-    const count = this.readLength();
-    const temp = [];
-    for (let i = 0; i < count; i++) {
-      temp.push(this.readObject());
+  return result;
+}
+function utf8ReadShort(target, length, offset) {
+  if (length < 4) {
+    if (length < 2) {
+      if (length === 0) return "";
+      else {
+        let a = target[offset++];
+        if ((a & 128) > 1) {
+          offset -= 1;
+          return;
+        }
+        return fromCharCode(a);
+      }
+    } else {
+      let a = target[offset++];
+      let b = target[offset++];
+      if ((a & 128) > 0 || (b & 128) > 0) {
+        offset -= 2;
+        return;
+      }
+      if (length < 3) return fromCharCode(a, b);
+      let c = target[offset++];
+      if ((c & 128) > 0) {
+        offset -= 3;
+        return;
+      }
+      return fromCharCode(a, b, c);
     }
-    return temp;
-  }
-  /**
-   * Reads a vector (a list) of objects.
-   */
-  readVectorDynamic(checkConstructor = true) {
-    if (checkConstructor) {
-      this.assertConstructor(CORE_TYPES.VectorDynamic);
+  } else {
+    let a = target[offset++];
+    let b = target[offset++];
+    let c = target[offset++];
+    let d = target[offset++];
+    if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
+      offset -= 4;
+      return;
     }
-    const temp = [];
-    let complete = false;
-    while (this.length > this.offset) {
-      const constructorId = this.readByte();
-      if (constructorId === CORE_TYPES.None) {
-        complete = true;
-        break;
+    if (length < 6) {
+      if (length === 4) return fromCharCode(a, b, c, d);
+      else {
+        let e = target[offset++];
+        if ((e & 128) > 0) {
+          offset -= 5;
+          return;
+        }
+        return fromCharCode(a, b, c, d, e);
       }
-      const ext = this.extensions.get(constructorId);
-      let value;
-      if (ext) {
-        value = ext.decode.call(this);
+    } else if (length < 8) {
+      let e = target[offset++];
+      let f = target[offset++];
+      if ((e & 128) > 0 || (f & 128) > 0) {
+        offset -= 6;
+        return;
+      }
+      if (length < 7) return fromCharCode(a, b, c, d, e, f);
+      let g = target[offset++];
+      if ((g & 128) > 0) {
+        offset -= 7;
+        return;
+      }
+      return fromCharCode(a, b, c, d, e, f, g);
+    } else {
+      let e = target[offset++];
+      let f = target[offset++];
+      let g = target[offset++];
+      let h = target[offset++];
+      if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
+        offset -= 8;
+        return;
+      }
+      if (length < 10) {
+        if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
+        else {
+          let i = target[offset++];
+          if ((i & 128) > 0) {
+            offset -= 9;
+            return;
+          }
+          return fromCharCode(a, b, c, d, e, f, g, h, i);
+        }
+      } else if (length < 12) {
+        let i = target[offset++];
+        let j = target[offset++];
+        if ((i & 128) > 0 || (j & 128) > 0) {
+          offset -= 10;
+          return;
+        }
+        if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+        let k = target[offset++];
+        if ((k & 128) > 0) {
+          offset -= 11;
+          return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
       } else {
-        value = this.readCore(constructorId);
+        let i = target[offset++];
+        let j = target[offset++];
+        let k = target[offset++];
+        let l = target[offset++];
+        if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
+          offset -= 12;
+          return;
+        }
+        if (length < 14) {
+          if (length === 12)
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+          else {
+            let m = target[offset++];
+            if ((m & 128) > 0) {
+              offset -= 13;
+              return;
+            }
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+          }
+        } else {
+          let m = target[offset++];
+          let n = target[offset++];
+          if ((m & 128) > 0 || (n & 128) > 0) {
+            offset -= 14;
+            return;
+          }
+          if (length < 15)
+            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+          let o = target[offset++];
+          if ((o & 128) > 0) {
+            offset -= 15;
+            return;
+          }
+          return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+        }
       }
-      temp.push(value);
-    }
-    if (!complete) {
-      const err = new Error(`DynamicVector incomplete.`);
-      err.incomplete = true;
-      Error.captureStackTrace(err, this.readDictionary);
-      throw err;
     }
-    this._last = temp;
-    return temp;
   }
-  readChecksum(checkConstructor = true) {
-    const offset = this.offset;
-    if (checkConstructor) {
-      this.assertConstructor(CORE_TYPES.Checksum);
-    }
-    const bytes = this.target.slice(this._checksumOffset, offset);
-    const checksum = this.readLength();
-    let sum = 0;
-    for (const val of bytes) {
-      sum += val;
-    }
-    if (checksum - sum !== 0) {
-      throw new Error(
-        `Invalid checksum = ${checksum - sum}, offset = ${offset}`
-      );
+}
+const utf8Write = function(target, value, offset) {
+  return value.length < 64 ? utf8WriteShort(target, value, offset) : encoder.encodeInto(value, target.subarray(offset)).written;
+};
+const utf8WriteShort = (target, value, offset) => {
+  let i, c1, c2, strPosition = offset;
+  const strLength = value.length;
+  for (i = 0; i < strLength; i++) {
+    c1 = value.charCodeAt(i);
+    if (c1 < 128) {
+      target[strPosition++] = c1;
+    } else if (c1 < 2048) {
+      target[strPosition++] = c1 >> 6 | 192;
+      target[strPosition++] = c1 & 63 | 128;
+    } else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
+      c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+      i++;
+      target[strPosition++] = c1 >> 18 | 240;
+      target[strPosition++] = c1 >> 12 & 63 | 128;
+      target[strPosition++] = c1 >> 6 & 63 | 128;
+      target[strPosition++] = c1 & 63 | 128;
+    } else {
+      target[strPosition++] = c1 >> 12 | 224;
+      target[strPosition++] = c1 >> 6 & 63 | 128;
+      target[strPosition++] = c1 & 63 | 128;
     }
-    this._checksumOffset = this.offset;
-  }
-  /**
-   * Tells the current position on the stream.
-   */
-  tellPosition() {
-    return this.offset;
-  }
-  /**
-   * Sets the current position on the stream.
-   */
-  setPosition(position) {
-    this.offset = position;
-  }
-  /**
-   * Seeks the stream position given an offset from the current position.
-   * The offset may be negative.
-   */
-  seek(offset) {
-    this.offset += offset;
   }
-}
+  return strPosition - offset;
+};
 
-const noop = Symbol();
-const NO_CONSTRUCTOR = /* @__PURE__ */ new Set([
-  CORE_TYPES.BoolFalse,
-  CORE_TYPES.BoolTrue,
-  CORE_TYPES.Null
-]);
-const SUPPORT_COMPRESSION = /* @__PURE__ */ new Set([CORE_TYPES.String]);
-class BinaryWriter {
-  withGzip;
+const NOOP_DICTIONARY = new Dictionary();
+class BinaryReader {
   target;
+  _last;
+  _lastObject;
   dictionary;
   dictionaryExtended;
   extensions;
-  _last = noop;
-  _checksumOffset;
+  structures;
   _repeat;
+  _checksumOffset;
   offset;
-  constructor(options) {
+  length;
+  /**
+   * Small utility class to read binary data.
+   */
+  constructor(data, {
+    dictionary = NOOP_DICTIONARY,
+    extensions,
+    structures
+  } = {}) {
+    this.target = data;
     this.offset = 0;
     this._checksumOffset = 0;
+    this.length = data.length;
     this.extensions = /* @__PURE__ */ new Map();
-    this.withGzip = !!options && !!options.gzip;
-    this.target = byteArrayAllocate(8192);
-    if (options && options.extensions) {
-      options.extensions.forEach((ext) => {
+    this.structures = /* @__PURE__ */ new Map();
+    if (extensions) {
+      for (const ext of extensions) {
         this.extensions.set(ext.token, ext);
-      });
+      }
+    }
+    if (structures) {
+      for (const struct of structures) {
+        this.structures.set(struct.extension.token, struct);
+      }
     }
-    if (!options) {
-      this.dictionary = new Dictionary();
-    } else if (options.dictionary instanceof Dictionary) {
-      this.dictionary = options.dictionary;
-    } else if (Array.isArray(options.dictionary)) {
-      this.dictionary = new Dictionary(options.dictionary);
+    if (Array.isArray(dictionary)) {
+      this.dictionary = new Dictionary(dictionary);
     } else {
-      this.dictionary = new Dictionary();
+      this.dictionary = dictionary;
     }
     this.dictionaryExtended = new Dictionary(void 0, this.dictionary.size);
   }
-  allocate(size) {
-    const position = this.offset + size;
-    if (this.safeEnd < position) {
-      this.makeRoom(position);
+  readByte() {
+    this.assertRead(1);
+    this._last = this.target[this.offset++];
+    return this._last;
+  }
+  readInt32(signed = true) {
+    this.assertRead(4);
+    this._last = this.target[this.offset++] | this.target[this.offset++] << 8 | this.target[this.offset++] << 16 | this.target[this.offset++] << 24;
+    if (!signed) {
+      this._last = this._last >>> 0;
     }
-    return this;
+    return this._last;
   }
-  makeRoom(end) {
-    let start = 0;
-    let newSize = 0;
-    let target = this.target;
-    if (end > 16777216) {
-      if (end - start > MAX_BUFFER_SIZE)
-        throw new Error(
-          "Packed buffer would be larger than maximum buffer size"
-        );
-      newSize = Math.min(
-        MAX_BUFFER_SIZE,
-        Math.round(
-          Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096
-        ) * 4096
-      );
-    } else {
-      newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
+  readInt16(signed = true) {
+    this.assertRead(2);
+    this._last = this.target[this.offset++] | this.target[this.offset++] << 8;
+    if (signed) {
+      this._last = this._last << 16 >> 16;
     }
-    const newBuffer = byteArrayAllocate(newSize);
-    end = Math.min(end, target.length);
-    newBuffer.set(target.slice(start, end));
-    this.target = newBuffer;
+    return this._last;
   }
-  get safeEnd() {
-    return this.target.length - 10;
+  readInt8(signed = true) {
+    this.assertRead(1);
+    this._last = this.target[this.offset++];
+    if (signed) {
+      this._last = this._last << 24 >> 24;
+    }
+    return this._last;
   }
-  getBuffer() {
-    return this.target.subarray(0, this.offset);
+  /**
+   * Reads a real floating point (4 bytes) value.
+   * @returns {number}
+   */
+  readFloat() {
+    this.assertRead(4);
+    int32[0] = this.readInt32();
+    this._last = float32[0];
+    return this._last;
   }
-  writeByte(value) {
-    this.allocate(1);
-    this.target[this.offset++] = value;
-    return this;
+  /**
+   * Reads a real floating point (8 bytes) value.
+   * @returns {BigInteger}
+   */
+  readDouble() {
+    this.assertRead(8);
+    int32[0] = this.readInt32();
+    int32[1] = this.readInt32();
+    this._last = float64[0];
+    return this._last;
   }
-  writeBool(value) {
-    if (value) {
-      this.writeByte(CORE_TYPES.BoolTrue);
-    } else {
-      this.writeByte(CORE_TYPES.BoolFalse);
+  /**
+   * Throws error if provided length cannot be read from buffer
+   * @param length {number}
+   */
+  assertRead(length) {
+    if (this.length < this.offset + +length) {
+      const left = this.target.length - this.offset;
+      const result = this.target.subarray(this.offset, this.offset + left);
+      const err = new Error(
+        `No more data left to read (need ${length}, got ${left}: ${result}); last read ${this._last}`
+      );
+      err.incomplete = true;
+      Error.captureStackTrace(err, this.assertRead);
+      throw err;
     }
-    return this;
   }
-  writeNull() {
-    this.writeByte(CORE_TYPES.Null);
-    return this;
+  assertConstructor(constructorId) {
+    const byte = this.readByte();
+    if (byte !== constructorId) {
+      throw new Error(
+        `Invalid constructor code, expected = ${CORE_TYPES[constructorId]}, got = ${CORE_TYPES[byte] || byte}, offset = ${this.offset - 1}`
+      );
+    }
   }
-  writeInt32(value, signed = true) {
-    this.allocate(4);
-    if (signed) {
-      this.target[this.offset++] = value;
-      this.target[this.offset++] = value >> 8;
-      this.target[this.offset++] = value >> 16;
-      this.target[this.offset++] = value >> 24;
-    } else {
-      this.target[this.offset++] = value;
-      this.target[this.offset++] = value >> 8;
-      this.target[this.offset++] = value >> 16;
-      this.target[this.offset++] = value >> 24;
+  /**
+   * Gets the byte array representing the current buffer as a whole.
+   */
+  getBuffer() {
+    return this.target;
+  }
+  readNull() {
+    const value = this.readByte();
+    if (value === CORE_TYPES.Null) {
+      return null;
     }
-    return this;
+    throw new Error(`Invalid boolean code ${value.toString(16)}`);
   }
-  writeInt16(value, signed = true) {
-    this.allocate(2);
-    if (signed) {
-      this.target[this.offset++] = value;
-      this.target[this.offset++] = value >> 8;
-    } else {
-      this.target[this.offset++] = value;
-      this.target[this.offset++] = value >> 8;
+  readLength() {
+    const firstByte = this.readByte();
+    if (firstByte === 254) {
+      return this.readByte() | this.readByte() << 8 | this.readByte() << 16;
     }
-    return this;
+    return firstByte;
   }
-  writeInt8(value, signed = true) {
-    this.allocate(1);
-    this.target[this.offset++] = value;
-    return this;
+  readAll() {
+    const result = [];
+    while (this.length > this.offset) {
+      result.push(this.readObject());
+    }
+    return result;
   }
-  writeFloat(value) {
-    this.allocate(4);
-    float32[0] = value;
-    this.writeInt32(int32[0]);
-    return this;
+  readBytes() {
+    const length = this.readLength();
+    this.assertRead(length);
+    const bytes = this.target.subarray(this.offset, this.offset + length);
+    this.offset += bytes.length;
+    this._last = bytes;
+    return bytes;
   }
-  writeDouble(value) {
-    this.allocate(8);
-    float64[0] = value;
-    this.writeInt32(int32[0], false);
-    this.writeInt32(int32[1], false);
-    return this;
+  /**
+   * Reads encoded string.
+   */
+  readString() {
+    const length = this.readLength();
+    this.assertRead(length);
+    const result = utf8Read(this.target, length, this.offset);
+    this.offset += length;
+    this._last = result;
+    return result;
   }
-  writeDate(value) {
-    let timestamp = 0;
-    if (value instanceof Date) {
-      timestamp = value.getTime();
-    } else if (typeof value === "number") {
-      timestamp = value;
+  /**
+   * Reads a boolean value.
+   */
+  readBool() {
+    const value = this.readByte();
+    if (value === CORE_TYPES.BoolTrue) {
+      return true;
+    } else if (value === CORE_TYPES.BoolFalse) {
+      return false;
+    } else {
+      throw new Error(`Invalid boolean code ${value.toString(16)}`);
     }
-    this.writeDouble(timestamp);
-    return this;
   }
-  writeString(value) {
-    const strLength = value.length;
-    let start = this.offset;
-    let require = strLength << 2;
-    if (require < 254) {
-      require += 1;
-      this.offset += 1;
-    } else {
-      require += 4;
-      this.offset += 4;
+  /**
+   * Reads and converts Unix time
+   * into a Javascript {Date} object.
+   */
+  readDate() {
+    const value = this.readDouble();
+    return new Date(value);
+  }
+  readStructure(checkConstructor = true) {
+    if (checkConstructor) {
+      this.assertConstructor(CORE_TYPES.Structure);
     }
-    this.allocate(require);
-    const bytes = utf8Write(this.target, value, this.offset);
-    if (require < 254) {
-      this.target[start++] = bytes;
-    } else {
-      this.target[start++] = 254;
-      this.target[start++] = bytes % 256;
-      this.target[start++] = (bytes >> 8) % 256;
-      this.target[start++] = (bytes >> 16) % 256;
+    const structureId = this.readInt32(false);
+    const struct = this.structures.get(structureId);
+    if (!struct) {
+      throw new Error(
+        `Unknown structure id = ${structureId}, offset = ${this.offset - 1}`
+      );
     }
-    this.offset += bytes;
-    return this;
+    return struct.extension.decode.call(this);
   }
-  writeChecksum(withConstructor = true) {
-    const bytes = this.target.slice(this._checksumOffset, this.offset);
-    let sum = 0;
-    for (const val of bytes) {
-      sum += val;
+  /**
+   * Reads a object.
+   */
+  readObject() {
+    if (this._repeat) {
+      if (this._repeat.pool > 0) {
+        --this._repeat.pool;
+        return this._repeat.value;
+      } else {
+        this._repeat = void 0;
+      }
     }
-    if (withConstructor) {
-      this.writeByte(CORE_TYPES.Checksum);
+    const constructorId = this.readByte();
+    const ext = this.extensions.get(constructorId);
+    let value;
+    if (ext) {
+      value = ext.decode.call(this);
+    } else {
+      value = this._lastObject = this.readCore(constructorId);
     }
-    this.writeLength(sum);
-    this._checksumOffset = this.offset;
-    return this;
+    return value;
   }
-  writeBytes(value) {
-    const length = value.length;
-    this.writeLength(length);
-    this.allocate(length);
-    this.target.set(value, this.offset);
-    this.offset += length;
-    return this;
+  readObjectGzip() {
+    const bytes = this.readGzip();
+    const reader = new BinaryReader(bytes);
+    reader.extensions = this.extensions;
+    reader.dictionary = this.dictionary;
+    reader.dictionaryExtended = this.dictionaryExtended;
+    return reader.readObject();
   }
-  writeLength(value) {
-    if (value < 254) {
-      this.allocate(1);
-      this.target[this.offset++] = value;
-    } else {
-      this.allocate(4);
-      this.target[this.offset++] = 254;
-      this.target[this.offset++] = value % 256;
-      this.target[this.offset++] = (value >> 8) % 256;
-      this.target[this.offset++] = (value >> 16) % 256;
+  readGzip() {
+    return pako.inflateRaw(this.readBytes());
+  }
+  readCore(constructorId) {
+    switch (constructorId) {
+      case CORE_TYPES.None:
+        return this.readObject();
+      case CORE_TYPES.GZIP:
+        return this.readObjectGzip();
+      case CORE_TYPES.BoolTrue:
+        return true;
+      case CORE_TYPES.BoolFalse:
+        return false;
+      case CORE_TYPES.Vector:
+        return this.readVector(false);
+      case CORE_TYPES.VectorDynamic:
+        return this.readVectorDynamic(false);
+      case CORE_TYPES.Null:
+        return null;
+      case CORE_TYPES.Binary:
+        return this.readBytes();
+      case CORE_TYPES.String:
+        return this.readString();
+      case CORE_TYPES.Date:
+        return this.readDate();
+      case CORE_TYPES.Int32:
+        return this.readInt32();
+      case CORE_TYPES.Int16:
+        return this.readInt16();
+      case CORE_TYPES.Int8:
+        return this.readInt8();
+      case CORE_TYPES.UInt32:
+        return this.readInt32(false);
+      case CORE_TYPES.UInt16:
+        return this.readInt16(false);
+      case CORE_TYPES.UInt8:
+        return this.readInt8(false);
+      case CORE_TYPES.Float:
+        return this.readFloat();
+      case CORE_TYPES.Double:
+        return this.readDouble();
+      case CORE_TYPES.Map:
+        return this.readMap(false);
+      case CORE_TYPES.Checksum:
+        return void this.readChecksum(false);
+      case CORE_TYPES.Structure:
+        return this.readStructure(false);
+      case CORE_TYPES.DictIndex: {
+        const idx = this.readLength();
+        return this.getDictionaryValue(idx);
+      }
+      case CORE_TYPES.DictValue: {
+        const value = this.readString();
+        this.dictionaryExtended.maybeInsert(value);
+        return value;
+      }
+      case CORE_TYPES.Repeat: {
+        const size = this.readLength();
+        this._repeat = { pool: size - 1, value: this._lastObject };
+        return this._lastObject;
+      }
     }
-    return this;
+    throw new Error(
+      `Invalid constructor = ${CORE_TYPES[constructorId] || constructorId}, offset = ${this.offset - 1}`
+    );
   }
-  writeVector(value) {
-    const length = value.length;
-    this.writeLength(length);
-    for (let i = 0; i < length; i++) {
-      if (value[i] === void 0) {
-        this.writeNull();
-      } else {
-        this.writeObject(value[i]);
+  getDictionaryValue(index) {
+    let value = null;
+    if (this.dictionary) {
+      value = this.dictionary.getValue(index);
+    }
+    if (value === null) {
+      value = this.dictionaryExtended.getValue(index);
+    }
+    return value;
+  }
+  readDictionary() {
+    const constructorId = this.readByte();
+    let key = null;
+    switch (constructorId) {
+      case CORE_TYPES.DictIndex: {
+        const idx = this.readLength();
+        key = this.getDictionaryValue(idx);
+        break;
+      }
+      case CORE_TYPES.DictValue: {
+        key = this.readString();
+        this.dictionaryExtended.maybeInsert(key);
+        break;
+      }
+      case CORE_TYPES.None: {
+        key = null;
+        break;
+      }
+      default: {
+        this.seek(-1);
       }
     }
-    return this;
-  }
-  writeMap(object) {
-    for (const key in object) {
-      if (object[key] === void 0) continue;
-      this._last = noop;
-      this.wireDictionary(key);
-      this.writeObject(object[key]);
-    }
-    this.writeByte(CORE_TYPES.None);
-    return this;
+    return key;
   }
-  wireDictionary(value) {
-    let idx = null;
-    if (this.dictionary) {
-      idx = this.dictionary.getIndex(value);
-    }
-    if (idx === null) {
-      idx = this.dictionaryExtended.getIndex(value);
+  readMap(checkConstructor = true) {
+    if (checkConstructor) {
+      this.assertConstructor(CORE_TYPES.Map);
     }
-    if (idx === null) {
-      this.dictionaryExtended.maybeInsert(value);
-      this.writeCore(CORE_TYPES.DictValue, value);
-    } else {
-      this.writeCore(CORE_TYPES.DictIndex, idx);
+    const temp = {};
+    let key = this.readDictionary();
+    while (key !== null) {
+      temp[key] = this.readObject();
+      key = this.readDictionary();
     }
-    return this;
-  }
-  writeGzip(value) {
-    const compressed = pako.deflateRaw(value, { level: 9 });
-    this.writeBytes(compressed);
-    return this;
+    return temp;
   }
-  encode(value) {
+  decode(value) {
+    this.target = value;
+    this._last = void 0;
+    this._lastObject = void 0;
+    this._repeat = void 0;
     this.offset = 0;
     this._checksumOffset = 0;
-    this._last = noop;
-    this._repeat = void 0;
-    this.target = byteArrayAllocate(256);
-    this.writeObject(value);
-    return this.getBuffer();
-  }
-  startDynamicVector() {
-    this.writeByte(CORE_TYPES.VectorDynamic);
-    return this;
+    this.length = value.length;
+    return this.readObject();
   }
-  endDynamicVector() {
-    this.writeByte(CORE_TYPES.None);
-    return this;
+  /**
+   * Reads a vector (a list) of objects.
+   */
+  readVector(checkConstructor = true) {
+    if (checkConstructor) {
+      this.assertConstructor(CORE_TYPES.Vector);
+    }
+    const count = this.readLength();
+    const temp = [];
+    for (let i = 0; i < count; i++) {
+      temp.push(this.readObject());
+    }
+    return temp;
   }
-  _writeCustom(value) {
-    const start = this.offset;
-    this.allocate(1);
-    this.offset++;
-    let edgeExt;
-    for (const ext of this.extensions.values()) {
-      if (ext.token === -1) {
-        edgeExt = ext;
-        continue;
+  /**
+   * Reads a vector (a list) of objects.
+   */
+  readVectorDynamic(checkConstructor = true) {
+    if (checkConstructor) {
+      this.assertConstructor(CORE_TYPES.VectorDynamic);
+    }
+    const temp = [];
+    let complete = false;
+    while (this.length > this.offset) {
+      const constructorId = this.readByte();
+      if (constructorId === CORE_TYPES.None) {
+        complete = true;
+        break;
       }
-      ext.encode.call(this, value);
-      const processed = start + 1 < this.offset;
-      if (processed) {
-        const end = this.offset;
-        this.offset = start;
-        this.writeByte(ext.token);
-        this.offset = end;
-        return true;
+      const ext = this.extensions.get(constructorId);
+      let value;
+      if (ext) {
+        value = ext.decode.call(this);
+      } else {
+        value = this.readCore(constructorId);
       }
+      temp.push(value);
     }
-    this.offset = start;
-    if (edgeExt) {
-      edgeExt.encode.call(this, value);
-      return start < this.offset;
+    if (!complete) {
+      const err = new Error(`DynamicVector incomplete.`);
+      err.incomplete = true;
+      Error.captureStackTrace(err, this.readDictionary);
+      throw err;
     }
-    return false;
+    this._last = temp;
+    return temp;
   }
-  writeObject(value) {
-    if (value === void 0) return this;
-    const constructorId = coreType(value);
-    if (constructorId === CORE_TYPES.None) {
-      if (this._writeCustom(value)) {
-        return this;
-      }
-      throw new TypeError(`Invalid core type of ${value}`);
+  readChecksum(checkConstructor = true) {
+    const offset = this.offset;
+    if (checkConstructor) {
+      this.assertConstructor(CORE_TYPES.Checksum);
     }
-    if (this._last === value) {
-      this.writeRepeat();
-    } else {
-      this._last = value;
-      this._repeat = void 0;
-      this.writeCore(constructorId, value);
+    const bytes = this.target.slice(this._checksumOffset, offset);
+    const checksum = this.readInt32();
+    let sum = 0;
+    for (const val of bytes) {
+      sum += val;
     }
-    return this;
+    if (checksum - sum !== 0) {
+      throw new Error(
+        `Invalid checksum = ${checksum - sum}, offset = ${offset}`
+      );
+    }
+    this._checksumOffset = this.offset;
   }
-  writeObjectGzip(value) {
-    const writer = new BinaryWriter();
-    writer.extensions = this.extensions;
-    writer.dictionary = this.dictionary;
-    writer.dictionaryExtended = this.dictionaryExtended;
-    writer.writeObject(value);
-    this.writeCore(CORE_TYPES.GZIP, writer.getBuffer());
-    return this;
+  /**
+   * Tells the current position on the stream.
+   */
+  tellPosition() {
+    return this.offset;
   }
-  writeCore(constructorId, value) {
-    if (this.withGzip && SUPPORT_COMPRESSION.has(constructorId)) {
-      this.writeObjectGzip(value);
-      return this;
-    } else if (!NO_CONSTRUCTOR.has(constructorId)) {
-      this.writeByte(constructorId);
-    }
-    switch (constructorId) {
-      case CORE_TYPES.GZIP: {
-        return this.writeGzip(value);
-      }
-      case CORE_TYPES.DictIndex: {
-        return this.writeLength(value);
-      }
-      case CORE_TYPES.DictValue: {
-        return this.writeString(value);
-      }
-      case CORE_TYPES.BoolFalse: {
-        return this.writeBool(value);
-      }
-      case CORE_TYPES.BoolTrue: {
-        return this.writeBool(value);
-      }
-      case CORE_TYPES.Date: {
-        return this.writeDate(value);
-      }
-      case CORE_TYPES.Int32: {
-        return this.writeInt32(value);
-      }
-      case CORE_TYPES.Int16: {
-        return this.writeInt16(value);
-      }
-      case CORE_TYPES.Int8: {
-        return this.writeInt8(value);
-      }
-      case CORE_TYPES.UInt32: {
-        return this.writeInt32(value, false);
-      }
-      case CORE_TYPES.UInt16: {
-        return this.writeInt16(value, false);
-      }
-      case CORE_TYPES.UInt8: {
-        return this.writeInt8(value, false);
-      }
-      case CORE_TYPES.Double: {
-        return this.writeDouble(value);
-      }
-      case CORE_TYPES.Float: {
-        return this.writeFloat(value);
-      }
-      case CORE_TYPES.Null: {
-        return this.writeNull();
-      }
-      case CORE_TYPES.String: {
-        if (value.length <= 16) {
-          this.offset--;
-          return this.wireDictionary(value);
-        }
-        return this.writeString(value);
-      }
-      case CORE_TYPES.Vector: {
-        return this.writeVector(value);
-      }
-      case CORE_TYPES.Map: {
-        return this.writeMap(value);
-      }
-    }
-    return this;
+  /**
+   * Sets the current position on the stream.
+   */
+  setPosition(position) {
+    this.offset = position;
   }
-  writeRepeat() {
-    if (!this._repeat) {
-      this.writeByte(CORE_TYPES.Repeat);
-      this._repeat = { count: 0, offset: this.offset };
-    }
-    this.offset = this._repeat.offset;
-    this._repeat.count++;
-    this.writeLength(this._repeat.count);
-    return this;
+  /**
+   * Seeks the stream position given an offset from the current position.
+   * The offset may be negative.
+   */
+  seek(offset) {
+    this.offset += offset;
   }
 }
 
-export { BinaryWriter as B, CORE_TYPES as C, MAX_BUFFER_SIZE as M, BinaryReader as a, createDictionary as c };
-//# sourceMappingURL=tl-pack.CkwM-fIb.mjs.map
+export { BinaryWriter as B, CORE_TYPES as C, MAX_BUFFER_SIZE as M, Structure as S, BinaryReader as a, createDictionary as c, defineStructure as d };
+//# sourceMappingURL=tl-pack.CxheH0R_.mjs.map