@sapphire/string-store 1.0.0

package/dist/esm/index.mjs

@@ -0,0 +1,1211 @@
+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.readUint16(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/BigUint32.ts
+var BigUint32Type = {
+  serialize(buffer, value) {
+    buffer.writeBigInt32(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readBigUint32(pointer);
+  },
+  BIT_SIZE: 32
+};
+
+// src/lib/types/BigUint64.ts
+var BigUint64Type = {
+  serialize(buffer, value) {
+    buffer.writeBigInt64(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readBigUint64(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.readBigUint64(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/types/Uint16.ts
+var Uint16Type = {
+  serialize(buffer, value) {
+    buffer.writeInt16(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint16(pointer);
+  },
+  BIT_SIZE: 16
+};
+
+// src/lib/types/Uint2.ts
+var Uint2Type = {
+  serialize(buffer, value) {
+    buffer.writeInt2(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint2(pointer);
+  },
+  BIT_SIZE: 2
+};
+
+// src/lib/types/Uint32.ts
+var Uint32Type = {
+  serialize(buffer, value) {
+    buffer.writeInt32(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint32(pointer);
+  },
+  BIT_SIZE: 32
+};
+
+// src/lib/types/Uint4.ts
+var Uint4Type = {
+  serialize(buffer, value) {
+    buffer.writeInt4(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint4(pointer);
+  },
+  BIT_SIZE: 4
+};
+
+// src/lib/types/Uint64.ts
+var Uint64Type = {
+  serialize(buffer, value) {
+    buffer.writeInt64(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint64(pointer);
+  },
+  BIT_SIZE: 64
+};
+
+// src/lib/types/Uint8.ts
+var Uint8Type = {
+  serialize(buffer, value) {
+    buffer.writeInt8(value);
+  },
+  deserialize(buffer, pointer) {
+    return buffer.readUint8(pointer);
+  },
+  BIT_SIZE: 8
+};
+
+// src/lib/types/index.ts
+var t = {
+  array: ArrayType,
+  bigInt32: BigInt32Type,
+  bigInt64: BigInt64Type,
+  bigUint32: BigUint32Type,
+  bigUint64: BigUint64Type,
+  bit: BitType,
+  boolean: BooleanType,
+  fixedLengthArray: FixedLengthArrayType,
+  float32: Float32Type,
+  float64: Float64Type,
+  int16: Int16Type,
+  int2: Int2Type,
+  int32: Int32Type,
+  int4: Int4Type,
+  int64: Int64Type,
+  int8: Int8Type,
+  snowflake: SnowflakeType,
+  string: StringType,
+  uint16: Uint16Type,
+  uint2: Uint2Type,
+  uint32: Uint32Type,
+  uint4: Uint4Type,
+  uint64: Uint64Type,
+  uint8: Uint8Type
+};
+
+// 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, t.array(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, t.fixedLengthArray(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, t.string);
+  }
+  /**
+   * 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, t.boolean);
+  }
+  /**
+   * 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, t.bit);
+  }
+  /**
+   * Adds a 2-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -2 to 1, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int2(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int2);
+  }
+  /**
+   * Adds a 2-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 3, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint2(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint2);
+  }
+  /**
+   * Adds a 4-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -8 to 7, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int4(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int4);
+  }
+  /**
+   * Adds a 4-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 15, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint4(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint4);
+  }
+  /**
+   * Adds a 8-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -128 to 127, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int8(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int8);
+  }
+  /**
+   * Adds a 8-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 255, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint8(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint8);
+  }
+  /**
+   * Adds a 16-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -32768 to 32767, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int16(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int16);
+  }
+  /**
+   * Adds a 16-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 65535, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint16(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint16);
+  }
+  /**
+   * Adds a 32-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -2_147_483_648 to 2_147_483_647, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int32(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int32);
+  }
+  /**
+   * Adds a 32-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 4_294_967_295, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint32(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint32);
+  }
+  /**
+   * Adds a 64-bit integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -9_223_372_036_854_775_808 to 9_223_372_036_854_775_807, inclusive.
+   *
+   * However, it may run into precision issues past the range of `-9_007_199_254_740_991` to `9_007_199_254_740_991`
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  int64(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.int64);
+  }
+  /**
+   * Adds a 64-bit unsigned integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0 to 18_446_744_073_709_551_615, inclusive.
+   *
+   * However, it may run into precision issues past `9_007_199_254_740_991`
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  uint64(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.uint64);
+  }
+  /**
+   * Adds a 32-bit big integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -2_147_483_648n to 2_147_483_647n, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  bigInt32(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.bigInt32);
+  }
+  /**
+   * Adds a 32-bit big integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0n to 4_294_967_295n, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  bigUint32(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.bigUint32);
+  }
+  /**
+   * Adds a 64-bit big integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -9_223_372_036_854_775_808n to 9_223_372_036_854_775_807n, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  bigInt64(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.bigInt64);
+  }
+  /**
+   * Adds a 64-bit big integer property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from 0n to 18_446_744_073_709_551_615n, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  bigUint64(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.bigUint64);
+  }
+  /**
+   * Adds a 32-bit floating point number property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -3.4028234663852886e+38 to 3.4028234663852886e+38, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  float32(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.float32);
+  }
+  /**
+   * Adds a 64-bit floating point number property to the schema.
+   *
+   * @remarks
+   *
+   * The range of values is from -1.7976931348623157e+308 to 1.7976931348623157e+308, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  float64(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.float64);
+  }
+  /**
+   * Adds a 64-bit big integer property to the schema, similar to {@link Schema.bigUint64}.
+   *
+   * @remarks
+   *
+   * The range of values is from 0n to 18_446_744_073_709_551_615n, inclusive.
+   *
+   * @param name The name of the property
+   * @returns The modified schema
+   */
+  snowflake(name) {
+    return __privateMethod(this, _Schema_instances, addType_fn).call(this, name, t.snowflake);
+  }
+  /**
+   * 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 ConverterUint8 = new Uint8Array(8);
+var ConverterUint16 = new Uint16Array(ConverterUint8.buffer);
+var ConverterUint32 = new Uint32Array(ConverterUint8.buffer);
+var ConverterUint64 = new BigUint64Array(ConverterUint8.buffer);
+var ConverterInt32 = new Int32Array(ConverterUint8.buffer);
+var ConverterInt64 = new BigInt64Array(ConverterUint8.buffer);
+var ConverterFloat = new Float32Array(ConverterUint8.buffer);
+var ConverterDouble = new Float64Array(ConverterUint8.buffer);
+var _buffer, _bitLength, _wordIndex, _wordLength, _UnalignedUint16Array_instances, readBit_fn, readByte_fn, bufferRead16_fn, bufferRead32_fn, bufferRead64_fn, writeBit_fn, bufferWrite16_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) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, value);
+  }
+  writeInt32(value) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, value);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, value >> 16);
+  }
+  writeInt64(value) {
+    this.writeBigInt64(BigInt(value));
+  }
+  writeBigInt32(value) {
+    ConverterInt64[0] = value;
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[0]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[1]);
+  }
+  writeBigInt64(value) {
+    ConverterInt64[0] = value;
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[0]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[1]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[2]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[3]);
+  }
+  writeFloat32(value) {
+    ConverterFloat[0] = value;
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[0]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[1]);
+  }
+  writeFloat64(value) {
+    ConverterDouble[0] = value;
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[0]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[1]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[2]);
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferWrite16_fn).call(this, ConverterUint16[3]);
+  }
+  readBit(offset) {
+    const ptr = Pointer.from(offset);
+    return __privateMethod(this, _UnalignedUint16Array_instances, readBit_fn).call(this, ptr);
+  }
+  readInt2(offset) {
+    return this.readUint2(offset) << 30 >> 30;
+  }
+  readUint2(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) {
+    return this.readUint4(offset) << 28 >> 28;
+  }
+  readUint4(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) {
+    return this.readUint8(offset) << 24 >> 24;
+  }
+  readUint8(offset) {
+    const ptr = Pointer.from(offset);
+    return __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  }
+  readInt16(offset) {
+    return this.readUint16(offset) << 16 >> 16;
+  }
+  readUint16(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead16_fn).call(this, Pointer.from(offset));
+    return ConverterUint16[0];
+  }
+  readInt32(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead32_fn).call(this, Pointer.from(offset));
+    return ConverterInt32[0];
+  }
+  readUint32(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead32_fn).call(this, Pointer.from(offset));
+    return ConverterUint32[0];
+  }
+  readInt64(offset) {
+    return Number(this.readBigInt64(offset));
+  }
+  readUint64(offset) {
+    return Number(this.readBigUint64(offset));
+  }
+  readBigInt32(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead32_fn).call(this, Pointer.from(offset));
+    return BigInt(ConverterInt32[0]);
+  }
+  readBigUint32(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead32_fn).call(this, Pointer.from(offset));
+    return BigInt(ConverterUint32[0]);
+  }
+  readBigInt64(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead64_fn).call(this, Pointer.from(offset));
+    return ConverterInt64[0];
+  }
+  readBigUint64(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead64_fn).call(this, Pointer.from(offset));
+    return ConverterUint64[0];
+  }
+  readFloat32(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead32_fn).call(this, Pointer.from(offset));
+    return ConverterFloat[0];
+  }
+  readFloat64(offset) {
+    __privateMethod(this, _UnalignedUint16Array_instances, bufferRead64_fn).call(this, Pointer.from(offset));
+    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");
+bufferRead16_fn = /* @__PURE__ */ __name(function(ptr) {
+  ConverterUint8[0] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[1] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+}, "#bufferRead16");
+bufferRead32_fn = /* @__PURE__ */ __name(function(ptr) {
+  ConverterUint8[0] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[1] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[2] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[3] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+}, "#bufferRead32");
+bufferRead64_fn = /* @__PURE__ */ __name(function(ptr) {
+  ConverterUint8[0] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[1] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[2] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[3] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[4] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[5] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[6] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+  ConverterUint8[7] = __privateMethod(this, _UnalignedUint16Array_instances, readByte_fn).call(this, ptr);
+}, "#bufferRead64");
+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");
+bufferWrite16_fn = /* @__PURE__ */ __name(function(value) {
+  const wordIndex = __privateGet(this, _wordIndex);
+  const bitIndex = this.bitLength & 15;
+  if (wordIndex + (bitIndex === 0 ? 0 : 1) === this.maxLength) {
+    throw new RangeError(`The buffer is full`);
+  }
+  if (bitIndex === 0) {
+    __privateGet(this, _buffer)[wordIndex] = value;
+  } else {
+    value &= 65535;
+    __privateGet(this, _buffer)[wordIndex] |= value << bitIndex;
+    __privateGet(this, _buffer)[wordIndex + 1] = value >> 16 - bitIndex;
+  }
+  __privateSet(this, _bitLength, __privateGet(this, _bitLength) + 16);
+  __privateWrapper(this, _wordIndex)._++;
+  __privateWrapper(this, _wordLength)._++;
+}, "#bufferWrite16");
+__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;
+
+// src/lib/utilities.ts
+function toUTF16(buffer) {
+  let result = "";
+  for (const value of new Uint16Array(buffer.buffer)) {
+    result += String.fromCharCode(value);
+  }
+  return result;
+}
+__name(toUTF16, "toUTF16");
+function fromUTF16(buffer) {
+  const result = new Uint16Array(buffer.length);
+  for (let i = 0; i < buffer.length; i++) {
+    result[i] = buffer.charCodeAt(i);
+  }
+  return result;
+}
+__name(fromUTF16, "fromUTF16");
+
+export { ArrayType, BigInt32Type, BigInt64Type, BigUint32Type, BigUint64Type, BitType, BooleanType, FixedLengthArrayType, Float32Type, Float64Type, Int16Type, Int2Type, Int32Type, Int4Type, Int64Type, Int8Type, Pointer, Schema, SchemaStore, SnowflakeType, StringType, Uint16Type, Uint2Type, Uint32Type, Uint4Type, Uint64Type, Uint8Type, UnalignedUint16Array, fromUTF16, t, toUTF16 };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map