FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@solana/codecs-numbers/dist/index.browser.cjs

@@ -0,0 +1,326 @@
+'use strict';
+
+var errors = require('@solana/errors');
+var codecsCore = require('@solana/codecs-core');
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return codecsCore.createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return codecsCore.createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      codecsCore.assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      codecsCore.assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(codecsCore.toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => codecsCore.combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => codecsCore.combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => codecsCore.combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => codecsCore.combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => codecsCore.combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => codecsCore.combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => codecsCore.combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => codecsCore.createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => codecsCore.createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => codecsCore.combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => codecsCore.combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => codecsCore.combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => codecsCore.combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => codecsCore.combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => codecsCore.combineCodec(getU8Encoder(), getU8Decoder());
+
+exports.Endian = Endian;
+exports.assertNumberIsBetweenForCodec = assertNumberIsBetweenForCodec;
+exports.getF32Codec = getF32Codec;
+exports.getF32Decoder = getF32Decoder;
+exports.getF32Encoder = getF32Encoder;
+exports.getF64Codec = getF64Codec;
+exports.getF64Decoder = getF64Decoder;
+exports.getF64Encoder = getF64Encoder;
+exports.getI128Codec = getI128Codec;
+exports.getI128Decoder = getI128Decoder;
+exports.getI128Encoder = getI128Encoder;
+exports.getI16Codec = getI16Codec;
+exports.getI16Decoder = getI16Decoder;
+exports.getI16Encoder = getI16Encoder;
+exports.getI32Codec = getI32Codec;
+exports.getI32Decoder = getI32Decoder;
+exports.getI32Encoder = getI32Encoder;
+exports.getI64Codec = getI64Codec;
+exports.getI64Decoder = getI64Decoder;
+exports.getI64Encoder = getI64Encoder;
+exports.getI8Codec = getI8Codec;
+exports.getI8Decoder = getI8Decoder;
+exports.getI8Encoder = getI8Encoder;
+exports.getShortU16Codec = getShortU16Codec;
+exports.getShortU16Decoder = getShortU16Decoder;
+exports.getShortU16Encoder = getShortU16Encoder;
+exports.getU128Codec = getU128Codec;
+exports.getU128Decoder = getU128Decoder;
+exports.getU128Encoder = getU128Encoder;
+exports.getU16Codec = getU16Codec;
+exports.getU16Decoder = getU16Decoder;
+exports.getU16Encoder = getU16Encoder;
+exports.getU32Codec = getU32Codec;
+exports.getU32Decoder = getU32Decoder;
+exports.getU32Encoder = getU32Encoder;
+exports.getU64Codec = getU64Codec;
+exports.getU64Decoder = getU64Decoder;
+exports.getU64Encoder = getU64Encoder;
+exports.getU8Codec = getU8Codec;
+exports.getU8Decoder = getU8Decoder;
+exports.getU8Encoder = getU8Encoder;
+//# sourceMappingURL=index.browser.cjs.map
+//# sourceMappingURL=index.browser.cjs.map

node_modules/@solana/codecs-numbers/dist/index.browser.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.browser.mjs.map
+//# sourceMappingURL=index.browser.mjs.map

node_modules/@solana/codecs-numbers/dist/index.native.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.native.mjs.map
+//# sourceMappingURL=index.native.mjs.map

node_modules/@solana/codecs-numbers/dist/index.node.cjs

@@ -0,0 +1,326 @@
+'use strict';
+
+var errors = require('@solana/errors');
+var codecsCore = require('@solana/codecs-core');
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return codecsCore.createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return codecsCore.createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      codecsCore.assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      codecsCore.assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(codecsCore.toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => codecsCore.combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => codecsCore.combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => codecsCore.combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => codecsCore.combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => codecsCore.combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => codecsCore.combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => codecsCore.combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => codecsCore.createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => codecsCore.createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => codecsCore.combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => codecsCore.combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => codecsCore.combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => codecsCore.combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => codecsCore.combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => codecsCore.combineCodec(getU8Encoder(), getU8Decoder());
+
+exports.Endian = Endian;
+exports.assertNumberIsBetweenForCodec = assertNumberIsBetweenForCodec;
+exports.getF32Codec = getF32Codec;
+exports.getF32Decoder = getF32Decoder;
+exports.getF32Encoder = getF32Encoder;
+exports.getF64Codec = getF64Codec;
+exports.getF64Decoder = getF64Decoder;
+exports.getF64Encoder = getF64Encoder;
+exports.getI128Codec = getI128Codec;
+exports.getI128Decoder = getI128Decoder;
+exports.getI128Encoder = getI128Encoder;
+exports.getI16Codec = getI16Codec;
+exports.getI16Decoder = getI16Decoder;
+exports.getI16Encoder = getI16Encoder;
+exports.getI32Codec = getI32Codec;
+exports.getI32Decoder = getI32Decoder;
+exports.getI32Encoder = getI32Encoder;
+exports.getI64Codec = getI64Codec;
+exports.getI64Decoder = getI64Decoder;
+exports.getI64Encoder = getI64Encoder;
+exports.getI8Codec = getI8Codec;
+exports.getI8Decoder = getI8Decoder;
+exports.getI8Encoder = getI8Encoder;
+exports.getShortU16Codec = getShortU16Codec;
+exports.getShortU16Decoder = getShortU16Decoder;
+exports.getShortU16Encoder = getShortU16Encoder;
+exports.getU128Codec = getU128Codec;
+exports.getU128Decoder = getU128Decoder;
+exports.getU128Encoder = getU128Encoder;
+exports.getU16Codec = getU16Codec;
+exports.getU16Decoder = getU16Decoder;
+exports.getU16Encoder = getU16Encoder;
+exports.getU32Codec = getU32Codec;
+exports.getU32Decoder = getU32Decoder;
+exports.getU32Encoder = getU32Encoder;
+exports.getU64Codec = getU64Codec;
+exports.getU64Decoder = getU64Decoder;
+exports.getU64Encoder = getU64Encoder;
+exports.getU8Codec = getU8Codec;
+exports.getU8Decoder = getU8Decoder;
+exports.getU8Encoder = getU8Encoder;
+//# sourceMappingURL=index.node.cjs.map
+//# sourceMappingURL=index.node.cjs.map

node_modules/@solana/codecs-numbers/dist/index.node.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.node.mjs.map
+//# sourceMappingURL=index.node.mjs.map

node_modules/@solana/codecs-numbers/dist/types/assertions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Ensures that a given number falls within a specified range.
+ *
+ * If the number is outside the allowed range, an error is thrown.
+ * This function is primarily used to validate values before encoding them in a codec.
+ *
+ * @param codecDescription - A string describing the codec that is performing the validation.
+ * @param min - The minimum allowed value (inclusive).
+ * @param max - The maximum allowed value (inclusive).
+ * @param value - The number to validate.
+ *
+ * @throws {@link SolanaError} if the value is out of range.
+ *
+ * @example
+ * Validating a number within range.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 42); // Passes
+ * ```
+ *
+ * @example
+ * Throwing an error for an out-of-range value.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 300); // Throws
+ * ```
+ */
+export declare function assertNumberIsBetweenForCodec(codecDescription: string, min: bigint | number, max: bigint | number, value: bigint | number): void;
+//# sourceMappingURL=assertions.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../src/assertions.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CACzC,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,QAUzB"}

node_modules/@solana/codecs-numbers/dist/types/common.d.ts

@@ -0,0 +1,84 @@
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Represents an encoder for numbers and bigints.
+ *
+ * This type allows encoding values that are either `number` or `bigint`.
+ * Depending on the specific implementation, the encoded output may have a fixed or variable size.
+ *
+ * @see {@link FixedSizeNumberEncoder}
+ */
+export type NumberEncoder = Encoder<bigint | number>;
+/**
+ * Represents a fixed-size encoder for numbers and bigints.
+ *
+ * This encoder serializes values using an exact number of bytes, defined by `TSize`.
+ *
+ * @typeParam TSize - The number of bytes used for encoding.
+ *
+ * @see {@link NumberEncoder}
+ */
+export type FixedSizeNumberEncoder<TSize extends number = number> = FixedSizeEncoder<bigint | number, TSize>;
+/**
+ * Represents a decoder for numbers and bigints.
+ *
+ * This type supports decoding values as either `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberDecoder}
+ */
+export type NumberDecoder = Decoder<bigint> | Decoder<number>;
+/**
+ * Represents a fixed-size decoder for numbers and bigints.
+ *
+ * This decoder reads a fixed number of bytes (`TSize`) and converts them into a `number` or `bigint`.
+ *
+ * @typeParam TSize - The number of bytes expected for decoding.
+ *
+ * @see {@link NumberDecoder}
+ */
+export type FixedSizeNumberDecoder<TSize extends number = number> = FixedSizeDecoder<bigint, TSize> | FixedSizeDecoder<number, TSize>;
+/**
+ * Represents a codec for encoding and decoding numbers and bigints.
+ *
+ * - The encoded value can be either a `number` or a `bigint`.
+ * - The decoded value will always be either a `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberCodec}
+ */
+export type NumberCodec = Codec<bigint | number, bigint> | Codec<bigint | number, number>;
+/**
+ * Represents a fixed-size codec for encoding and decoding numbers and bigints.
+ *
+ * This codec uses a specific number of bytes (`TSize`) for serialization.
+ * The encoded value can be either a `number` or `bigint`, but the decoded value will always be a `number` or `bigint`,
+ * depending on the implementation.
+ *
+ * @typeParam TSize - The number of bytes used for encoding and decoding.
+ *
+ * @see {@link NumberCodec}
+ */
+export type FixedSizeNumberCodec<TSize extends number = number> = FixedSizeCodec<bigint | number, bigint, TSize> | FixedSizeCodec<bigint | number, number, TSize>;
+/**
+ * Configuration options for number codecs that use more than one byte.
+ *
+ * This configuration applies to all number codecs except `u8` and `i8`,
+ * allowing the user to specify the endianness of serialization.
+ */
+export type NumberCodecConfig = {
+    /**
+     * Specifies whether numbers should be encoded in little-endian or big-endian format.
+     *
+     * @defaultValue `Endian.Little`
+     */
+    endian?: Endian;
+};
+/**
+ * Defines the byte order used for number serialization.
+ *
+ * - `Little`: The least significant byte is stored first.
+ * - `Big`: The most significant byte is stored first.
+ */
+export declare enum Endian {
+    Little = 0,
+    Big = 1
+}
+//# sourceMappingURL=common.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAClH;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAErD;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAAI,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,CAAC;AAE7G;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAC1D,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,GAC/B,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC;AAE1F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IACxD,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,GAC9C,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,oBAAY,MAAM;IACd,MAAM,IAAA;IACN,GAAG,IAAA;CACN"}

node_modules/@solana/codecs-numbers/dist/types/f32.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This encoder serializes `f32` values using 4 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 4>` for encoding `f32` values.
+ *
+ * @example
+ * Encoding an `f32` value.
+ * ```ts
+ * const encoder = getF32Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x0000c0bf
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export declare const getF32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This decoder deserializes `f32` values from 4 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `f32` values.
+ *
+ * @example
+ * Decoding an `f32` value.
+ * ```ts
+ * const decoder = getF32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0xc0, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export declare const getF32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit floating-point numbers (`f32`).
+ *
+ * This codec serializes `f32` values using 4 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 4>` for encoding and decoding `f32` values.
+ *
+ * @example
+ * Encoding and decoding an `f32` value.
+ * ```ts
+ * const codec = getF32Codec();
+ * const bytes = codec.encode(-1.5); // 0x0000c0bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbfc00000
+ * ```
+ *
+ * @remarks
+ * `f32` values follow the IEEE 754 single-precision floating-point standard.
+ * Precision loss may occur for certain values.
+ *
+ * - If you need higher precision, consider using {@link getF64Codec}.
+ * - If you need integer values, consider using {@link getI32Codec} or {@link getU32Codec}.
+ *
+ * Separate {@link getF32Encoder} and {@link getF32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF32Encoder().encode(-1.5);
+ * const value = getF32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF32Encoder}
+ * @see {@link getF32Decoder}
+ */
+export declare const getF32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=f32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/f32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f32.d.ts","sourceRoot":"","sources":["../../src/f32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/f64.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This encoder serializes `f64` values using 8 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 8>` for encoding `f64` values.
+ *
+ * @example
+ * Encoding an `f64` value.
+ * ```ts
+ * const encoder = getF64Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x000000000000f8bf
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export declare const getF64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This decoder deserializes `f64` values from 8 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 8>` for decoding `f64` values.
+ *
+ * @example
+ * Decoding an `f64` value.
+ * ```ts
+ * const decoder = getF64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export declare const getF64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit floating-point numbers (`f64`).
+ *
+ * This codec serializes `f64` values using 8 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 8>` for encoding and decoding `f64` values.
+ *
+ * @example
+ * Encoding and decoding an `f64` value.
+ * ```ts
+ * const codec = getF64Codec();
+ * const bytes = codec.encode(-1.5); // 0x000000000000f8bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbff8000000000000
+ * ```
+ *
+ * @remarks
+ * `f64` values follow the IEEE 754 double-precision floating-point standard.
+ * Precision loss may still occur but is significantly lower than `f32`.
+ *
+ * - If you need smaller floating-point values, consider using {@link getF32Codec}.
+ * - If you need integer values, consider using {@link getI64Codec} or {@link getU64Codec}.
+ *
+ * Separate {@link getF64Encoder} and {@link getF64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF64Encoder().encode(-1.5);
+ * const value = getF64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF64Encoder}
+ * @see {@link getF64Decoder}
+ */
+export declare const getF64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 8>;
+//# sourceMappingURL=f64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/f64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f64.d.ts","sourceRoot":"","sources":["../../src/f64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i128.d.ts

@@ -0,0 +1,91 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 128-bit signed integers (`i128`).
+ *
+ * This encoder serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `i128` values.
+ *
+ * @example
+ * Encoding an `i128` value.
+ * ```ts
+ * const encoder = getI128Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export declare const getI128Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 16>;
+/**
+ * Returns a decoder for 128-bit signed integers (`i128`).
+ *
+ * This decoder deserializes `i128` values from 16 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `i128` values.
+ *
+ * @example
+ * Decoding an `i128` value.
+ * ```ts
+ * const decoder = getI128Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ *   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export declare const getI128Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 16>;
+/**
+ * Returns a codec for encoding and decoding 128-bit signed integers (`i128`).
+ *
+ * This codec serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `i128` values.
+ *
+ * @example
+ * Encoding and decoding an `i128` value.
+ * ```ts
+ * const codec = getI128Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^127` and `2^127 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI64Codec} or {@link getI32Codec}.
+ * - If you need a larger signed integer, consider using a custom codec.
+ * - If you need unsigned integers, consider using {@link getU128Codec}.
+ *
+ * Separate {@link getI128Encoder} and {@link getI128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI128Encoder().encode(-42);
+ * const value = getI128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI128Encoder}
+ * @see {@link getI128Decoder}
+ */
+export declare const getI128Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 16>;
+//# sourceMappingURL=i128.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i128.d.ts","sourceRoot":"","sources":["../../src/i128.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,CAa9F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAYrF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,YAAY,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i16.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 16-bit signed integers (`i16`).
+ *
+ * This encoder serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `i16` values.
+ *
+ * @example
+ * Encoding an `i16` value.
+ * ```ts
+ * const encoder = getI16Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ff
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export declare const getI16Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 2>;
+/**
+ * Returns a decoder for 16-bit signed integers (`i16`).
+ *
+ * This decoder deserializes `i16` values from 2 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `i16` values.
+ *
+ * @example
+ * Decoding an `i16` value.
+ * ```ts
+ * const decoder = getI16Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export declare const getI16Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 2>;
+/**
+ * Returns a codec for encoding and decoding 16-bit signed integers (`i16`).
+ *
+ * This codec serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `i16` values.
+ *
+ * @example
+ * Encoding and decoding an `i16` value.
+ * ```ts
+ * const codec = getI16Codec();
+ * const bytes = codec.encode(-42); // 0xd6ff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^15` (`-32,768`) and `2^15 - 1` (`32,767`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI32Codec}.
+ * - If you need unsigned integers, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getI16Encoder} and {@link getI16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI16Encoder().encode(-42);
+ * const value = getI16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI16Encoder}
+ * @see {@link getI16Decoder}
+ */
+export declare const getI16Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 2>;
+//# sourceMappingURL=i16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i16.d.ts","sourceRoot":"","sources":["../../src/i16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i32.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit signed integers (`i32`).
+ *
+ * This encoder serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 4>` for encoding `i32` values.
+ *
+ * @example
+ * Encoding an `i32` value.
+ * ```ts
+ * const encoder = getI32Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ffffff
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export declare const getI32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit signed integers (`i32`).
+ *
+ * This decoder deserializes `i32` values from 4 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `i32` values.
+ *
+ * @example
+ * Decoding an `i32` value.
+ * ```ts
+ * const decoder = getI32Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff, 0xff, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export declare const getI32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit signed integers (`i32`).
+ *
+ * This codec serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 4>` for encoding and decoding `i32` values.
+ *
+ * @example
+ * Encoding and decoding an `i32` value.
+ * ```ts
+ * const codec = getI32Codec();
+ * const bytes = codec.encode(-42); // 0xd6ffffff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^31` (`-2,147,483,648`) and `2^31 - 1` (`2,147,483,647`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI16Codec} or {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI64Codec}.
+ * - If you need unsigned integers, consider using {@link getU32Codec}.
+ *
+ * Separate {@link getI32Encoder} and {@link getI32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI32Encoder().encode(-42);
+ * const value = getI32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI32Encoder}
+ * @see {@link getI32Decoder}
+ */
+export declare const getI32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=i32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i32.d.ts","sourceRoot":"","sources":["../../src/i32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i64.d.ts

@@ -0,0 +1,90 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit signed integers (`i64`).
+ *
+ * This encoder serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `i64` values.
+ *
+ * @example
+ * Encoding an `i64` value.
+ * ```ts
+ * const encoder = getI64Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffff
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export declare const getI64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit signed integers (`i64`).
+ *
+ * This decoder deserializes `i64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `i64` values.
+ *
+ * @example
+ * Decoding an `i64` value.
+ * ```ts
+ * const decoder = getI64Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export declare const getI64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit signed integers (`i64`).
+ *
+ * This codec serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `i64` values.
+ *
+ * @example
+ * Encoding and decoding an `i64` value.
+ * ```ts
+ * const codec = getI64Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^63` and `2^63 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI32Codec} or {@link getI16Codec}.
+ * - If you need a larger signed integer, consider using {@link getI128Codec}.
+ * - If you need unsigned integers, consider using {@link getU64Codec}.
+ *
+ * Separate {@link getI64Encoder} and {@link getI64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI64Encoder().encode(-42);
+ * const value = getI64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI64Encoder}
+ * @see {@link getI64Decoder}
+ */
+export declare const getI64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 8>;
+//# sourceMappingURL=i64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i64.d.ts","sourceRoot":"","sources":["../../src/i64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i8.d.ts

@@ -0,0 +1,75 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for 8-bit signed integers (`i8`).
+ *
+ * This encoder serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `i8` values.
+ *
+ * @example
+ * Encoding an `i8` value.
+ * ```ts
+ * const encoder = getI8Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export declare const getI8Encoder: () => FixedSizeEncoder<bigint | number, 1>;
+/**
+ * Returns a decoder for 8-bit signed integers (`i8`).
+ *
+ * This decoder deserializes `i8` values from 1 byte.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `i8` values.
+ *
+ * @example
+ * Decoding an `i8` value.
+ * ```ts
+ * const decoder = getI8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6])); // -42
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export declare const getI8Decoder: () => FixedSizeDecoder<number, 1>;
+/**
+ * Returns a codec for encoding and decoding 8-bit signed integers (`i8`).
+ *
+ * This codec serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `i8` values.
+ *
+ * @example
+ * Encoding and decoding an `i8` value.
+ * ```ts
+ * const codec = getI8Codec();
+ * const bytes = codec.encode(-42); // 0xd6
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^7` (`-128`) and `2^7 - 1` (`127`).
+ *
+ * - If you need a larger signed integer, consider using {@link getI16Codec}.
+ * - If you need an unsigned integer, consider using {@link getU8Codec}.
+ *
+ * Separate {@link getI8Encoder} and {@link getI8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI8Encoder().encode(-42);
+ * const value = getI8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI8Encoder}
+ * @see {@link getI8Decoder}
+ */
+export declare const getI8Codec: () => FixedSizeCodec<bigint | number, number, 1>;
+//# sourceMappingURL=i8.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i8.d.ts","sourceRoot":"","sources":["../../src/i8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvG;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM7D,CAAC;AAEP;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAKpD,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,UAAU,QAAO,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACvB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This package contains codecs for numbers of different sizes and endianness.
+ * It can be used standalone, but it is also exported as part of Kit
+ * [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * This package is also part of the [`@solana/codecs` package](https://github.com/anza-xyz/kit/tree/main/packages/codecs)
+ * which acts as an entry point for all codec packages as well as for their documentation.
+ *
+ * @packageDocumentation
+ */
+export * from './assertions';
+export * from './common';
+export * from './f32';
+export * from './f64';
+export * from './i128';
+export * from './i16';
+export * from './i32';
+export * from './i64';
+export * from './i8';
+export * from './short-u16';
+export * from './u128';
+export * from './u16';
+export * from './u32';
+export * from './u64';
+export * from './u8';
+//# sourceMappingURL=index.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/short-u16.d.ts

@@ -0,0 +1,96 @@
+import { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for `shortU16` values.
+ *
+ * This encoder serializes `shortU16` values using **1 to 3 bytes**.
+ * Smaller values use fewer bytes, while larger values take up more space.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeEncoder<number | bigint>` for encoding `shortU16` values.
+ *
+ * @example
+ * Encoding a `shortU16` value.
+ * ```ts
+ * const encoder = getShortU16Encoder();
+ * encoder.encode(42);    // 0x2a
+ * encoder.encode(128);   // 0x8001
+ * encoder.encode(16384); // 0x808001
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export declare const getShortU16Encoder: () => VariableSizeEncoder<bigint | number>;
+/**
+ * Returns a decoder for `shortU16` values.
+ *
+ * This decoder deserializes `shortU16` values from **1 to 3 bytes**.
+ * The number of bytes used depends on the encoded value.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeDecoder<number>` for decoding `shortU16` values.
+ *
+ * @example
+ * Decoding a `shortU16` value.
+ * ```ts
+ * const decoder = getShortU16Decoder();
+ * decoder.decode(new Uint8Array([0x2a]));             // 42
+ * decoder.decode(new Uint8Array([0x80, 0x01]));       // 128
+ * decoder.decode(new Uint8Array([0x80, 0x80, 0x01])); // 16384
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export declare const getShortU16Decoder: () => VariableSizeDecoder<number>;
+/**
+ * Returns a codec for encoding and decoding `shortU16` values.
+ *
+ * It serializes unsigned integers using **1 to 3 bytes** based on the encoded value.
+ * The larger the value, the more bytes it uses.
+ *
+ * - If the value is `<= 0x7f` (127), it is stored in a **single byte**
+ *   and the first bit is set to `0` to indicate the end of the value.
+ * - Otherwise, the first bit is set to `1` to indicate that the value continues in the next byte, which follows the same pattern.
+ * - This process repeats until the value is fully encoded in up to 3 bytes. The third and last byte, if needed, uses all 8 bits to store the remaining value.
+ *
+ * In other words, the encoding scheme follows this structure:
+ *
+ * ```txt
+ * 0XXXXXXX                   <- Values 0 to 127 (1 byte)
+ * 1XXXXXXX 0XXXXXXX          <- Values 128 to 16,383 (2 bytes)
+ * 1XXXXXXX 1XXXXXXX XXXXXXXX <- Values 16,384 to 4,194,303 (3 bytes)
+ * ```
+ *
+ * @returns A `VariableSizeCodec<number | bigint, number>` for encoding and decoding `shortU16` values.
+ *
+ * @example
+ * Encoding and decoding `shortU16` values.
+ * ```ts
+ * const codec = getShortU16Codec();
+ * const bytes1 = codec.encode(42);    // 0x2a
+ * const bytes2 = codec.encode(128);   // 0x8001
+ * const bytes3 = codec.encode(16384); // 0x808001
+ *
+ * codec.decode(bytes1); // 42
+ * codec.decode(bytes2); // 128
+ * codec.decode(bytes3); // 16384
+ * ```
+ *
+ * @remarks
+ * This codec efficiently stores small numbers, making it useful for transactions and compact representations.
+ *
+ * If you need a fixed-size `u16` codec, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getShortU16Encoder} and {@link getShortU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getShortU16Encoder().encode(42);
+ * const value = getShortU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getShortU16Encoder}
+ * @see {@link getShortU16Decoder}
+ */
+export declare const getShortU16Codec: () => VariableSizeCodec<bigint | number, number>;
+//# sourceMappingURL=short-u16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/short-u16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"short-u16.d.ts","sourceRoot":"","sources":["../../src/short-u16.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,QAAO,mBAAmB,CAAC,MAAM,GAAG,MAAM,CA6BnE,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,QAAO,mBAAmB,CAAC,MAAM,CAmB1D,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,gBAAgB,QAAO,iBAAiB,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CACjB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u128.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 128-bit unsigned integers (`u128`).
+ *
+ * This encoder serializes `u128` values using sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `u128` values.
+ *
+ * @example
+ * Encoding a `u128` value.
+ * ```ts
+ * const encoder = getU128Encoder();
+ * const bytes = encoder.encode(42n); // 0x2a000000000000000000000000000000
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export declare const getU128Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 16>;
+/**
+ * Returns a decoder for 128-bit unsigned integers (`u128`).
+ *
+ * This decoder deserializes `u128` values from sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `u128` values.
+ *
+ * @example
+ * Decoding a `u128` value.
+ * ```ts
+ * const decoder = getU128Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export declare const getU128Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 16>;
+/**
+ * Returns a codec for encoding and decoding 128-bit unsigned integers (`u128`).
+ *
+ * This codec serializes `u128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `u128` values.
+ *
+ * @example
+ * Encoding and decoding a `u128` value.
+ * ```ts
+ * const codec = getU128Codec();
+ * const bytes = codec.encode(42); // 0x2a000000000000000000000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000000000000000000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^128 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU64Codec} or {@link getU32Codec}.
+ * - If you need signed integers, consider using {@link getI128Codec}.
+ *
+ * Separate {@link getU128Encoder} and {@link getU128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU128Encoder().encode(42);
+ * const value = getU128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU128Encoder}
+ * @see {@link getU128Decoder}
+ */
+export declare const getU128Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 16>;
+//# sourceMappingURL=u128.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u128.d.ts","sourceRoot":"","sources":["../../src/u128.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,CAa9F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAYrF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,YAAY,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u16.d.ts

@@ -0,0 +1,85 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 16-bit unsigned integers (`u16`).
+ *
+ * This encoder serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `u16` values.
+ *
+ * @example
+ * Encoding a `u16` value.
+ * ```ts
+ * const encoder = getU16Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export declare const getU16Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 2>;
+/**
+ * Returns a decoder for 16-bit unsigned integers (`u16`).
+ *
+ * This decoder deserializes `u16` values from two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `u16` values.
+ *
+ * @example
+ * Decoding a `u16` value.
+ * ```ts
+ * const decoder = getU16Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export declare const getU16Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 2>;
+/**
+ * Returns a codec for encoding and decoding 16-bit unsigned integers (`u16`).
+ *
+ * This codec serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `u16` values.
+ *
+ * @example
+ * Encoding and decoding a `u16` value.
+ * ```ts
+ * const codec = getU16Codec();
+ * const bytes = codec.encode(42); // 0x2a00 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^16 - 1`.
+ * If you need a larger range, consider using {@link getU32Codec} or {@link getU64Codec}.
+ * For signed integers, use {@link getI16Codec}.
+ *
+ * Separate {@link getU16Encoder} and {@link getU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU16Encoder().encode(42);
+ * const value = getU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU16Encoder}
+ * @see {@link getU16Decoder}
+ */
+export declare const getU16Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 2>;
+//# sourceMappingURL=u16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u16.d.ts","sourceRoot":"","sources":["../../src/u16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u32.d.ts

@@ -0,0 +1,85 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit unsigned integers (`u32`).
+ *
+ * This encoder serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<bigint | number, 4>` for encoding `u32` values.
+ *
+ * @example
+ * Encoding a `u32` value.
+ * ```ts
+ * const encoder = getU32Encoder();
+ * const bytes = encoder.encode(42); // 0x2a000000
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export declare const getU32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit unsigned integers (`u32`).
+ *
+ * This decoder deserializes `u32` values from four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `u32` values.
+ *
+ * @example
+ * Decoding a `u32` value.
+ * ```ts
+ * const decoder = getU32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export declare const getU32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit unsigned integers (`u32`).
+ *
+ * This codec serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<bigint | number, number, 4>` for encoding and decoding `u32` values.
+ *
+ * @example
+ * Encoding and decoding a `u32` value.
+ * ```ts
+ * const codec = getU32Codec();
+ * const bytes = codec.encode(42); // 0x2a000000 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000002a
+ * ```
+ *
+ * @remarks
+ * This codec only supports values between `0` and `2^32 - 1`.
+ * If you need a larger range, consider using {@link getU64Codec} or {@link getU128Codec}.
+ * For signed integers, use {@link getI32Codec}.
+ *
+ * Separate {@link getU32Encoder} and {@link getU32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU32Encoder().encode(42);
+ * const value = getU32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU32Encoder}
+ * @see {@link getU32Decoder}
+ */
+export declare const getU32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=u32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u32.d.ts","sourceRoot":"","sources":["../../src/u32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u64.d.ts

@@ -0,0 +1,88 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit unsigned integers (`u64`).
+ *
+ * This encoder serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `u64` values.
+ *
+ * @example
+ * Encoding a `u64` value.
+ * ```ts
+ * const encoder = getU64Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00000000000000
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export declare const getU64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit unsigned integers (`u64`).
+ *
+ * This decoder deserializes `u64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `u64` values.
+ *
+ * @example
+ * Decoding a `u64` value.
+ * ```ts
+ * const decoder = getU64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export declare const getU64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit unsigned integers (`u64`).
+ *
+ * This codec serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `u64` values.
+ *
+ * @example
+ * Encoding and decoding a `u64` value.
+ * ```ts
+ * const codec = getU64Codec();
+ * const bytes = codec.encode(42); // 0x2a00000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^64 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU32Codec} or {@link getU16Codec}.
+ * - If you need a larger unsigned integer, consider using {@link getU128Codec}.
+ * - If you need signed integers, consider using {@link getI64Codec}.
+ *
+ * Separate {@link getU64Encoder} and {@link getU64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU64Encoder().encode(42);
+ * const value = getU64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU64Encoder}
+ * @see {@link getU64Decoder}
+ */
+export declare const getU64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 8>;
+//# sourceMappingURL=u64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u64.d.ts","sourceRoot":"","sources":["../../src/u64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u8.d.ts

@@ -0,0 +1,71 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for 8-bit unsigned integers (`u8`).
+ *
+ * This encoder serializes `u8` values using a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `u8` values.
+ *
+ * @example
+ * Encoding a `u8` value.
+ * ```ts
+ * const encoder = getU8Encoder();
+ * const bytes = encoder.encode(42); // 0x2a
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export declare const getU8Encoder: () => FixedSizeEncoder<bigint | number, 1>;
+/**
+ * Returns a decoder for 8-bit unsigned integers (`u8`).
+ *
+ * This decoder deserializes `u8` values from a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `u8` values.
+ *
+ * @example
+ * Decoding a `u8` value.
+ * ```ts
+ * const decoder = getU8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xff])); // 255
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export declare const getU8Decoder: () => FixedSizeDecoder<number, 1>;
+/**
+ * Returns a codec for encoding and decoding 8-bit unsigned integers (`u8`).
+ *
+ * This codec serializes `u8` values using a single byte.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `u8` values.
+ *
+ * @example
+ * Encoding and decoding a `u8` value.
+ * ```ts
+ * const codec = getU8Codec();
+ * const bytes = codec.encode(255); // 0xff
+ * const value = codec.decode(bytes); // 255
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^8 - 1` (0 to 255).
+ * If you need larger integers, consider using {@link getU16Codec}, {@link getU32Codec}, or {@link getU64Codec}.
+ * For signed integers, use {@link getI8Codec}.
+ *
+ * Separate {@link getU8Encoder} and {@link getU8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU8Encoder().encode(42);
+ * const value = getU8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU8Encoder}
+ * @see {@link getU8Decoder}
+ */
+export declare const getU8Codec: () => FixedSizeCodec<bigint | number, number, 1>;
+//# sourceMappingURL=u8.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u8.d.ts","sourceRoot":"","sources":["../../src/u8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM7D,CAAC;AAEP;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAKpD,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,UAAU,QAAO,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACvB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/utils.d.ts

@@ -0,0 +1,18 @@
+import { FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+type NumberFactorySharedInput<TSize extends number> = {
+    config?: NumberCodecConfig;
+    name: string;
+    size: TSize;
+};
+type NumberFactoryEncoderInput<TFrom, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    range?: [bigint | number, bigint | number];
+    set: (view: DataView, value: TFrom, littleEndian?: boolean) => void;
+};
+type NumberFactoryDecoderInput<TTo, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    get: (view: DataView, littleEndian?: boolean) => TTo;
+};
+export declare function numberEncoderFactory<TFrom extends bigint | number, TSize extends number>(input: NumberFactoryEncoderInput<TFrom, TSize>): FixedSizeEncoder<TFrom, TSize>;
+export declare function numberDecoderFactory<TTo extends bigint | number, TSize extends number>(input: NumberFactoryDecoderInput<TTo, TSize>): FixedSizeDecoder<TTo, TSize>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,gBAAgB,EAChB,gBAAgB,EAGnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAU,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAErD,KAAK,wBAAwB,CAAC,KAAK,SAAS,MAAM,IAAI;IAClD,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,KAAK,yBAAyB,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IAAI,wBAAwB,CAAC,KAAK,CAAC,GAAG;IAC5F,KAAK,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAC3C,GAAG,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACvE,CAAC;AAEF,KAAK,yBAAyB,CAAC,GAAG,EAAE,KAAK,SAAS,MAAM,IAAI,wBAAwB,CAAC,KAAK,CAAC,GAAG;IAC1F,GAAG,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,OAAO,KAAK,GAAG,CAAC;CACxD,CAAC;AAMF,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,SAAS,MAAM,EACpF,KAAK,EAAE,yBAAyB,CAAC,KAAK,EAAE,KAAK,CAAC,GAC/C,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAahC;AAED,wBAAgB,oBAAoB,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,SAAS,MAAM,EAClF,KAAK,EAAE,yBAAyB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC7C,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAU9B"}