@solana/codecs-core 2.0.0-experimental.fcff844 → 2.0.0-experimental.fd64233

package/README.md

@@ -14,12 +14,397 @@
 
 # @solana/codecs-core
 
-This package contains the core types and function for encoding and decoding data structures on Solana. It can be used standalone, but it is also exported as part of the Solana JavaScript SDK [`@solana/web3.js@experimental`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
+This package contains the core types and functions for encoding and decoding data structures on Solana. It can be used standalone, but it is also exported as part of the Solana JavaScript SDK [`@solana/web3.js@experimental`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
 
-## Types
+This package is also part of the [`@solana/codecs` package](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs) which acts as an entry point for all codec packages as well as for their documentation.
 
-TODO
+## Composing codecs
 
-## Functions
+The easiest way to create your own codecs is to compose the [various codecs](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs) offered by this library. For instance, here’s how you would define a codec for a `Person` object that contains a `name` string attribute and an `age` number stored in 4 bytes.
 
-TODO
+```ts
+type Person = { name: string; age: number };
+const getPersonCodec = (): Codec<Person> =>
+    getStructCodec([
+        ['name', getStringCodec()],
+        ['age', getU32Codec()],
+    ]);
+```
+
+This function returns a `Codec` object which contains both an `encode` and `decode` function that can be used to convert a `Person` type to and from a `Uint8Array`.
+
+```ts
+const personCodec = getPersonCodec();
+const bytes = personCodec.encode({ name: 'John', age: 42 });
+const person = personCodec.decode(bytes);
+```
+
+There is a significant library of composable codecs at your disposal, enabling you to compose complex types. You may be interested in the documentation of these other packages to learn more about them:
+
+-   [`@solana/codecs-numbers`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs-numbers) for number codecs.
+-   [`@solana/codecs-strings`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs-strings) for string codecs.
+-   [`@solana/codecs-data-structures`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs-data-structures) for many data structure codecs such as objects, arrays, tuples, sets, maps, scalar enums, data enums, booleans, etc.
+-   [`@solana/options`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/options) for a Rust-like `Option` type and associated codec.
+
+You may also be interested in some of the helpers of this `@solana/codecs-core` library such as `mapCodec`, `fixCodec` or `reverseCodec` that create new codecs from existing ones.
+
+Note that all of these libraries are included in the [`@solana/codecs` package](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs) as well as the main `@solana/web3.js` package for your convenience.
+
+## Composing encoders and decoders
+
+Whilst Codecs can both encode and decode, it is possible to only focus on encoding or decoding data, enabling the unused logic to be tree-shaken. For instance, here’s our previous example using Encoders only to encode a `Person` type.
+
+```ts
+const getPersonEncoder = (): Encoder<Person> =>
+    getStructEncoder([
+        ['name', getStringEncoder()],
+        ['age', getU32Encoder()],
+    ]);
+
+const bytes = getPersonEncoder().encode({ name: 'John', age: 42 });
+```
+
+The same can be done for decoding the `Person` type by using Decoders like so.
+
+```ts
+const getPersonDecoder = (): Decoder<Person> =>
+    getStructDecoder([
+        ['name', getStringDecoder()],
+        ['age', getU32Decoder()],
+    ]);
+
+const person = getPersonDecoder().decode(bytes);
+```
+
+## Combining encoders and decoders
+
+Separating Codecs into Encoders and Decoders is particularly good practice for library maintainers as it allows their users to tree-shake any of the encoders and/or decoders they don’t need. However, we may still want to offer a codec helper for users who need both for convenience.
+
+That’s why this library offers a `combineCodec` helper that creates a `Codec` instance from a matching `Encoder` and `Decoder`.
+
+```ts
+const getPersonCodec = (): Codec<Person> => combineCodec(getPersonEncoder(), getPersonDecoder());
+```
+
+This means library maintainers can offer Encoders, Decoders and Codecs for all their types whilst staying efficient and tree-shakeable. In summary, we recommend the following pattern when creating codecs for library types.
+
+```ts
+type MyType = /* ... */;
+const getMyTypeEncoder = (): Encoder<MyType> => { /* ... */ };
+const getMyTypeDecoder = (): Decoder<MyType> => { /* ... */ };
+const getMyTypeCodec = (): Codec<MyType> =>
+    combineCodec(getMyTypeEncoder(), getMyTypeDecoder());
+```
+
+## Different From and To types
+
+When creating codecs, the encoded type is allowed to be looser than the decoded type. A good example of that is the u64 number codec:
+
+```ts
+const u64Codec: Codec<number | bigint, bigint> = getU64Codec();
+```
+
+As you can see, the first type parameter is looser since it accepts numbers or big integers, whereas the second type parameter only accepts big integers. That’s because when _encoding_ a u64 number, you may provide either a `bigint` or a `number` for convenience. However, when you decode a u64 number, you will always get a `bigint` because not all u64 values can fit in a JavaScript `number` type.
+
+```ts
+const bytes = u64Codec.encode(42);
+const value = u64Codec.decode(bytes); // BigInt(42)
+```
+
+This relationship between the type we encode “From” and decode “To” can be generalized in TypeScript as `To extends From`.
+
+Here’s another example using an object with default values. You can read more about the `mapEncoder` helper below.
+
+```ts
+type Person = { name: string, age: number };
+type PersonInput = { name: string, age?: number };
+
+const getPersonEncoder = (): Encoder<PersonInput> =>
+    mapEncoder(
+        getStructEncoder([
+            ['name', getStringEncoder()],
+            ['age', getU32Encoder()],
+        ]),
+        input => { ...input, age: input.age ?? 42 }
+    );
+
+const getPersonDecoder = (): Decoder<Person> =>
+    getStructEncoder([
+        ['name', getStringEncoder()],
+        ['age', getU32Encoder()],
+    ]);
+
+const getPersonCodec = (): Codec<PersonInput, Person> =>
+  combineCodec(getPersonEncoder(), getPersonDecoder())
+```
+
+## Fixed-size and variable-size codecs
+
+It is also worth noting that Codecs can either be of fixed size or variable size.
+
+`FixedSizeCodecs` have a `fixedSize` number attribute that tells us exactly how big their encoded data is in bytes.
+
+```ts
+const myCodec: FixedSizeCodec<number> = getU32Codec();
+myCodec.fixedSize; // 4 bytes.
+```
+
+On the other hand, `VariableSizeCodecs` do not know the size of their encoded data in advance. Instead, they will grab that information either from the provided encoded data or from the value to encode. For the former, we can simply access the length of the `Uint8Array`. For the latter, it provides a `getSizeFromValue` that tells us the encoded byte size of the provided value.
+
+```ts
+const myCodec: VariableSizeCodec<string> = getStringCodec({
+    size: getU32Codec(),
+});
+myCodec.getSizeFromValue('hello world'); // 4 + 11 bytes.
+```
+
+Also note that, if the `VariableSizeCodec` is bounded by a maximum size, it can be provided as a `maxSize` number attribute.
+
+The following type guards are available to identify and/or assert the size of codecs: `isFixedSize`, `isVariableSize`, `assertIsFixedSize` and `assertIsVariableSize`.
+
+Finally, note that the same is true for `Encoders` and `Decoders`.
+
+-   A `FixedSizeEncoder` has a `fixedSize` number attribute.
+-   A `VariableSizeEncoder` has a `getSizeFromValue` function and an optional `maxSize` number attribute.
+-   A `FixedSizeDecoder` has a `fixedSize` number attribute.
+-   A `VariableSizeDecoder` has an optional `maxSize` number attribute.
+
+## Creating custom codecs
+
+If composing codecs isn’t enough for you, you may implement your own codec logic by using the `createCodec` function. This function requires an object with a `read` and a `write` function telling us how to read from and write to an existing byte array.
+
+The `read` function accepts the `bytes` to decode from and the `offset` at each we should start reading. It returns an array with two items:
+
+-   The first item should be the decoded value.
+-   The second item should be the next offset to read from.
+
+```ts
+createCodec({
+    read(bytes, offset) {
+        const value = bytes[offset];
+        return [value, offset + 1];
+    },
+    // ...
+});
+```
+
+Reciprocally, the `write` function accepts the `value` to encode, the array of `bytes` to write the encoded value to and the `offset` at which it should be written. It should encode the given value, insert it in the byte array, and provide the next offset to write to as the return value.
+
+```ts
+createCodec({
+    write(value, bytes, offset) {
+        bytes.set(value, offset);
+        return offset + 1;
+    },
+    // ...
+});
+```
+
+Additionally, we must specify the size of the codec. If we are defining a `FixedSizeCodec`, we must simply provide the `fixedSize` number attribute. For `VariableSizeCodecs`, we must provide the `getSizeFromValue` function as described in the previous section.
+
+```ts
+// FixedSizeCodec.
+createCodec({
+    fixedSize: 1,
+    // ...
+});
+
+// VariableSizeCodec.
+createCodec({
+    getSizeFromValue: (value: string) => value.length,
+    // ...
+});
+```
+
+Here’s a concrete example of a custom codec that encodes any unsigned integer in a single byte. Since a single byte can only store integers from 0 to 255, if any other integer is provided it will take its modulo 256 to ensure it fits in a single byte. Because it always requires a single byte, that codec is a `FixedSizeCodec` of size `1`.
+
+```ts
+const getModuloU8Codec = () =>
+    createCodec<number>({
+        fixedSize: 1,
+        read(bytes, offset) {
+            const value = bytes[offset];
+            return [value, offset + 1];
+        },
+        write(value, bytes, offset) {
+            bytes.set(value % 256, offset);
+            return offset + 1;
+        },
+    });
+```
+
+Note that, it is also possible to create custom encoders and decoders separately by using the `createEncoder` and `createDecoder` functions respectively and then use the `combineCodec` function on them just like we were doing with composed codecs.
+
+This approach is recommended to library maintainers as it allows their users to tree-shake any of the encoders and/or decoders they don’t need.
+
+Here’s our previous modulo u8 example but split into separate `Encoder`, `Decoder` and `Codec` instances.
+
+```ts
+const getModuloU8Encoder = () =>
+    createEncoder<number>({
+        fixedSize: 1,
+        write(value, bytes, offset) {
+            bytes.set(value % 256, offset);
+            return offset + 1;
+        },
+    });
+
+const getModuloU8Decoder = () =>
+    createDecoder<number>({
+        fixedSize: 1,
+        read(bytes, offset) {
+            const value = bytes[offset];
+            return [value, offset + 1];
+        },
+    });
+
+const getModuloU8Codec = () => combineCodec(getModuloU8Encoder(), getModuloU8Decoder());
+```
+
+Here’s another example returning a `VariableSizeCodec`. This one transforms a simple string composed of characters from `a` to `z` to a buffer of numbers from `1` to `26` where `0` bytes are spaces.
+
+```ts
+const alphabet = ' abcdefghijklmnopqrstuvwxyz';
+
+const getCipherEncoder = () =>
+    createEncoder<string>({
+        getSizeFromValue: value => value.length,
+        write(value, bytes, offset) {
+            const bytesToAdd = [...value].map(char => alphabet.indexOf(char));
+            bytes.set(bytesToAdd, offset);
+            return offset + bytesToAdd.length;
+        },
+    });
+
+const getCipherDecoder = () =>
+    createDecoder<string>({
+        read(bytes, offset) {
+            const value = [...bytes.slice(offset)].map(byte => alphabet.charAt(byte)).join('');
+            return [value, bytes.length];
+        },
+    });
+
+const getCipherCodec = () => combineCodec(getCipherEncoder(), getCipherDecoder());
+```
+
+## Mapping codecs
+
+It is possible to transform a `Codec<T>` to a `Codec<U>` by providing two mapping functions: one that goes from `T` to `U` and one that does the opposite.
+
+For instance, here’s how you would map a `u32` integer into a `string` representation of that number.
+
+```ts
+const getStringU32Codec = () =>
+    mapCodec(
+        getU32Codec(),
+        (integerAsString: string): number => parseInt(integerAsString),
+        (integer: number): string => integer.toString(),
+    );
+
+getStringU32Codec().encode('42'); // new Uint8Array([42])
+getStringU32Codec().decode(new Uint8Array([42])); // "42"
+```
+
+If a `Codec` has [different From and To types](#different-from-and-to-types), say `Codec<OldFrom, OldTo>`, and we want to map it to `Codec<NewFrom, NewTo>`, we must provide functions that map from `NewFrom` to `OldFrom` and from `OldTo` to `NewTo`.
+
+To illustrate that, let’s take our previous `getStringU32Codec` example but make it use a `getU64Codec` codec instead as it returns a `Codec<number | bigint, bigint>`. Additionally, let’s make it so our `getStringU64Codec` function returns a `Codec<number | string, string>` so that it also accepts numbers when encoding values. Here’s what our mapping functions look like:
+
+```ts
+const getStringU64Codec = () =>
+    mapCodec(
+        getU64Codec(),
+        (integerInput: number | string): number | bigint =>
+            typeof integerInput === 'string' ? BigInt(integerAsString) : integerInput,
+        (integer: bigint): string => integer.toString(),
+    );
+```
+
+Note that the second function that maps the decoded type is optional. That means, you can omit it to simply update or loosen the type to encode whilst keeping the decoded type the same.
+
+This is particularly useful to provide default values to object structures. For instance, here’s how we can map our `Person` codec to give a default value to its `age` attribute.
+
+```ts
+type Person = { name: string; age: number; }
+const getPersonCodec = (): Codec<Person> => { /*...*/ }
+
+type PersonInput = { name: string; age?: number; }
+const getPersonWithDefaultValueCodec = (): Codec<PersonInput, Person> =>
+    mapCodec(
+        getPersonCodec(),
+        (person: PersonInput): Person => { ...person, age: person.age ?? 42 }
+    )
+```
+
+Similar helpers exist to map `Encoder` and `Decoder` instances allowing you to separate your codec logic into tree-shakeable functions. Here’s our `getStringU32Codec` written that way.
+
+```ts
+const getStringU32Encoder = () =>
+    mapEncoder(getU32Encoder(), (integerAsString: string): number => parseInt(integerAsString));
+const getStringU32Decoder = () => mapDecoder(getU32Decoder(), (integer: number): string => integer.toString());
+const getStringU32Codec = () => combineCodec(getStringU32Encoder(), getStringU32Decoder());
+```
+
+## Fixing the size of codecs
+
+The `fixCodec` function allows you to bind the size of a given codec to the given fixed size.
+
+For instance, say you want to represent a base-58 string that uses exactly 32 bytes when decoded. Here’s how you can use the `fixCodec` helper to achieve that.
+
+```ts
+const get32BytesBase58Codec = () => fixCodec(getBase58Codec(), 32);
+```
+
+You may also use the `fixEncoder` and `fixDecoder` functions to separate your codec logic like so:
+
+```ts
+const get32BytesBase58Encoder = () => fixEncoder(getBase58Encoder(), 32);
+const get32BytesBase58Decoder = () => fixDecoder(getBase58Decoder(), 32);
+const get32BytesBase58Codec = () => combineCodec(get32BytesBase58Encoder(), get32BytesBase58Codec());
+```
+
+## Reversing codecs
+
+The `reverseCodec` helper reverses the bytes of the provided `FixedSizeCodec`.
+
+```ts
+const getBigEndianU64Codec = () => reverseCodec(getU64Codec());
+```
+
+Note that number codecs can already do that for you via their `endian` option.
+
+```ts
+const getBigEndianU64Codec = () => getU64Codec({ endian: Endian.BIG });
+```
+
+As usual, the `reverseEncoder` and `reverseDecoder` can also be used to achieve that.
+
+```ts
+const getBigEndianU64Encoder = () => reverseEncoder(getU64Encoder());
+const getBigEndianU64Decoder = () => reverseDecoder(getU64Decoder());
+const getBigEndianU64Codec = () => combineCodec(getBigEndianU64Encoder(), getBigEndianU64Decoder());
+```
+
+## Byte helpers
+
+This package also provides utility functions for managing bytes such as:
+
+-   `mergeBytes`: Concatenates an array of `Uint8Arrays` into a single `Uint8Array`.
+-   `padBytes`: Pads a `Uint8Array` with zeroes (to the right) to the specified length.
+-   `fixBytes`: Pads or truncates a `Uint8Array` so it has the specified length.
+
+```ts
+// Merge multiple Uint8Array buffers into one.
+mergeBytes([new Uint8Array([1, 2]), new Uint8Array([3, 4])]); // Uint8Array([1, 2, 3, 4])
+
+// Pad a Uint8Array buffer to the given size.
+padBytes(new Uint8Array([1, 2]), 4); // Uint8Array([1, 2, 0, 0])
+padBytes(new Uint8Array([1, 2, 3, 4]), 2); // Uint8Array([1, 2, 3, 4])
+
+// Pad and truncate a Uint8Array buffer to the given size.
+fixBytes(new Uint8Array([1, 2]), 4); // Uint8Array([1, 2, 0, 0])
+fixBytes(new Uint8Array([1, 2, 3, 4]), 2); // Uint8Array([1, 2])
+```
+
+---
+
+To read more about the available codecs and how to use them, check out the documentation of the main [`@solana/codecs` package](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs).

package/dist/types/combine-codec.d.ts

@@ -1,4 +1,4 @@
-import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from './codec';
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from './codec.js';
 /**
  * Combines an encoder and a decoder into a codec.
  * The encoder and decoder must have the same fixed size, max size and description.

package/dist/types/fix-codec.d.ts

@@ -1,4 +1,4 @@
-import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec';
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec.js';
 /**
  * Creates a fixed-size encoder from a given encoder.
  *

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
-export * from './assertions';
-export * from './bytes';
-export * from './codec';
-export * from './combine-codec';
-export * from './fix-codec';
-export * from './map-codec';
-export * from './reverse-codec';
+export * from './assertions.js';
+export * from './bytes.js';
+export * from './codec.js';
+export * from './combine-codec.js';
+export * from './fix-codec.js';
+export * from './map-codec.js';
+export * from './reverse-codec.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/map-codec.d.ts

@@ -1,4 +1,4 @@
-import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from './codec';
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from './codec.js';
 /**
  * Converts an encoder A to a encoder B by mapping their values.
  */

package/dist/types/reverse-codec.d.ts

@@ -1,4 +1,4 @@
-import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec';
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec.js';
 /**
  * Reverses the bytes of a fixed-size encoder.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/codecs-core",
-  "version": "2.0.0-experimental.fcff844",
+  "version": "2.0.0-experimental.fd64233",
   "description": "Core types and helpers for encoding and decoding byte arrays on Solana",
   "exports": {
     "browser": {
@@ -51,8 +51,8 @@
   "devDependencies": {
     "@solana/eslint-config-solana": "^1.0.2",
     "@swc/jest": "^0.2.29",
-    "@types/jest": "^29.5.6",
-    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.13.2",
     "@typescript-eslint/parser": "^6.3.0",
     "agadoo": "^3.0.0",
     "eslint": "^8.45.0",
@@ -79,8 +79,8 @@
     ]
   },
   "scripts": {
-    "compile:js": "tsup --config build-scripts/tsup.config.library.ts",
-    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/build-scripts/add-js-extension-to-types.mjs",
     "dev": "jest -c node_modules/test-config/jest-dev.config.ts --rootDir . --watch",
     "publish-packages": "pnpm publish --tag experimental --access public --no-git-checks",
     "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",

package/dist/index.development.js

@@ -1,233 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-  'use strict';
-
-  // src/assertions.ts
-  function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
-    if (bytes.length - offset <= 0) {
-      throw new Error(`Codec [${codecDescription}] cannot decode empty byte arrays.`);
-    }
-  }
-  function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
-    const bytesLength = bytes.length - offset;
-    if (bytesLength < expected) {
-      throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);
-    }
-  }
-
-  // src/bytes.ts
-  var mergeBytes = (byteArrays) => {
-    const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
-    if (nonEmptyByteArrays.length === 0) {
-      return byteArrays.length ? byteArrays[0] : new Uint8Array();
-    }
-    if (nonEmptyByteArrays.length === 1) {
-      return nonEmptyByteArrays[0];
-    }
-    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    nonEmptyByteArrays.forEach((arr) => {
-      result.set(arr, offset);
-      offset += arr.length;
-    });
-    return result;
-  };
-  var padBytes = (bytes, length) => {
-    if (bytes.length >= length)
-      return bytes;
-    const paddedBytes = new Uint8Array(length).fill(0);
-    paddedBytes.set(bytes);
-    return paddedBytes;
-  };
-  var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
-
-  // src/codec.ts
-  function getEncodedSize(value, encoder) {
-    return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
-  }
-  function createEncoder(encoder) {
-    return Object.freeze({
-      ...encoder,
-      encode: (value) => {
-        const bytes = new Uint8Array(getEncodedSize(value, encoder));
-        encoder.write(value, bytes, 0);
-        return bytes;
-      }
-    });
-  }
-  function createDecoder(decoder) {
-    return Object.freeze({
-      ...decoder,
-      decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
-    });
-  }
-  function createCodec(codec) {
-    return Object.freeze({
-      ...codec,
-      decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],
-      encode: (value) => {
-        const bytes = new Uint8Array(getEncodedSize(value, codec));
-        codec.write(value, bytes, 0);
-        return bytes;
-      }
-    });
-  }
-  function isFixedSize(codec) {
-    return "fixedSize" in codec && typeof codec.fixedSize === "number";
-  }
-  function assertIsFixedSize(codec, message) {
-    if (!isFixedSize(codec)) {
-      throw new Error(message != null ? message : "Expected a fixed-size codec, got a variable-size one.");
-    }
-  }
-  function isVariableSize(codec) {
-    return !isFixedSize(codec);
-  }
-  function assertIsVariableSize(codec, message) {
-    if (!isVariableSize(codec)) {
-      throw new Error(message != null ? message : "Expected a variable-size codec, got a fixed-size one.");
-    }
-  }
-
-  // src/combine-codec.ts
-  function combineCodec(encoder, decoder) {
-    if (isFixedSize(encoder) !== isFixedSize(decoder)) {
-      throw new Error(`Encoder and decoder must either both be fixed-size or variable-size.`);
-    }
-    if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
-      throw new Error(
-        `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
-      );
-    }
-    if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
-      throw new Error(
-        `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
-      );
-    }
-    return {
-      ...decoder,
-      ...encoder,
-      decode: decoder.decode,
-      encode: encoder.encode,
-      read: decoder.read,
-      write: encoder.write
-    };
-  }
-
-  // src/fix-codec.ts
-  function fixEncoder(encoder, fixedBytes) {
-    return createEncoder({
-      fixedSize: fixedBytes,
-      write: (value, bytes, offset) => {
-        const variableByteArray = encoder.encode(value);
-        const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
-        bytes.set(fixedByteArray, offset);
-        return offset + fixedBytes;
-      }
-    });
-  }
-  function fixDecoder(decoder, fixedBytes) {
-    return createDecoder({
-      fixedSize: fixedBytes,
-      read: (bytes, offset) => {
-        assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes, offset);
-        if (offset > 0 || bytes.length > fixedBytes) {
-          bytes = bytes.slice(offset, offset + fixedBytes);
-        }
-        if (isFixedSize(decoder)) {
-          bytes = fixBytes(bytes, decoder.fixedSize);
-        }
-        const [value] = decoder.read(bytes, 0);
-        return [value, offset + fixedBytes];
-      }
-    });
-  }
-  function fixCodec(codec, fixedBytes) {
-    return combineCodec(fixEncoder(codec, fixedBytes), fixDecoder(codec, fixedBytes));
-  }
-
-  // src/map-codec.ts
-  function mapEncoder(encoder, unmap) {
-    return createEncoder({
-      ...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
-      write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
-    });
-  }
-  function mapDecoder(decoder, map) {
-    return createDecoder({
-      ...decoder,
-      read: (bytes, offset) => {
-        const [value, newOffset] = decoder.read(bytes, offset);
-        return [map(value, bytes, offset), newOffset];
-      }
-    });
-  }
-  function mapCodec(codec, unmap, map) {
-    return createCodec({
-      ...mapEncoder(codec, unmap),
-      read: map ? mapDecoder(codec, map).read : codec.read
-    });
-  }
-
-  // src/reverse-codec.ts
-  function reverseEncoder(encoder) {
-    assertIsFixedSize(encoder, "Cannot reverse a codec of variable size.");
-    return createEncoder({
-      ...encoder,
-      write: (value, bytes, offset) => {
-        const newOffset = encoder.write(value, bytes, offset);
-        const slice = bytes.slice(offset, offset + encoder.fixedSize).reverse();
-        bytes.set(slice, offset);
-        return newOffset;
-      }
-    });
-  }
-  function reverseDecoder(decoder) {
-    assertIsFixedSize(decoder, "Cannot reverse a codec of variable size.");
-    return createDecoder({
-      ...decoder,
-      read: (bytes, offset) => {
-        const reverseEnd = offset + decoder.fixedSize;
-        if (offset === 0 && bytes.length === reverseEnd) {
-          return decoder.read(bytes.reverse(), offset);
-        }
-        const reversedBytes = bytes.slice();
-        reversedBytes.set(bytes.slice(offset, reverseEnd).reverse(), offset);
-        return decoder.read(reversedBytes, offset);
-      }
-    });
-  }
-  function reverseCodec(codec) {
-    return combineCodec(reverseEncoder(codec), reverseDecoder(codec));
-  }
-
-  exports.assertByteArrayHasEnoughBytesForCodec = assertByteArrayHasEnoughBytesForCodec;
-  exports.assertByteArrayIsNotEmptyForCodec = assertByteArrayIsNotEmptyForCodec;
-  exports.assertIsFixedSize = assertIsFixedSize;
-  exports.assertIsVariableSize = assertIsVariableSize;
-  exports.combineCodec = combineCodec;
-  exports.createCodec = createCodec;
-  exports.createDecoder = createDecoder;
-  exports.createEncoder = createEncoder;
-  exports.fixBytes = fixBytes;
-  exports.fixCodec = fixCodec;
-  exports.fixDecoder = fixDecoder;
-  exports.fixEncoder = fixEncoder;
-  exports.getEncodedSize = getEncodedSize;
-  exports.isFixedSize = isFixedSize;
-  exports.isVariableSize = isVariableSize;
-  exports.mapCodec = mapCodec;
-  exports.mapDecoder = mapDecoder;
-  exports.mapEncoder = mapEncoder;
-  exports.mergeBytes = mergeBytes;
-  exports.padBytes = padBytes;
-  exports.reverseCodec = reverseCodec;
-  exports.reverseDecoder = reverseDecoder;
-  exports.reverseEncoder = reverseEncoder;
-
-  return exports;
-
-})({});
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.development.js.map

package/dist/index.development.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/assertions.ts","../src/bytes.ts","../src/codec.ts","../src/combine-codec.ts","../src/fix-codec.ts","../src/map-codec.ts","../src/reverse-codec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Asserts that a given byte array is not empty.\n */\nexport function assertByteArrayIsNotEmptyForCodec(codecDescription: string, bytes: Uint8Array, offset = 0) {\n    if (bytes.length - offset <= 0) {\n        // TODO: Coded error.\n        throw new Error(`Codec [${codecDescription}] cannot decode empty byte arrays.`);\n    }\n}\n\n/**\n * Asserts that a given byte array has enough bytes to decode.\n */\nexport function assertByteArrayHasEnoughBytesForCodec(\n    codecDescription: string,\n    expected: number,\n    bytes: Uint8Array,\n    offset = 0,\n) {\n    const bytesLength = bytes.length - offset;\n    if (bytesLength < expected) {\n        // TODO: Coded error.\n        throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);\n    }\n}\n","/**\n * Concatenates an array of `Uint8Array`s into a single `Uint8Array`.\n * Reuses the original byte array when applicable.\n */\nexport const mergeBytes = (byteArrays: Uint8Array[]): Uint8Array => {\n    const nonEmptyByteArrays = byteArrays.filter(arr => arr.length);\n    if (nonEmptyByteArrays.length === 0) {\n        return byteArrays.length ? byteArrays[0] : new Uint8Array();\n    }\n\n    if (nonEmptyByteArrays.length === 1) {\n        return nonEmptyByteArrays[0];\n    }\n\n    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);\n    const result = new Uint8Array(totalLength);\n    let offset = 0;\n    nonEmptyByteArrays.forEach(arr => {\n        result.set(arr, offset);\n        offset += arr.length;\n    });\n    return result;\n};\n\n/**\n * Pads a `Uint8Array` with zeroes to the specified length.\n * If the array is longer than the specified length, it is returned as-is.\n */\nexport const padBytes = (bytes: Uint8Array, length: number): Uint8Array => {\n    if (bytes.length >= length) return bytes;\n    const paddedBytes = new Uint8Array(length).fill(0);\n    paddedBytes.set(bytes);\n    return paddedBytes;\n};\n\n/**\n * Fixes a `Uint8Array` to the specified length.\n * If the array is longer than the specified length, it is truncated.\n * If the array is shorter than the specified length, it is padded with zeroes.\n */\nexport const fixBytes = (bytes: Uint8Array, length: number): Uint8Array =>\n    padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);\n","/**\n * Defines an offset in bytes.\n */\nexport type Offset = number;\n\ntype BaseEncoder<TFrom> = {\n    /** Encode the provided value and return the encoded bytes directly. */\n    readonly encode: (value: TFrom) => Uint8Array;\n    /**\n     * Writes the encoded value into the provided byte array at the given offset.\n     * Returns the offset of the next byte after the encoded value.\n     */\n    readonly write: (value: TFrom, bytes: Uint8Array, offset: Offset) => Offset;\n};\n\nexport type FixedSizeEncoder<TFrom, TSize extends number = number> = BaseEncoder<TFrom> & {\n    /** The fixed size of the encoded value in bytes. */\n    readonly fixedSize: TSize;\n};\n\nexport type VariableSizeEncoder<TFrom> = BaseEncoder<TFrom> & {\n    /** The total size of the encoded value in bytes. */\n    readonly getSizeFromValue: (value: TFrom) => number;\n    /** The maximum size an encoded value can be in bytes, if applicable. */\n    readonly maxSize?: number;\n};\n\n/**\n * An object that can encode a value to a `Uint8Array`.\n */\nexport type Encoder<TFrom> = FixedSizeEncoder<TFrom> | VariableSizeEncoder<TFrom>;\n\ntype BaseDecoder<TTo> = {\n    /** Decodes the provided byte array at the given offset (or zero) and returns the value directly. */\n    readonly decode: (bytes: Uint8Array, offset?: Offset) => TTo;\n    /**\n     * Reads the encoded value from the provided byte array at the given offset.\n     * Returns the decoded value and the offset of the next byte after the encoded value.\n     */\n    readonly read: (bytes: Uint8Array, offset: Offset) => [TTo, Offset];\n};\n\nexport type FixedSizeDecoder<TTo, TSize extends number = number> = BaseDecoder<TTo> & {\n    /** The fixed size of the encoded value in bytes. */\n    readonly fixedSize: TSize;\n};\n\nexport type VariableSizeDecoder<TTo> = BaseDecoder<TTo> & {\n    /** The maximum size an encoded value can be in bytes, if applicable. */\n    readonly maxSize?: number;\n};\n\n/**\n * An object that can decode a value from a `Uint8Array`.\n */\nexport type Decoder<TTo> = FixedSizeDecoder<TTo> | VariableSizeDecoder<TTo>;\n\nexport type FixedSizeCodec<TFrom, TTo extends TFrom = TFrom, TSize extends number = number> = FixedSizeEncoder<\n    TFrom,\n    TSize\n> &\n    FixedSizeDecoder<TTo, TSize>;\n\nexport type VariableSizeCodec<TFrom, TTo extends TFrom = TFrom> = VariableSizeEncoder<TFrom> & VariableSizeDecoder<TTo>;\n\n/**\n * An object that can encode and decode a value to and from a `Uint8Array`.\n * It supports encoding looser types than it decodes for convenience.\n * For example, a `bigint` encoder will always decode to a `bigint`\n * but can be used to encode a `number`.\n *\n * @typeParam TFrom - The type of the value to encode.\n * @typeParam TTo - The type of the decoded value. Defaults to `TFrom`.\n */\nexport type Codec<TFrom, TTo extends TFrom = TFrom> = FixedSizeCodec<TFrom, TTo> | VariableSizeCodec<TFrom, TTo>;\n\n/**\n * Get the encoded size of a given value in bytes.\n */\nexport function getEncodedSize<TFrom>(\n    value: TFrom,\n    encoder: { fixedSize: number } | { getSizeFromValue: (value: TFrom) => number },\n): number {\n    return 'fixedSize' in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);\n}\n\n/** Fills the missing `encode` function using the existing `write` function. */\nexport function createEncoder<TFrom, TSize extends number>(\n    encoder: Omit<FixedSizeEncoder<TFrom, TSize>, 'encode'>,\n): FixedSizeEncoder<TFrom, TSize>;\nexport function createEncoder<TFrom>(encoder: Omit<VariableSizeEncoder<TFrom>, 'encode'>): VariableSizeEncoder<TFrom>;\nexport function createEncoder<TFrom>(\n    encoder: Omit<FixedSizeEncoder<TFrom>, 'encode'> | Omit<VariableSizeEncoder<TFrom>, 'encode'>,\n): Encoder<TFrom>;\nexport function createEncoder<TFrom>(\n    encoder: Omit<FixedSizeEncoder<TFrom>, 'encode'> | Omit<VariableSizeEncoder<TFrom>, 'encode'>,\n): Encoder<TFrom> {\n    return Object.freeze({\n        ...encoder,\n        encode: value => {\n            const bytes = new Uint8Array(getEncodedSize(value, encoder));\n            encoder.write(value, bytes, 0);\n            return bytes;\n        },\n    });\n}\n\n/** Fills the missing `decode` function using the existing `read` function. */\nexport function createDecoder<TTo, TSize extends number>(\n    decoder: Omit<FixedSizeDecoder<TTo, TSize>, 'decode'>,\n): FixedSizeDecoder<TTo, TSize>;\nexport function createDecoder<TTo>(decoder: Omit<VariableSizeDecoder<TTo>, 'decode'>): VariableSizeDecoder<TTo>;\nexport function createDecoder<TTo>(\n    decoder: Omit<FixedSizeDecoder<TTo>, 'decode'> | Omit<VariableSizeDecoder<TTo>, 'decode'>,\n): Decoder<TTo>;\nexport function createDecoder<TTo>(\n    decoder: Omit<FixedSizeDecoder<TTo>, 'decode'> | Omit<VariableSizeDecoder<TTo>, 'decode'>,\n): Decoder<TTo> {\n    return Object.freeze({\n        ...decoder,\n        decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0],\n    });\n}\n\n/** Fills the missing `encode` and `decode` function using the existing `write` and `read` functions. */\nexport function createCodec<TFrom, TTo extends TFrom = TFrom, TSize extends number = number>(\n    codec: Omit<FixedSizeCodec<TFrom, TTo, TSize>, 'encode' | 'decode'>,\n): FixedSizeCodec<TFrom, TTo, TSize>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec: Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): VariableSizeCodec<TFrom, TTo>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec:\n        | Omit<FixedSizeCodec<TFrom, TTo>, 'encode' | 'decode'>\n        | Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): Codec<TFrom, TTo>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec:\n        | Omit<FixedSizeCodec<TFrom, TTo>, 'encode' | 'decode'>\n        | Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): Codec<TFrom, TTo> {\n    return Object.freeze({\n        ...codec,\n        decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],\n        encode: value => {\n            const bytes = new Uint8Array(getEncodedSize(value, codec));\n            codec.write(value, bytes, 0);\n            return bytes;\n        },\n    });\n}\n\nexport function isFixedSize<TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize> | VariableSizeEncoder<TFrom>,\n): encoder is FixedSizeEncoder<TFrom, TSize>;\nexport function isFixedSize<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize> | VariableSizeDecoder<TTo>,\n): decoder is FixedSizeDecoder<TTo, TSize>;\nexport function isFixedSize<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: FixedSizeCodec<TFrom, TTo, TSize> | VariableSizeCodec<TFrom, TTo>,\n): codec is FixedSizeCodec<TFrom, TTo, TSize>;\nexport function isFixedSize<TSize extends number>(\n    codec: { fixedSize: TSize } | { maxSize?: number },\n): codec is { fixedSize: TSize };\nexport function isFixedSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { fixedSize: number } {\n    return 'fixedSize' in codec && typeof codec.fixedSize === 'number';\n}\n\nexport function assertIsFixedSize<TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize> | VariableSizeEncoder<TFrom>,\n    message?: string,\n): asserts encoder is FixedSizeEncoder<TFrom, TSize>;\nexport function assertIsFixedSize<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize> | VariableSizeDecoder<TTo>,\n    message?: string,\n): asserts decoder is FixedSizeDecoder<TTo, TSize>;\nexport function assertIsFixedSize<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: FixedSizeCodec<TFrom, TTo, TSize> | VariableSizeCodec<TFrom, TTo>,\n    message?: string,\n): asserts codec is FixedSizeCodec<TFrom, TTo, TSize>;\nexport function assertIsFixedSize<TSize extends number>(\n    codec: { fixedSize: TSize } | { maxSize?: number },\n    message?: string,\n): asserts codec is { fixedSize: TSize };\nexport function assertIsFixedSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { fixedSize: number } {\n    if (!isFixedSize(codec)) {\n        // TODO: Coded error.\n        throw new Error(message ?? 'Expected a fixed-size codec, got a variable-size one.');\n    }\n}\n\nexport function isVariableSize<TFrom>(encoder: Encoder<TFrom>): encoder is VariableSizeEncoder<TFrom>;\nexport function isVariableSize<TTo>(decoder: Decoder<TTo>): decoder is VariableSizeDecoder<TTo>;\nexport function isVariableSize<TFrom, TTo extends TFrom>(\n    codec: Codec<TFrom, TTo>,\n): codec is VariableSizeCodec<TFrom, TTo>;\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number };\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number } {\n    return !isFixedSize(codec);\n}\n\nexport function assertIsVariableSize<T>(\n    encoder: Encoder<T>,\n    message?: string,\n): asserts encoder is VariableSizeEncoder<T>;\nexport function assertIsVariableSize<T>(\n    decoder: Decoder<T>,\n    message?: string,\n): asserts decoder is VariableSizeDecoder<T>;\nexport function assertIsVariableSize<TFrom, TTo extends TFrom>(\n    codec: Codec<TFrom, TTo>,\n    message?: string,\n): asserts codec is VariableSizeCodec<TFrom, TTo>;\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { maxSize?: number };\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { maxSize?: number } {\n    if (!isVariableSize(codec)) {\n        // TODO: Coded error.\n        throw new Error(message ?? 'Expected a variable-size codec, got a fixed-size one.');\n    }\n}\n","import {\n    Codec,\n    Decoder,\n    Encoder,\n    FixedSizeCodec,\n    FixedSizeDecoder,\n    FixedSizeEncoder,\n    isFixedSize,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from './codec';\n\n/**\n * Combines an encoder and a decoder into a codec.\n * The encoder and decoder must have the same fixed size, max size and description.\n * If a description is provided, it will override the encoder and decoder descriptions.\n */\nexport function combineCodec<TFrom, TTo extends TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize>,\n    decoder: FixedSizeDecoder<TTo, TSize>,\n): FixedSizeCodec<TFrom, TTo, TSize>;\nexport function combineCodec<TFrom, TTo extends TFrom>(\n    encoder: VariableSizeEncoder<TFrom>,\n    decoder: VariableSizeDecoder<TTo>,\n): VariableSizeCodec<TFrom, TTo>;\nexport function combineCodec<TFrom, TTo extends TFrom>(\n    encoder: Encoder<TFrom>,\n    decoder: Decoder<TTo>,\n): Codec<TFrom, TTo>;\nexport function combineCodec<TFrom, TTo extends TFrom>(\n    encoder: Encoder<TFrom>,\n    decoder: Decoder<TTo>,\n): Codec<TFrom, TTo> {\n    if (isFixedSize(encoder) !== isFixedSize(decoder)) {\n        // TODO: Coded error.\n        throw new Error(`Encoder and decoder must either both be fixed-size or variable-size.`);\n    }\n\n    if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {\n        // TODO: Coded error.\n        throw new Error(\n            `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`,\n        );\n    }\n\n    if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {\n        // TODO: Coded error.\n        throw new Error(\n            `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`,\n        );\n    }\n\n    return {\n        ...decoder,\n        ...encoder,\n        decode: decoder.decode,\n        encode: encoder.encode,\n        read: decoder.read,\n        write: encoder.write,\n    };\n}\n","import { assertByteArrayHasEnoughBytesForCodec } from './assertions';\nimport { fixBytes } from './bytes';\nimport {\n    Codec,\n    createDecoder,\n    createEncoder,\n    Decoder,\n    Encoder,\n    FixedSizeCodec,\n    FixedSizeDecoder,\n    FixedSizeEncoder,\n    isFixedSize,\n    Offset,\n} from './codec';\nimport { combineCodec } from './combine-codec';\n\n/**\n * Creates a fixed-size encoder from a given encoder.\n *\n * @param encoder - The encoder to wrap into a fixed-size encoder.\n * @param fixedBytes - The fixed number of bytes to write.\n */\nexport function fixEncoder<TFrom, TSize extends number>(\n    encoder: Encoder<TFrom>,\n    fixedBytes: TSize,\n): FixedSizeEncoder<TFrom, TSize> {\n    return createEncoder({\n        fixedSize: fixedBytes,\n        write: (value: TFrom, bytes: Uint8Array, offset: Offset) => {\n            // Here we exceptionally use the `encode` function instead of the `write`\n            // function as using the nested `write` function on a fixed-sized byte\n            // array may result in a out-of-bounds error on the nested encoder.\n            const variableByteArray = encoder.encode(value);\n            const fixedByteArray =\n                variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;\n            bytes.set(fixedByteArray, offset);\n            return offset + fixedBytes;\n        },\n    });\n}\n\n/**\n * Creates a fixed-size decoder from a given decoder.\n *\n * @param decoder - The decoder to wrap into a fixed-size decoder.\n * @param fixedBytes - The fixed number of bytes to read.\n */\nexport function fixDecoder<TTo, TSize extends number>(\n    decoder: Decoder<TTo>,\n    fixedBytes: TSize,\n): FixedSizeDecoder<TTo, TSize> {\n    return createDecoder({\n        fixedSize: fixedBytes,\n        read: (bytes: Uint8Array, offset: Offset) => {\n            assertByteArrayHasEnoughBytesForCodec('fixCodec', fixedBytes, bytes, offset);\n            // Slice the byte array to the fixed size if necessary.\n            if (offset > 0 || bytes.length > fixedBytes) {\n                bytes = bytes.slice(offset, offset + fixedBytes);\n            }\n            // If the nested decoder is fixed-size, pad and truncate the byte array accordingly.\n            if (isFixedSize(decoder)) {\n                bytes = fixBytes(bytes, decoder.fixedSize);\n            }\n            // Decode the value using the nested decoder.\n            const [value] = decoder.read(bytes, 0);\n            return [value, offset + fixedBytes];\n        },\n    });\n}\n\n/**\n * Creates a fixed-size codec from a given codec.\n *\n * @param codec - The codec to wrap into a fixed-size codec.\n * @param fixedBytes - The fixed number of bytes to read/write.\n */\nexport function fixCodec<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: Codec<TFrom, TTo>,\n    fixedBytes: TSize,\n): FixedSizeCodec<TFrom, TTo, TSize> {\n    return combineCodec(fixEncoder(codec, fixedBytes), fixDecoder(codec, fixedBytes));\n}\n","import {\n    Codec,\n    createCodec,\n    createDecoder,\n    createEncoder,\n    Decoder,\n    Encoder,\n    FixedSizeCodec,\n    FixedSizeDecoder,\n    FixedSizeEncoder,\n    isVariableSize,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from './codec';\n\n/**\n * Converts an encoder A to a encoder B by mapping their values.\n */\nexport function mapEncoder<TOldFrom, TNewFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TOldFrom, TSize>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): FixedSizeEncoder<TNewFrom, TSize>;\nexport function mapEncoder<TOldFrom, TNewFrom>(\n    encoder: VariableSizeEncoder<TOldFrom>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): VariableSizeEncoder<TNewFrom>;\nexport function mapEncoder<TOldFrom, TNewFrom>(\n    encoder: Encoder<TOldFrom>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): Encoder<TNewFrom>;\nexport function mapEncoder<TOldFrom, TNewFrom>(\n    encoder: Encoder<TOldFrom>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): Encoder<TNewFrom> {\n    return createEncoder({\n        ...(isVariableSize(encoder)\n            ? { ...encoder, getSizeFromValue: (value: TNewFrom) => encoder.getSizeFromValue(unmap(value)) }\n            : encoder),\n        write: (value: TNewFrom, bytes, offset) => encoder.write(unmap(value), bytes, offset),\n    });\n}\n\n/**\n * Converts an decoder A to a decoder B by mapping their values.\n */\nexport function mapDecoder<TOldTo, TNewTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TOldTo, TSize>,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): FixedSizeDecoder<TNewTo, TSize>;\nexport function mapDecoder<TOldTo, TNewTo>(\n    decoder: VariableSizeDecoder<TOldTo>,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): VariableSizeDecoder<TNewTo>;\nexport function mapDecoder<TOldTo, TNewTo>(\n    decoder: Decoder<TOldTo>,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): Decoder<TNewTo>;\nexport function mapDecoder<TOldTo, TNewTo>(\n    decoder: Decoder<TOldTo>,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): Decoder<TNewTo> {\n    return createDecoder({\n        ...decoder,\n        read: (bytes: Uint8Array, offset) => {\n            const [value, newOffset] = decoder.read(bytes, offset);\n            return [map(value, bytes, offset), newOffset];\n        },\n    });\n}\n\n/**\n * Converts a codec A to a codec B by mapping their values.\n */\nexport function mapCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom, TSize extends number>(\n    codec: FixedSizeCodec<TOldFrom, TTo, TSize>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): FixedSizeCodec<TNewFrom, TTo, TSize>;\nexport function mapCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(\n    codec: VariableSizeCodec<TOldFrom, TTo>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): VariableSizeCodec<TNewFrom, TTo>;\nexport function mapCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(\n    codec: Codec<TOldFrom, TTo>,\n    unmap: (value: TNewFrom) => TOldFrom,\n): Codec<TNewFrom, TTo>;\nexport function mapCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom, TSize extends number>(\n    codec: FixedSizeCodec<TOldFrom, TOldTo, TSize>,\n    unmap: (value: TNewFrom) => TOldFrom,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): FixedSizeCodec<TNewFrom, TNewTo, TSize>;\nexport function mapCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(\n    codec: VariableSizeCodec<TOldFrom, TOldTo>,\n    unmap: (value: TNewFrom) => TOldFrom,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): VariableSizeCodec<TNewFrom, TNewTo>;\nexport function mapCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(\n    codec: Codec<TOldFrom, TOldTo>,\n    unmap: (value: TNewFrom) => TOldFrom,\n    map: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): Codec<TNewFrom, TNewTo>;\nexport function mapCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(\n    codec: Codec<TOldFrom, TOldTo>,\n    unmap: (value: TNewFrom) => TOldFrom,\n    map?: (value: TOldTo, bytes: Uint8Array, offset: number) => TNewTo,\n): Codec<TNewFrom, TNewTo> {\n    return createCodec({\n        ...mapEncoder(codec, unmap),\n        read: map ? mapDecoder(codec, map).read : (codec.read as unknown as Decoder<TNewTo>['read']),\n    });\n}\n","import {\n    assertIsFixedSize,\n    createDecoder,\n    createEncoder,\n    FixedSizeCodec,\n    FixedSizeDecoder,\n    FixedSizeEncoder,\n} from './codec';\nimport { combineCodec } from './combine-codec';\n\n/**\n * Reverses the bytes of a fixed-size encoder.\n */\nexport function reverseEncoder<TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize>,\n): FixedSizeEncoder<TFrom, TSize> {\n    assertIsFixedSize(encoder, 'Cannot reverse a codec of variable size.');\n    return createEncoder({\n        ...encoder,\n        write: (value: TFrom, bytes, offset) => {\n            const newOffset = encoder.write(value, bytes, offset);\n            const slice = bytes.slice(offset, offset + encoder.fixedSize).reverse();\n            bytes.set(slice, offset);\n            return newOffset;\n        },\n    });\n}\n\n/**\n * Reverses the bytes of a fixed-size decoder.\n */\nexport function reverseDecoder<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize>,\n): FixedSizeDecoder<TTo, TSize> {\n    assertIsFixedSize(decoder, 'Cannot reverse a codec of variable size.');\n    return createDecoder({\n        ...decoder,\n        read: (bytes, offset) => {\n            const reverseEnd = offset + decoder.fixedSize;\n            if (offset === 0 && bytes.length === reverseEnd) {\n                return decoder.read(bytes.reverse(), offset);\n            }\n            const reversedBytes = bytes.slice();\n            reversedBytes.set(bytes.slice(offset, reverseEnd).reverse(), offset);\n            return decoder.read(reversedBytes, offset);\n        },\n    });\n}\n\n/**\n * Reverses the bytes of a fixed-size codec.\n */\nexport function reverseCodec<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: FixedSizeCodec<TFrom, TTo, TSize>,\n): FixedSizeCodec<TFrom, TTo, TSize> {\n    return combineCodec(reverseEncoder(codec), reverseDecoder(codec));\n}\n"]}

package/dist/index.production.min.js

@@ -1,33 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-	'use strict';
-
-	function N(e,o,r=0){if(o.length-r<=0)throw new Error(`Codec [${e}] cannot decode empty byte arrays.`)}function S(e,o,r,i=0){let T=r.length-i;if(T<o)throw new Error(`Codec [${e}] expected ${o} bytes, got ${T}.`)}var v=e=>{let o=e.filter(d=>d.length);if(o.length===0)return e.length?e[0]:new Uint8Array;if(o.length===1)return o[0];let r=o.reduce((d,F)=>d+F.length,0),i=new Uint8Array(r),T=0;return o.forEach(d=>{i.set(d,T),T+=d.length;}),i},f=(e,o)=>{if(e.length>=o)return e;let r=new Uint8Array(o).fill(0);return r.set(e),r},s=(e,o)=>f(e.length<=o?e:e.slice(0,o),o);function u(e,o){return "fixedSize"in o?o.fixedSize:o.getSizeFromValue(e)}function c(e){return Object.freeze({...e,encode:o=>{let r=new Uint8Array(u(o,e));return e.write(o,r,0),r}})}function m(e){return Object.freeze({...e,decode:(o,r=0)=>e.read(o,r)[0]})}function l(e){return Object.freeze({...e,decode:(o,r=0)=>e.read(o,r)[0],encode:o=>{let r=new Uint8Array(u(o,e));return e.write(o,r,0),r}})}function n(e){return "fixedSize"in e&&typeof e.fixedSize=="number"}function z(e,o){if(!n(e))throw new Error(o!=null?o:"Expected a fixed-size codec, got a variable-size one.")}function x(e){return !n(e)}function h(e,o){if(!x(e))throw new Error(o!=null?o:"Expected a variable-size codec, got a fixed-size one.")}function a(e,o){if(n(e)!==n(o))throw new Error("Encoder and decoder must either both be fixed-size or variable-size.");if(n(e)&&n(o)&&e.fixedSize!==o.fixedSize)throw new Error(`Encoder and decoder must have the same fixed size, got [${e.fixedSize}] and [${o.fixedSize}].`);if(!n(e)&&!n(o)&&e.maxSize!==o.maxSize)throw new Error(`Encoder and decoder must have the same max size, got [${e.maxSize}] and [${o.maxSize}].`);return {...o,...e,decode:o.decode,encode:e.encode,read:o.read,write:e.write}}function b(e,o){return c({fixedSize:o,write:(r,i,T)=>{let d=e.encode(r),F=d.length>o?d.slice(0,o):d;return i.set(F,T),T+o}})}function p(e,o){return m({fixedSize:o,read:(r,i)=>{S("fixCodec",o,r,i),(i>0||r.length>o)&&(r=r.slice(i,i+o)),n(e)&&(r=s(r,e.fixedSize));let[T]=e.read(r,0);return [T,i+o]}})}function Te(e,o){return a(b(e,o),p(e,o))}function w(e,o){return c({...x(e)?{...e,getSizeFromValue:r=>e.getSizeFromValue(o(r))}:e,write:(r,i,T)=>e.write(o(r),i,T)})}function O(e,o){return m({...e,read:(r,i)=>{let[T,d]=e.read(r,i);return [o(T,r,i),d]}})}function le(e,o,r){return l({...w(e,o),read:r?O(e,r).read:e.read})}function E(e){return z(e,"Cannot reverse a codec of variable size."),c({...e,write:(o,r,i)=>{let T=e.write(o,r,i),d=r.slice(i,i+e.fixedSize).reverse();return r.set(d,i),T}})}function C(e){return z(e,"Cannot reverse a codec of variable size."),m({...e,read:(o,r)=>{let i=r+e.fixedSize;if(r===0&&o.length===i)return e.read(o.reverse(),r);let T=o.slice();return T.set(o.slice(r,i).reverse(),r),e.read(T,r)}})}function De(e){return a(E(e),C(e))}
-
-	exports.assertByteArrayHasEnoughBytesForCodec = S;
-	exports.assertByteArrayIsNotEmptyForCodec = N;
-	exports.assertIsFixedSize = z;
-	exports.assertIsVariableSize = h;
-	exports.combineCodec = a;
-	exports.createCodec = l;
-	exports.createDecoder = m;
-	exports.createEncoder = c;
-	exports.fixBytes = s;
-	exports.fixCodec = Te;
-	exports.fixDecoder = p;
-	exports.fixEncoder = b;
-	exports.getEncodedSize = u;
-	exports.isFixedSize = n;
-	exports.isVariableSize = x;
-	exports.mapCodec = le;
-	exports.mapDecoder = O;
-	exports.mapEncoder = w;
-	exports.mergeBytes = v;
-	exports.padBytes = f;
-	exports.reverseCodec = De;
-	exports.reverseDecoder = C;
-	exports.reverseEncoder = E;
-
-	return exports;
-
-})({});