@brainai/satp-client 2.0.7 → 2.0.8

package/node_modules/@solana/codecs-core/dist/types/offset-codec.d.ts

@@ -1,328 +0,0 @@
-import { Codec, Decoder, Encoder, Offset } from './codec';
-import { ReadonlyUint8Array } from './readonly-uint8array';
-type AnyEncoder = Encoder<any>;
-type AnyDecoder = Decoder<any>;
-type AnyCodec = Codec<any>;
-/**
- * Configuration object for modifying the offset of an encoder, decoder, or codec.
- *
- * This type defines optional functions for adjusting the **pre-offset** (before encoding/decoding)
- * and the **post-offset** (after encoding/decoding). These functions allow precise control
- * over where data is written or read within a byte array.
- *
- * @property preOffset - A function that modifies the offset before encoding or decoding.
- * @property postOffset - A function that modifies the offset after encoding or decoding.
- *
- * @example
- * Moving the pre-offset forward by 2 bytes.
- * ```ts
- * const config: OffsetConfig = {
- *     preOffset: ({ preOffset }) => preOffset + 2,
- * };
- * ```
- *
- * @example
- * Moving the post-offset forward by 2 bytes.
- * ```ts
- * const config: OffsetConfig = {
- *     postOffset: ({ postOffset }) => postOffset + 2,
- * };
- * ```
- *
- * @example
- * Using both pre-offset and post-offset together.
- * ```ts
- * const config: OffsetConfig = {
- *     preOffset: ({ preOffset }) => preOffset + 2,
- *     postOffset: ({ postOffset }) => postOffset + 4,
- * };
- * ```
- *
- * @see {@link offsetEncoder}
- * @see {@link offsetDecoder}
- * @see {@link offsetCodec}
- */
-type OffsetConfig = {
-    postOffset?: PostOffsetFunction;
-    preOffset?: PreOffsetFunction;
-};
-/**
- * Scope provided to the `preOffset` and `postOffset` functions,
- * containing contextual information about the current encoding or decoding process.
- *
- * The pre-offset function modifies where encoding or decoding begins,
- * while the post-offset function modifies where the next operation continues.
- *
- * @property bytes - The entire byte array being encoded or decoded.
- * @property preOffset - The original offset before encoding or decoding starts.
- * @property wrapBytes - A helper function that wraps offsets around the byte array length.
- *
- * @example
- * Using `wrapBytes` to wrap a negative offset to the end of the byte array.
- * ```ts
- * const config: OffsetConfig = {
- *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves to last 4 bytes
- * };
- * ```
- *
- * @example
- * Adjusting the offset dynamically based on the byte array size.
- * ```ts
- * const config: OffsetConfig = {
- *     preOffset: ({ bytes }) => bytes.length > 10 ? 4 : 2,
- * };
- * ```
- *
- * @see {@link PreOffsetFunction}
- * @see {@link PostOffsetFunction}
- */
-type PreOffsetFunctionScope = {
-    /** The entire byte array. */
-    bytes: ReadonlyUint8Array | Uint8Array;
-    /** The original offset prior to encode or decode. */
-    preOffset: Offset;
-    /** Wraps the offset to the byte array length. */
-    wrapBytes: (offset: Offset) => Offset;
-};
-/**
- * A function that modifies the pre-offset before encoding or decoding.
- *
- * This function is used to adjust the starting position before writing
- * or reading data in a byte array.
- *
- * @param scope - The current encoding or decoding context.
- * @returns The new offset at which encoding or decoding should start.
- *
- * @example
- * Skipping the first 2 bytes before writing or reading.
- * ```ts
- * const preOffset: PreOffsetFunction = ({ preOffset }) => preOffset + 2;
- * ```
- *
- * @example
- * Wrapping the offset to ensure it stays within bounds.
- * ```ts
- * const preOffset: PreOffsetFunction = ({ wrapBytes, preOffset }) => wrapBytes(preOffset + 10);
- * ```
- *
- * @see {@link OffsetConfig}
- * @see {@link PreOffsetFunctionScope}
- */
-type PreOffsetFunction = (scope: PreOffsetFunctionScope) => Offset;
-/**
- * A function that modifies the post-offset after encoding or decoding.
- *
- * This function adjusts where the next encoder or decoder should start
- * after the current operation has completed.
- *
- * @param scope - The current encoding or decoding context, including the modified pre-offset
- * and the original post-offset.
- * @returns The new offset at which the next operation should begin.
- *
- * @example
- * Moving the post-offset forward by 4 bytes.
- * ```ts
- * const postOffset: PostOffsetFunction = ({ postOffset }) => postOffset + 4;
- * ```
- *
- * @example
- * Wrapping the post-offset within the byte array length.
- * ```ts
- * const postOffset: PostOffsetFunction = ({ wrapBytes, postOffset }) => wrapBytes(postOffset);
- * ```
- *
- * @example
- * Ensuring a minimum spacing of 8 bytes between values.
- * ```ts
- * const postOffset: PostOffsetFunction = ({ postOffset, newPreOffset }) =>
- *     Math.max(postOffset, newPreOffset + 8);
- * ```
- *
- * @see {@link OffsetConfig}
- * @see {@link PreOffsetFunctionScope}
- */
-type PostOffsetFunction = (scope: PreOffsetFunctionScope & {
-    /** The modified offset used to encode or decode. */
-    newPreOffset: Offset;
-    /** The original offset returned by the encoder or decoder. */
-    postOffset: Offset;
-}) => Offset;
-/**
- * Moves the offset of a given encoder before and/or after encoding.
- *
- * This function allows an encoder to write its encoded value at a different offset
- * than the one originally provided. It supports both pre-offset adjustments
- * (before encoding) and post-offset adjustments (after encoding).
- *
- * The pre-offset function determines where encoding should start, while the
- * post-offset function adjusts where the next encoder should continue writing.
- *
- * For more details, see {@link offsetCodec}.
- *
- * @typeParam TFrom - The type of the value to encode.
- *
- * @param encoder - The encoder to adjust.
- * @param config - An object specifying how the offset should be modified.
- * @returns A new encoder with adjusted offsets.
- *
- * @example
- * Moving the pre-offset forward by 2 bytes.
- * ```ts
- * const encoder = offsetEncoder(getU32Encoder(), {
- *     preOffset: ({ preOffset }) => preOffset + 2,
- * });
- * const bytes = new Uint8Array(10);
- * encoder.write(42, bytes, 0); // Actually written at offset 2
- * ```
- *
- * @example
- * Moving the post-offset forward by 2 bytes.
- * ```ts
- * const encoder = offsetEncoder(getU32Encoder(), {
- *     postOffset: ({ postOffset }) => postOffset + 2,
- * });
- * const bytes = new Uint8Array(10);
- * const nextOffset = encoder.write(42, bytes, 0); // Next encoder starts at offset 6 instead of 4
- * ```
- *
- * @example
- * Using `wrapBytes` to ensure an offset wraps around the byte array length.
- * ```ts
- * const encoder = offsetEncoder(getU32Encoder(), {
- *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes of the array
- * });
- * const bytes = new Uint8Array(10);
- * encoder.write(42, bytes, 0); // Writes at bytes.length - 4
- * ```
- *
- * @remarks
- * If you need both encoding and decoding offsets to be adjusted, use {@link offsetCodec}.
- *
- * @see {@link offsetCodec}
- * @see {@link offsetDecoder}
- */
-export declare function offsetEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, config: OffsetConfig): TEncoder;
-/**
- * Moves the offset of a given decoder before and/or after decoding.
- *
- * This function allows a decoder to read its input from a different offset
- * than the one originally provided. It supports both pre-offset adjustments
- * (before decoding) and post-offset adjustments (after decoding).
- *
- * The pre-offset function determines where decoding should start, while the
- * post-offset function adjusts where the next decoder should continue reading.
- *
- * For more details, see {@link offsetCodec}.
- *
- * @typeParam TTo - The type of the decoded value.
- *
- * @param decoder - The decoder to adjust.
- * @param config - An object specifying how the offset should be modified.
- * @returns A new decoder with adjusted offsets.
- *
- * @example
- * Moving the pre-offset forward by 2 bytes.
- * ```ts
- * const decoder = offsetDecoder(getU32Decoder(), {
- *     preOffset: ({ preOffset }) => preOffset + 2,
- * });
- * const bytes = new Uint8Array([0, 0, 42, 0]); // Value starts at offset 2
- * decoder.read(bytes, 0); // Actually reads from offset 2
- * ```
- *
- * @example
- * Moving the post-offset forward by 2 bytes.
- * ```ts
- * const decoder = offsetDecoder(getU32Decoder(), {
- *     postOffset: ({ postOffset }) => postOffset + 2,
- * });
- * const bytes = new Uint8Array([42, 0, 0, 0]);
- * const [value, nextOffset] = decoder.read(bytes, 0); // Next decoder starts at offset 6 instead of 4
- * ```
- *
- * @example
- * Using `wrapBytes` to read from the last 4 bytes of an array.
- * ```ts
- * const decoder = offsetDecoder(getU32Decoder(), {
- *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes of the array
- * });
- * const bytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 42]); // Value stored at the last 4 bytes
- * decoder.read(bytes, 0); // Reads from bytes.length - 4
- * ```
- *
- * @remarks
- * If you need both encoding and decoding offsets to be adjusted, use {@link offsetCodec}.
- *
- * @see {@link offsetCodec}
- * @see {@link offsetEncoder}
- */
-export declare function offsetDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, config: OffsetConfig): TDecoder;
-/**
- * Moves the offset of a given codec before and/or after encoding and decoding.
- *
- * This function allows a codec to encode and decode values at custom offsets
- * within a byte array. It modifies both the **pre-offset** (where encoding/decoding starts)
- * and the **post-offset** (where the next operation should continue).
- *
- * This is particularly useful when working with structured binary formats
- * that require skipping reserved bytes, inserting padding, or aligning fields at
- * specific locations.
- *
- * @typeParam TFrom - The type of the value to encode.
- * @typeParam TTo - The type of the decoded value.
- *
- * @param codec - The codec to adjust.
- * @param config - An object specifying how the offset should be modified.
- * @returns A new codec with adjusted offsets.
- *
- * @example
- * Moving the pre-offset forward by 2 bytes when encoding and decoding.
- * ```ts
- * const codec = offsetCodec(getU32Codec(), {
- *     preOffset: ({ preOffset }) => preOffset + 2,
- * });
- * const bytes = new Uint8Array(10);
- * codec.write(42, bytes, 0); // Actually written at offset 2
- * codec.read(bytes, 0);      // Actually read from offset 2
- * ```
- *
- * @example
- * Moving the post-offset forward by 2 bytes when encoding and decoding.
- * ```ts
- * const codec = offsetCodec(getU32Codec(), {
- *     postOffset: ({ postOffset }) => postOffset + 2,
- * });
- * const bytes = new Uint8Array(10);
- * codec.write(42, bytes, 0);
- * // Next encoding starts at offset 6 instead of 4
- * codec.read(bytes, 0);
- * // Next decoding starts at offset 6 instead of 4
- * ```
- *
- * @example
- * Using `wrapBytes` to loop around negative offsets.
- * ```ts
- * const codec = offsetCodec(getU32Codec(), {
- *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes
- * });
- * const bytes = new Uint8Array(10);
- * codec.write(42, bytes, 0); // Writes at bytes.length - 4
- * codec.read(bytes, 0); // Reads from bytes.length - 4
- * ```
- *
- * @remarks
- * If you only need to adjust offsets for encoding, use {@link offsetEncoder}.
- * If you only need to adjust offsets for decoding, use {@link offsetDecoder}.
- *
- * ```ts
- * const bytes = new Uint8Array(10);
- * offsetEncoder(getU32Encoder(), { preOffset: ({ preOffset }) => preOffset + 2 }).write(42, bytes, 0);
- * const [value] = offsetDecoder(getU32Decoder(), { preOffset: ({ preOffset }) => preOffset + 2 }).read(bytes, 0);
- * ```
- *
- * @see {@link offsetEncoder}
- * @see {@link offsetDecoder}
- */
-export declare function offsetCodec<TCodec extends AnyCodec>(codec: TCodec, config: OffsetConfig): TCodec;
-export {};
-//# sourceMappingURL=offset-codec.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/offset-codec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"offset-codec.d.ts","sourceRoot":"","sources":["../../src/offset-codec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAgC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAExF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,KAAK,YAAY,GAAG;IAChB,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,SAAS,CAAC,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,KAAK,sBAAsB,GAAG;IAC1B,6BAA6B;IAC7B,KAAK,EAAE,kBAAkB,GAAG,UAAU,CAAC;IACvC,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,MAAM,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,KAAK,kBAAkB,GAAG,CACtB,KAAK,EAAE,sBAAsB,GAAG;IAC5B,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;CACtB,KACA,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,CAe5G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,CAe5G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,WAAW,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAEhG"}

package/node_modules/@solana/codecs-core/dist/types/pad-codec.d.ts

@@ -1,162 +0,0 @@
-import { Codec, Decoder, Encoder, Offset } from './codec';
-type AnyEncoder = Encoder<any>;
-type AnyDecoder = Decoder<any>;
-type AnyCodec = Codec<any>;
-/**
- * Adds left padding to the given encoder, shifting the encoded value forward
- * by `offset` bytes whilst increasing the size of the encoder accordingly.
- *
- * For more details, see {@link padLeftCodec}.
- *
- * @typeParam TFrom - The type of the value to encode.
- *
- * @param encoder - The encoder to pad.
- * @param offset - The number of padding bytes to add before encoding.
- * @returns A new encoder with left padding applied.
- *
- * @example
- * ```ts
- * const encoder = padLeftEncoder(getU16Encoder(), 2);
- * const bytes = encoder.encode(0xffff); // 0x0000ffff (0xffff written at offset 2)
- * ```
- *
- * @see {@link padLeftCodec}
- * @see {@link padLeftDecoder}
- */
-export declare function padLeftEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, offset: Offset): TEncoder;
-/**
- * Adds right padding to the given encoder, extending the encoded value by `offset`
- * bytes whilst increasing the size of the encoder accordingly.
- *
- * For more details, see {@link padRightCodec}.
- *
- * @typeParam TFrom - The type of the value to encode.
- *
- * @param encoder - The encoder to pad.
- * @param offset - The number of padding bytes to add after encoding.
- * @returns A new encoder with right padding applied.
- *
- * @example
- * ```ts
- * const encoder = padRightEncoder(getU16Encoder(), 2);
- * const bytes = encoder.encode(0xffff); // 0xffff0000 (two extra bytes added at the end)
- * ```
- *
- * @see {@link padRightCodec}
- * @see {@link padRightDecoder}
- */
-export declare function padRightEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, offset: Offset): TEncoder;
-/**
- * Adds left padding to the given decoder, shifting the decoding position forward
- * by `offset` bytes whilst increasing the size of the decoder accordingly.
- *
- * For more details, see {@link padLeftCodec}.
- *
- * @typeParam TTo - The type of the decoded value.
- *
- * @param decoder - The decoder to pad.
- * @param offset - The number of padding bytes to skip before decoding.
- * @returns A new decoder with left padding applied.
- *
- * @example
- * ```ts
- * const decoder = padLeftDecoder(getU16Decoder(), 2);
- * const value = decoder.decode(new Uint8Array([0, 0, 0x12, 0x34])); // 0xffff (reads from offset 2)
- * ```
- *
- * @see {@link padLeftCodec}
- * @see {@link padLeftEncoder}
- */
-export declare function padLeftDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, offset: Offset): TDecoder;
-/**
- * Adds right padding to the given decoder, extending the post-offset by `offset`
- * bytes whilst increasing the size of the decoder accordingly.
- *
- * For more details, see {@link padRightCodec}.
- *
- * @typeParam TTo - The type of the decoded value.
- *
- * @param decoder - The decoder to pad.
- * @param offset - The number of padding bytes to skip after decoding.
- * @returns A new decoder with right padding applied.
- *
- * @example
- * ```ts
- * const decoder = padRightDecoder(getU16Decoder(), 2);
- * const value = decoder.decode(new Uint8Array([0x12, 0x34, 0, 0])); // 0xffff (ignores trailing bytes)
- * ```
- *
- * @see {@link padRightCodec}
- * @see {@link padRightEncoder}
- */
-export declare function padRightDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, offset: Offset): TDecoder;
-/**
- * Adds left padding to the given codec, shifting the encoding and decoding positions
- * forward by `offset` bytes whilst increasing the size of the codec accordingly.
- *
- * This ensures that values are read and written at a later position in the byte array,
- * while the padding bytes remain unused.
- *
- * @typeParam TFrom - The type of the value to encode.
- * @typeParam TTo - The type of the decoded value.
- *
- * @param codec - The codec to pad.
- * @param offset - The number of padding bytes to add before encoding and decoding.
- * @returns A new codec with left padding applied.
- *
- * @example
- * ```ts
- * const codec = padLeftCodec(getU16Codec(), 2);
- * const bytes = codec.encode(0xffff); // 0x0000ffff (0xffff written at offset 2)
- * const value = codec.decode(bytes);  // 0xffff (reads from offset 2)
- * ```
- *
- * @remarks
- * If you only need to apply padding for encoding, use {@link padLeftEncoder}.
- * If you only need to apply padding for decoding, use {@link padLeftDecoder}.
- *
- * ```ts
- * const bytes = padLeftEncoder(getU16Encoder(), 2).encode(0xffff);
- * const value = padLeftDecoder(getU16Decoder(), 2).decode(bytes);
- * ```
- *
- * @see {@link padLeftEncoder}
- * @see {@link padLeftDecoder}
- */
-export declare function padLeftCodec<TCodec extends AnyCodec>(codec: TCodec, offset: Offset): TCodec;
-/**
- * Adds right padding to the given codec, extending the encoded and decoded value
- * by `offset` bytes whilst increasing the size of the codec accordingly.
- *
- * The extra bytes remain unused, ensuring that the next operation starts further
- * along the byte array.
- *
- * @typeParam TFrom - The type of the value to encode.
- * @typeParam TTo - The type of the decoded value.
- *
- * @param codec - The codec to pad.
- * @param offset - The number of padding bytes to add after encoding and decoding.
- * @returns A new codec with right padding applied.
- *
- * @example
- * ```ts
- * const codec = padRightCodec(getU16Codec(), 2);
- * const bytes = codec.encode(0xffff); // 0xffff0000 (two extra bytes added)
- * const value = codec.decode(bytes);  // 0xffff (ignores padding bytes)
- * ```
- *
- * @remarks
- * If you only need to apply padding for encoding, use {@link padRightEncoder}.
- * If you only need to apply padding for decoding, use {@link padRightDecoder}.
- *
- * ```ts
- * const bytes = padRightEncoder(getU16Encoder(), 2).encode(0xffff);
- * const value = padRightDecoder(getU16Decoder(), 2).decode(bytes);
- * ```
- *
- * @see {@link padRightEncoder}
- * @see {@link padRightDecoder}
- */
-export declare function padRightCodec<TCodec extends AnyCodec>(codec: TCodec, offset: Offset): TCodec;
-export {};
-//# sourceMappingURL=pad-codec.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/pad-codec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pad-codec.d.ts","sourceRoot":"","sources":["../../src/pad-codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAM1D,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKvG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKxG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKvG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKxG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE5F"}

package/node_modules/@solana/codecs-core/dist/types/readonly-uint8array.d.ts

@@ -1,19 +0,0 @@
-/**
- * A read-only variant of `Uint8Array`.
- *
- * This type prevents modifications to the array by omitting mutable methods such as `copyWithin`,
- * `fill`, `reverse`, `set`, and `sort`, while still allowing indexed access to elements.
- *
- * @example
- * ```ts
- * const bytes: ReadonlyUint8Array = new Uint8Array([1, 2, 3]);
- * console.log(bytes[0]); // 1
- * bytes[0] = 42; // Type error: Cannot assign to '0' because it is a read-only property.
- * ```
- */
-export interface ReadonlyUint8Array extends Omit<Uint8Array, TypedArrayMutableProperties> {
-    readonly [n: number]: number;
-}
-type TypedArrayMutableProperties = 'copyWithin' | 'fill' | 'reverse' | 'set' | 'sort';
-export {};
-//# sourceMappingURL=readonly-uint8array.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/readonly-uint8array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"readonly-uint8array.d.ts","sourceRoot":"","sources":["../../src/readonly-uint8array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,UAAU,EAAE,2BAA2B,CAAC;IACrF,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC;AAED,KAAK,2BAA2B,GAAG,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC"}

package/node_modules/@solana/codecs-core/dist/types/resize-codec.d.ts

@@ -1,129 +0,0 @@
-import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec';
-type AnyEncoder = Encoder<any>;
-type AnyDecoder = Decoder<any>;
-type AnyCodec = Codec<any>;
-/**
- * Updates the size of a given encoder.
- *
- * This function modifies the size of an encoder using a provided transformation function.
- * For fixed-size encoders, it updates the `fixedSize` property, and for variable-size
- * encoders, it adjusts the size calculation based on the encoded value.
- *
- * If the new size is negative, an error will be thrown.
- *
- * For more details, see {@link resizeCodec}.
- *
- * @typeParam TFrom - The type of the value to encode.
- * @typeParam TSize - The original fixed size of the encoded value.
- * @typeParam TNewSize - The new fixed size after resizing.
- *
- * @param encoder - The encoder whose size will be updated.
- * @param resize - A function that takes the current size and returns the new size.
- * @returns A new encoder with the updated size.
- *
- * @example
- * Increasing the size of a `u16` encoder by 2 bytes.
- * ```ts
- * const encoder = resizeEncoder(getU16Encoder(), size => size + 2);
- * encoder.encode(0xffff); // 0xffff0000 (two extra bytes added)
- * ```
- *
- * @example
- * Shrinking a `u32` encoder to only use 2 bytes.
- * ```ts
- * const encoder = resizeEncoder(getU32Encoder(), () => 2);
- * encoder.fixedSize; // 2
- * ```
- *
- * @see {@link resizeCodec}
- * @see {@link resizeDecoder}
- */
-export declare function resizeEncoder<TFrom, TSize extends number, TNewSize extends number>(encoder: FixedSizeEncoder<TFrom, TSize>, resize: (size: TSize) => TNewSize): FixedSizeEncoder<TFrom, TNewSize>;
-export declare function resizeEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, resize: (size: number) => number): TEncoder;
-/**
- * Updates the size of a given decoder.
- *
- * This function modifies the size of a decoder using a provided transformation function.
- * For fixed-size decoders, it updates the `fixedSize` property to reflect the new size.
- * Variable-size decoders remain unchanged, as their size is determined dynamically.
- *
- * If the new size is negative, an error will be thrown.
- *
- * For more details, see {@link resizeCodec}.
- *
- * @typeParam TTo - The type of the decoded value.
- * @typeParam TSize - The original fixed size of the decoded value.
- * @typeParam TNewSize - The new fixed size after resizing.
- *
- * @param decoder - The decoder whose size will be updated.
- * @param resize - A function that takes the current size and returns the new size.
- * @returns A new decoder with the updated size.
- *
- * @example
- * Expanding a `u16` decoder to read 4 bytes instead of 2.
- * ```ts
- * const decoder = resizeDecoder(getU16Decoder(), size => size + 2);
- * decoder.fixedSize; // 4
- * ```
- *
- * @example
- * Shrinking a `u32` decoder to only read 2 bytes.
- * ```ts
- * const decoder = resizeDecoder(getU32Decoder(), () => 2);
- * decoder.fixedSize; // 2
- * ```
- *
- * @see {@link resizeCodec}
- * @see {@link resizeEncoder}
- */
-export declare function resizeDecoder<TFrom, TSize extends number, TNewSize extends number>(decoder: FixedSizeDecoder<TFrom, TSize>, resize: (size: TSize) => TNewSize): FixedSizeDecoder<TFrom, TNewSize>;
-export declare function resizeDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, resize: (size: number) => number): TDecoder;
-/**
- * Updates the size of a given codec.
- *
- * This function modifies the size of both the codec using a provided
- * transformation function. It is useful for adjusting the allocated byte size for
- * encoding and decoding without altering the underlying data structure.
- *
- * If the new size is negative, an error will be thrown.
- *
- * @typeParam TFrom - The type of the value to encode.
- * @typeParam TTo - The type of the decoded value.
- * @typeParam TSize - The original fixed size of the encoded/decoded value (for fixed-size codecs).
- * @typeParam TNewSize - The new fixed size after resizing (for fixed-size codecs).
- *
- * @param codec - The codec whose size will be updated.
- * @param resize - A function that takes the current size and returns the new size.
- * @returns A new codec with the updated size.
- *
- * @example
- * Expanding a `u16` codec from 2 to 4 bytes.
- * ```ts
- * const codec = resizeCodec(getU16Codec(), size => size + 2);
- * const bytes = codec.encode(0xffff); // 0xffff0000 (two extra bytes added)
- * const value = codec.decode(bytes);  // 0xffff (reads original two bytes)
- * ```
- *
- * @example
- * Shrinking a `u32` codec to only use 2 bytes.
- * ```ts
- * const codec = resizeCodec(getU32Codec(), () => 2);
- * codec.fixedSize; // 2
- * ```
- *
- * @remarks
- * If you only need to resize an encoder, use {@link resizeEncoder}.
- * If you only need to resize a decoder, use {@link resizeDecoder}.
- *
- * ```ts
- * const bytes = resizeEncoder(getU32Encoder(), (size) => size + 2).encode(0xffff);
- * const value = resizeDecoder(getU32Decoder(), (size) => size + 2).decode(bytes);
- * ```
- *
- * @see {@link resizeEncoder}
- * @see {@link resizeDecoder}
- */
-export declare function resizeCodec<TFrom, TTo extends TFrom, TSize extends number, TNewSize extends number>(codec: FixedSizeCodec<TFrom, TTo, TSize>, resize: (size: TSize) => TNewSize): FixedSizeCodec<TFrom, TTo, TNewSize>;
-export declare function resizeCodec<TCodec extends AnyCodec>(codec: TCodec, resize: (size: number) => number): TCodec;
-export {};
-//# sourceMappingURL=resize-codec.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/resize-codec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resize-codec.d.ts","sourceRoot":"","sources":["../../src/resize-codec.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,EAGL,OAAO,EACP,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAEnB,MAAM,SAAS,CAAC;AAIjB,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC9E,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EACvC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACrC,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EACrD,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,QAAQ,CAAC;AA8BZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC9E,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EACvC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACrC,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EACrD,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,QAAQ,CAAC;AAkBZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC/F,KAAK,EAAE,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EACxC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AACxC,wBAAgB,WAAW,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAAC"}