@sapphire/string-store 1.1.0-next.7c2bed20

package/dist/iife/index.global.js

@@ -0,0 +1,896 @@
+var SapphireStringStore = (function (exports) {
+  'use strict';
+
+  var __defProp = Object.defineProperty;
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+  var __privateWrapper = (obj, member, setter, getter) => ({
+    set _(value) {
+      __privateSet(obj, member, value);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  });
+
+  // src/lib/shared/_common.ts
+  function isArrayLike(object) {
+    if (!isObject(object)) return false;
+    if (Array.isArray(object)) return true;
+    if (!hasLength(object)) return false;
+    if (!isValidLength(object.length)) return false;
+    return object.length === 0 || object.length - 1 in object;
+  }
+  __name(isArrayLike, "isArrayLike");
+  function isObject(item) {
+    return typeof item === "object" && item !== null;
+  }
+  __name(isObject, "isObject");
+  function hasLength(item) {
+    return "length" in item && typeof item.length === "number";
+  }
+  __name(hasLength, "hasLength");
+  function isValidLength(length) {
+    return Number.isSafeInteger(length) && length >= 0 && length < 2147483648;
+  }
+  __name(isValidLength, "isValidLength");
+
+  // src/lib/shared/Pointer.ts
+  var _value;
+  var _Pointer = class _Pointer {
+    constructor() {
+      __privateAdd(this, _value, 0);
+    }
+    get value() {
+      return __privateGet(this, _value);
+    }
+    add(value) {
+      const added = __privateGet(this, _value) + value;
+      if (!isValidLength(added)) {
+        throw new RangeError(`The pointer value cannot be an invalid length value`);
+      }
+      __privateSet(this, _value, added);
+      return this;
+    }
+    static from(pointer) {
+      if (pointer instanceof _Pointer) {
+        return pointer;
+      }
+      const instance = new _Pointer();
+      instance.add(Number(pointer));
+      return instance;
+    }
+  };
+  _value = new WeakMap();
+  __name(_Pointer, "Pointer");
+  var Pointer = _Pointer;
+
+  // src/lib/types/Array.ts
+  function ArrayType(type) {
+    return {
+      serialize(buffer, values) {
+        if (!isArrayLike(values)) {
+          throw new TypeError(`Expected an array, got ${values}`);
+        }
+        buffer.writeInt16(values.length);
+        for (const value of values) {
+          type.serialize(buffer, value);
+        }
+      },
+      deserialize(buffer, pointer) {
+        const length = buffer.readInt16(pointer);
+        const value = [];
+        for (let i = 0; i < length; i++) {
+          value.push(type.deserialize(buffer, pointer));
+        }
+        return value;
+      },
+      BIT_SIZE: null
+    };
+  }
+  __name(ArrayType, "ArrayType");
+
+  // src/lib/types/BigInt32.ts
+  var BigInt32Type = {
+    serialize(buffer, value) {
+      buffer.writeBigInt32(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readBigInt32(pointer);
+    },
+    BIT_SIZE: 32
+  };
+
+  // src/lib/types/BigInt64.ts
+  var BigInt64Type = {
+    serialize(buffer, value) {
+      buffer.writeBigInt64(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readBigInt64(pointer);
+    },
+    BIT_SIZE: 64
+  };
+
+  // src/lib/types/Bit.ts
+  var BitType = {
+    serialize(buffer, value) {
+      buffer.writeBit(value & 1);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readBit(pointer);
+    },
+    BIT_SIZE: 1
+  };
+
+  // src/lib/types/Boolean.ts
+  var BooleanType = {
+    serialize(buffer, value) {
+      buffer.writeBit(Number(value));
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readBit(pointer) === 1;
+    },
+    BIT_SIZE: 1
+  };
+
+  // src/lib/types/FixedLengthArray.ts
+  function FixedLengthArrayType(type, length) {
+    return {
+      serialize(buffer, values) {
+        if (!isArrayLike(values) || values.length !== length) {
+          throw new TypeError(`Expected array of length ${length}, got ${values.length}`);
+        }
+        for (let i = 0; i < length; i++) {
+          type.serialize(buffer, values[i]);
+        }
+      },
+      deserialize(buffer, pointer) {
+        const value = [];
+        for (let i = 0; i < length; i++) {
+          value.push(type.deserialize(buffer, pointer));
+        }
+        return value;
+      },
+      BIT_SIZE: typeof type.BIT_SIZE === "number" ? type.BIT_SIZE * length : null
+    };
+  }
+  __name(FixedLengthArrayType, "FixedLengthArrayType");
+
+  // src/lib/types/Float32.ts
+  var Float32Type = {
+    serialize(buffer, value) {
+      buffer.writeFloat32(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readFloat32(pointer);
+    },
+    BIT_SIZE: 32
+  };
+
+  // src/lib/types/Float64.ts
+  var Float64Type = {
+    serialize(buffer, value) {
+      buffer.writeFloat64(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readFloat64(pointer);
+    },
+    BIT_SIZE: 64
+  };
+
+  // src/lib/types/Int16.ts
+  var Int16Type = {
+    serialize(buffer, value) {
+      buffer.writeInt16(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt16(pointer);
+    },
+    BIT_SIZE: 16
+  };
+
+  // src/lib/types/Int2.ts
+  var Int2Type = {
+    serialize(buffer, value) {
+      buffer.writeInt2(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt2(pointer);
+    },
+    BIT_SIZE: 2
+  };
+
+  // src/lib/types/Int32.ts
+  var Int32Type = {
+    serialize(buffer, value) {
+      buffer.writeInt32(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt32(pointer);
+    },
+    BIT_SIZE: 32
+  };
+
+  // src/lib/types/Int4.ts
+  var Int4Type = {
+    serialize(buffer, value) {
+      buffer.writeInt4(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt4(pointer);
+    },
+    BIT_SIZE: 4
+  };
+
+  // src/lib/types/Int64.ts
+  var Int64Type = {
+    serialize(buffer, value) {
+      buffer.writeInt64(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt64(pointer);
+    },
+    BIT_SIZE: 64
+  };
+
+  // src/lib/types/Int8.ts
+  var Int8Type = {
+    serialize(buffer, value) {
+      buffer.writeInt8(value);
+    },
+    deserialize(buffer, pointer) {
+      return buffer.readInt8(pointer);
+    },
+    BIT_SIZE: 8
+  };
+
+  // src/lib/types/Snowflake.ts
+  var SnowflakeType = {
+    serialize(buffer, value) {
+      buffer.writeBigInt64(BigInt(value));
+    },
+    deserialize(buffer, offset) {
+      return buffer.readBigInt64(offset);
+    },
+    BIT_SIZE: 64
+  };
+
+  // src/lib/types/String.ts
+  var encoder = new TextEncoder();
+  var decoder = new TextDecoder();
+  var StringType = {
+    serialize(buffer, value) {
+      const encoded = encoder.encode(value);
+      buffer.writeInt16(encoded.length);
+      for (const byte of encoded) {
+        buffer.writeInt8(byte);
+      }
+    },
+    deserialize(buffer, pointer) {
+      const length = buffer.readInt16(pointer);
+      const bytes = new Uint8Array(length);
+      for (let i = 0; i < length; i++) {
+        bytes[i] = buffer.readInt8(pointer);
+      }
+      return decoder.decode(bytes);
+    },
+    BIT_SIZE: null
+  };
+
+  // src/lib/schema/Schema.ts
+  var _id, _types, _bitSize, _Schema_instances, addType_fn;
+  var _Schema = class _Schema {
+    /**
+     * Creates a new schema.
+     *
+     * @param id The id of the schema
+     */
+    constructor(id) {
+      __privateAdd(this, _Schema_instances);
+      __privateAdd(this, _id);
+      __privateAdd(this, _types, /* @__PURE__ */ new Map());
+      __privateAdd(this, _bitSize, 0);
+      __privateSet(this, _id, id);
+    }
+    /**
+     * The id of the schema.
+     */
+    get id() {
+      return __privateGet(this, _id);
+    }
+    /**
+     * The total bit size of the schema.
+     *
+     * @remarks
+     *
+     * If any of the entries have a bit size of `null`, the bit size of the
+     * schema will also be `null`.
+     */
+    get bitSize() {
+      return __privateGet(this, _bitSize);
+    }
+    /**
+     * Get a property from the schema.
+     *
+     * @param name The name of the property
+     * @returns The specified property
+     *
+     * @remarks
+     *
+     * If the property does not exist, an error will be thrown.
+     */
+    get(name) {
+      const type = __privateGet(this, _types).get(name);
+      if (!type) throw new Error(`Schema with id ${__privateGet(this, _id)} does not have a property with name "${name}"`);
+      return type;
+    }
+    /**
+     * Serialize a value into a buffer.
+     *
+     * @param buffer The buffer to serialize
+     * @param value The value to serialize into the buffer
+     *
+     * @remarks
+     *
+     * The schema's ID is written to the buffer first, followed by each property
+     * in the schema.
+     */
+    serialize(buffer, value) {
+      buffer.writeInt16(__privateGet(this, _id));
+      for (const [name, type] of this) {
+        type.serialize(buffer, value[name]);
+      }
+    }
+    /**
+     * Deserialize a value from a buffer.
+     *
+     * @param buffer The buffer to deserialize
+     * @param pointer The pointer to where the buffer should be read from
+     * @returns The deserialized value
+     *
+     * @remarks
+     *
+     * Unlike {@link Schema.serialize}, this method does not read the schema's ID
+     * from the buffer, that is reserved for the {@link SchemaStore}.
+     */
+    deserialize(buffer, pointer) {
+      const ptr = Pointer.from(pointer);
+      const result = /* @__PURE__ */ Object.create(null);
+      for (const [name, type] of this) {
+        result[name] = type.deserialize(buffer, ptr);
+      }
+      return result;
+    }
+    /**
+     * Adds an array property to the schema.
+     *
+     * @seealso {@link Schema.fixedLengthArray} for a fixed length array
+     *
+     * @param name The name of the property
+     * @param type The type of the entry in the array
+     * @returns The modified schema
+     */
+    array(name, type) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, ArrayType(type));
+    }
+    /**
+     * Adds a fixed length array property to the schema.
+     *
+     * @seealso {@link Schema.array} for a dynamic length array
+     *
+     * @param name The name of the property
+     * @param type The type of the entry in the array
+     * @param length The length of the array
+     * @returns The modified schema
+     */
+    fixedLengthArray(name, type, length) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, FixedLengthArrayType(type, length));
+    }
+    /**
+     * Adds a string property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    string(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, StringType);
+    }
+    /**
+     * Adds a boolean property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    boolean(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, BooleanType);
+    }
+    /**
+     * Adds a bit property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    bit(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, BitType);
+    }
+    /**
+     * Adds a 2-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int2(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int2Type);
+    }
+    /**
+     * Adds a 4-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int4(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int4Type);
+    }
+    /**
+     * Adds a 8-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int8(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int8Type);
+    }
+    /**
+     * Adds a 16-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int16(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int16Type);
+    }
+    /**
+     * Adds a 32-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int32(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int32Type);
+    }
+    /**
+     * Adds a 64-bit integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    int64(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Int64Type);
+    }
+    /**
+     * Adds a 32-bit big integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    bigInt32(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, BigInt32Type);
+    }
+    /**
+     * Adds a 64-bit big integer property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    bigInt64(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, BigInt64Type);
+    }
+    /**
+     * Adds a 32-bit floating point number property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    float32(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Float32Type);
+    }
+    /**
+     * Adds a 64-bit floating point number property to the schema.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    float64(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, Float64Type);
+    }
+    /**
+     * Adds a 64-bit big integer property to the schema, similar to {@link Schema.bigInt64}.
+     *
+     * @param name The name of the property
+     * @returns The modified schema
+     */
+    snowflake(name) {
+      return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, SnowflakeType);
+    }
+    /**
+     * Iterates over the schema's property names.
+     *
+     * @returns An iterator for the schema's property names
+     */
+    keys() {
+      return __privateGet(this, _types).keys();
+    }
+    /**
+     * Iterates over the schema's property values
+     *
+     * @returns An iterator for the schema's property values
+     */
+    values() {
+      return __privateGet(this, _types).values();
+    }
+    /**
+     * Iterates over the schema's property entries
+     *
+     * @returns An iterator for the schema's property entries
+     */
+    entries() {
+      return __privateGet(this, _types).entries();
+    }
+    /**
+     * Iterates over the schema's property entries
+     *
+     * @returns An iterator for the schema's property entries
+     */
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+  _id = new WeakMap();
+  _types = new WeakMap();
+  _bitSize = new WeakMap();
+  _Schema_instances = new WeakSet();
+  addType_fn = /* @__PURE__ */ __name(function(name, type) {
+    if (__privateGet(this, _types).has(name)) {
+      throw new Error(`Schema with id ${__privateGet(this, _id)} already has a property with name "${name}"`);
+    }
+    __privateGet(this, _types).set(name, type);
+    if (type.BIT_SIZE === null) {
+      __privateSet(this, _bitSize, null);
+    } else if (__privateGet(this, _bitSize) !== null) {
+      __privateSet(this, _bitSize, __privateGet(this, _bitSize) + type.BIT_SIZE);
+    }
+    return this;
+  }, "#addType");
+  __name(_Schema, "Schema");
+  var Schema = _Schema;
+
+  // src/lib/UnalignedUint16Array.ts
+  var Converter8 = new Uint8Array(8);
+  var ConverterFloat = new Float32Array(Converter8.buffer);
+  var ConverterDouble = new Float64Array(Converter8.buffer);
+  var _buffer, _bitLength, _wordIndex, _wordLength, _UnalignedUint16Array_instances, readBit_fn, readByte_fn, writeBit_fn;
+  var _UnalignedUint16Array = class _UnalignedUint16Array {
+    constructor(maxLength) {
+      __privateAdd(this, _UnalignedUint16Array_instances);
+      __privateAdd(this, _buffer);
+      __privateAdd(this, _bitLength, 0);
+      __privateAdd(this, _wordIndex, 0);
+      __privateAdd(this, _wordLength, 0);
+      __privateSet(this, _buffer, new Uint16Array(maxLength));
+    }
+    get maxLength() {
+      return __privateGet(this, _buffer).length;
+    }
+    get maxBitLength() {
+      return __privateGet(this, _buffer).length * 16;
+    }
+    get length() {
+      return __privateGet(this, _wordLength);
+    }
+    get bitLength() {
+      return __privateGet(this, _bitLength);
+    }
+    writeBit(value) {
+      __privateMethod(this, _UnalignedUint16Array_instances, writeBit_fn).call(this, value);
+    }
+    writeInt2(value) {
+      this.writeBit(value & 1);
+      this.writeBit(value >> 1);
+    }
+    writeInt4(value) {
+      this.writeInt2(value & 3);
+      this.writeInt2(value >> 2);
+    }
+    writeInt8(value) {
+      this.writeInt4(value & 15);
+      this.writeInt4(value >> 4);
+    }
+    writeInt16(value) {
+      this.writeInt8(value & 255);
+      this.writeInt8(value >> 8);
+    }
+    writeInt32(value) {
+      this.writeInt16(value & 65535);
+      this.writeInt16(value >> 16);
+    }
+    writeInt64(value) {
+      this.writeBigInt64(BigInt(value));
+    }
+    writeBigInt32(value) {
+      this.writeInt16(Number(value & 0xffffn));
+      this.writeInt16(Number(value >> 16n));
+    }
+    writeBigInt64(value) {
+      this.writeInt32(Number(value & 0xffffffffn));
+      this.writeInt32(Number(value >> 32n));
+    }
+    writeFloat32(value) {
+      ConverterFloat[0] = value;
+      this.writeInt8(Converter8[0]);
+      this.writeInt8(Converter8[1]);
+      this.writeInt8(Converter8[2]);
+      this.writeInt8(Converter8[3]);
+    }
+    writeFloat64(value) {
+      ConverterDouble[0] = value;
+      this.writeInt8(Converter8[0]);
+      this.writeInt8(Converter8[1]);
+      this.writeInt8(Converter8[2]);
+      this.writeInt8(Converter8[3]);
+      this.writeInt8(Converter8[4]);
+      this.writeInt8(Converter8[5]);
+      this.writeInt8(Converter8[6]);
+      this.writeInt8(Converter8[7]);
+    }
+    readBit(offset) {
+      const ptr = Pointer.from(offset);
+      return __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr);
+    }
+    readInt2(offset) {
+      const ptr = Pointer.from(offset);
+      return __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 1;
+    }
+    readInt4(offset) {
+      const ptr = Pointer.from(offset);
+      return __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 1 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 2 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 3;
+    }
+    readInt8(offset) {
+      const ptr = Pointer.from(offset);
+      return __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+    }
+    readInt16(offset) {
+      const ptr = Pointer.from(offset);
+      return __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr) | __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr) << 8;
+    }
+    readInt32(offset) {
+      return Number(this.readBigInt32(offset));
+    }
+    readInt64(offset) {
+      return Number(this.readBigInt64(offset));
+    }
+    readBigInt32(offset) {
+      const ptr = Pointer.from(offset);
+      return BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 8n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 16n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 24n;
+    }
+    readBigInt64(offset) {
+      const ptr = Pointer.from(offset);
+      return BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 8n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 16n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 24n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 32n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 40n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 48n | BigInt(__privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr)) << 56n;
+    }
+    readFloat32(offset) {
+      const ptr = Pointer.from(offset);
+      Converter8[0] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[1] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[2] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[3] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      return ConverterFloat[0];
+    }
+    readFloat64(offset) {
+      const ptr = Pointer.from(offset);
+      Converter8[0] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[1] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[2] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[3] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[4] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[5] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[6] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      Converter8[7] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+      return ConverterDouble[0];
+    }
+    toString() {
+      let result = "";
+      for (let i = 0; i < this.length; i++) {
+        result += String.fromCharCode(__privateGet(this, _buffer)[i]);
+      }
+      return result;
+    }
+    toArray() {
+      return __privateGet(this, _buffer).slice(0, this.length);
+    }
+    static from(value) {
+      if (value instanceof _UnalignedUint16Array) return value;
+      const buffer = new _UnalignedUint16Array(value.length);
+      for (let i = 0; i < value.length; i++) {
+        __privateGet(buffer, _buffer)[i] = value.charCodeAt(i);
+      }
+      __privateSet(buffer, _bitLength, value.length << 4);
+      return buffer;
+    }
+  };
+  _buffer = new WeakMap();
+  _bitLength = new WeakMap();
+  _wordIndex = new WeakMap();
+  _wordLength = new WeakMap();
+  _UnalignedUint16Array_instances = new WeakSet();
+  readBit_fn = /* @__PURE__ */ __name(function(pointer) {
+    const bitOffset = pointer.value;
+    const index = bitOffset >> 4;
+    const bitIndex = bitOffset & 15;
+    pointer.add(1);
+    return __privateGet(this, _buffer)[index] >> bitIndex & 1;
+  }, "#readBit");
+  readByte_fn = /* @__PURE__ */ __name(function(ptr) {
+    return __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 1 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 2 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 3 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 4 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 5 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 6 | __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr) << 7;
+  }, "#readByte");
+  writeBit_fn = /* @__PURE__ */ __name(function(value) {
+    if (__privateGet(this, _wordIndex) === this.maxLength) {
+      throw new RangeError(`The buffer is full`);
+    }
+    if (value) {
+      const index = __privateGet(this, _wordIndex);
+      const bitIndex = this.bitLength & 15;
+      __privateGet(this, _buffer)[index] |= 1 << bitIndex;
+    }
+    if ((__privateGet(this, _bitLength) & 15) === 0) __privateWrapper(this, _wordLength)._++;
+    __privateWrapper(this, _bitLength)._++;
+    if ((__privateGet(this, _bitLength) & 15) === 0) __privateWrapper(this, _wordIndex)._++;
+  }, "#writeBit");
+  __name(_UnalignedUint16Array, "UnalignedUint16Array");
+  var UnalignedUint16Array = _UnalignedUint16Array;
+
+  // src/lib/schema/SchemaStore.ts
+  var _schemas;
+  var _SchemaStore = class _SchemaStore {
+    /**
+     * Creates a new schema store
+     *
+     * @param defaultMaximumArrayLength The default maximum array length for schemas
+     */
+    constructor(defaultMaximumArrayLength = 100) {
+      /**
+       * The default maximum array length for schemas
+       */
+      __publicField(this, "defaultMaximumArrayLength");
+      __privateAdd(this, _schemas, /* @__PURE__ */ new Map());
+      this.defaultMaximumArrayLength = defaultMaximumArrayLength;
+    }
+    /**
+     * Adds a schema to the store
+     *
+     * @param schema The schema to add to the store
+     * @returns The modified store
+     *
+     * @remarks
+     *
+     * An error will be thrown if a schema with the same id already exists in the store.
+     */
+    add(schema) {
+      if (__privateGet(this, _schemas).has(schema.id)) {
+        throw new Error(`Schema with id ${schema.id} already exists`);
+      }
+      __privateGet(this, _schemas).set(schema.id, schema);
+      return this;
+    }
+    /**
+     * Gets a schema from the store
+     *
+     * @param id The id of the schema to get
+     * @returns The schema with the given id
+     *
+     * @remarks
+     *
+     * An error will be thrown if a schema with the given id does not exist in the store.
+     */
+    get(id) {
+      const schema = __privateGet(this, _schemas).get(id);
+      if (!schema) throw new Error(`Schema with id ${id} does not exist`);
+      return schema;
+    }
+    /**
+     * Serializes a value using the schema with the given id
+     *
+     * @param id The id of the schema to use for serialization
+     * @param value The value to serialize
+     * @returns The serialized buffer
+     */
+    serialize(id, value) {
+      const schema = this.get(id);
+      const buffer = new UnalignedUint16Array(schema.bitSize ?? this.defaultMaximumArrayLength);
+      schema.serialize(buffer, value);
+      return buffer;
+    }
+    /**
+     * Deserializes a buffer
+     *
+     * @param buffer The buffer to deserialize
+     * @returns The resolved value, including the id of the schema used for deserialization
+     */
+    deserialize(buffer) {
+      buffer = UnalignedUint16Array.from(buffer);
+      const pointer = new Pointer();
+      const id = buffer.readInt16(pointer);
+      const schema = this.get(id);
+      return { id, data: schema.deserialize(buffer, pointer) };
+    }
+    /**
+     * Iterates over the stores's schema identifiers.
+     *
+     * @returns An iterator for the stores's schema identifiers
+     */
+    keys() {
+      return __privateGet(this, _schemas).keys();
+    }
+    /**
+     * Iterates over the stores's schemas.
+     *
+     * @returns An iterator for the stores's schemas
+     */
+    values() {
+      return __privateGet(this, _schemas).values();
+    }
+    /**
+     * Iterates over the stores's schema entries.
+     *
+     * @returns An iterator for the stores's schema entries
+     */
+    entries() {
+      return __privateGet(this, _schemas).entries();
+    }
+    /**
+     * Iterates over the stores's schema entries.
+     *
+     * @returns An iterator for the stores's schema entries
+     */
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+  _schemas = new WeakMap();
+  __name(_SchemaStore, "SchemaStore");
+  var SchemaStore = _SchemaStore;
+
+  exports.ArrayType = ArrayType;
+  exports.BigInt32Type = BigInt32Type;
+  exports.BigInt64Type = BigInt64Type;
+  exports.BitType = BitType;
+  exports.BooleanType = BooleanType;
+  exports.FixedLengthArrayType = FixedLengthArrayType;
+  exports.Float32Type = Float32Type;
+  exports.Float64Type = Float64Type;
+  exports.Int16Type = Int16Type;
+  exports.Int2Type = Int2Type;
+  exports.Int32Type = Int32Type;
+  exports.Int4Type = Int4Type;
+  exports.Int64Type = Int64Type;
+  exports.Int8Type = Int8Type;
+  exports.Pointer = Pointer;
+  exports.Schema = Schema;
+  exports.SchemaStore = SchemaStore;
+  exports.SnowflakeType = SnowflakeType;
+  exports.StringType = StringType;
+  exports.UnalignedUint16Array = UnalignedUint16Array;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=index.global.js.map
+//# sourceMappingURL=index.global.js.map