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

package/dist/esm/index.mjs

@@ -0,0 +1,870 @@
+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;
+
+export { ArrayType, BigInt32Type, BigInt64Type, BitType, BooleanType, FixedLengthArrayType, Float32Type, Float64Type, Int16Type, Int2Type, Int32Type, Int4Type, Int64Type, Int8Type, Pointer, Schema, SchemaStore, SnowflakeType, StringType, UnalignedUint16Array };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map