@solana/codecs-core 6.3.1 → 6.3.2-canary-20260313112147

package/src/resize-codec.ts

@@ -0,0 +1,209 @@
+import { SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, SolanaError } from '@solana/errors';
+
+import {
+    Codec,
+    createDecoder,
+    createEncoder,
+    Decoder,
+    Encoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    isFixedSize,
+} from './codec';
+import { combineCodec } from './combine-codec';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyEncoder = Encoder<any>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDecoder = Decoder<any>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-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 function resizeEncoder<TFrom, TSize extends number, TNewSize extends number>(
+    encoder: FixedSizeEncoder<TFrom, TSize>,
+    resize: (size: TSize) => TNewSize,
+): FixedSizeEncoder<TFrom, TNewSize>;
+export function resizeEncoder<TEncoder extends AnyEncoder>(
+    encoder: TEncoder,
+    resize: (size: number) => number,
+): TEncoder;
+export function resizeEncoder<TEncoder extends AnyEncoder>(
+    encoder: TEncoder,
+    resize: (size: number) => number,
+): TEncoder {
+    if (isFixedSize(encoder)) {
+        const fixedSize = resize(encoder.fixedSize);
+        if (fixedSize < 0) {
+            throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
+                bytesLength: fixedSize,
+                codecDescription: 'resizeEncoder',
+            });
+        }
+        return createEncoder({ ...encoder, fixedSize }) as TEncoder;
+    }
+    return createEncoder({
+        ...encoder,
+        getSizeFromValue: value => {
+            const newSize = resize(encoder.getSizeFromValue(value));
+            if (newSize < 0) {
+                throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
+                    bytesLength: newSize,
+                    codecDescription: 'resizeEncoder',
+                });
+            }
+            return newSize;
+        },
+    }) as 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 function resizeDecoder<TFrom, TSize extends number, TNewSize extends number>(
+    decoder: FixedSizeDecoder<TFrom, TSize>,
+    resize: (size: TSize) => TNewSize,
+): FixedSizeDecoder<TFrom, TNewSize>;
+export function resizeDecoder<TDecoder extends AnyDecoder>(
+    decoder: TDecoder,
+    resize: (size: number) => number,
+): TDecoder;
+export function resizeDecoder<TDecoder extends AnyDecoder>(
+    decoder: TDecoder,
+    resize: (size: number) => number,
+): TDecoder {
+    if (isFixedSize(decoder)) {
+        const fixedSize = resize(decoder.fixedSize);
+        if (fixedSize < 0) {
+            throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
+                bytesLength: fixedSize,
+                codecDescription: 'resizeDecoder',
+            });
+        }
+        return createDecoder({ ...decoder, fixedSize }) as TDecoder;
+    }
+    return decoder;
+}
+
+/**
+ * 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 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 function resizeCodec<TCodec extends AnyCodec>(codec: TCodec, resize: (size: number) => number): TCodec;
+export function resizeCodec<TCodec extends AnyCodec>(codec: TCodec, resize: (size: number) => number): TCodec {
+    return combineCodec(resizeEncoder(codec, resize), resizeDecoder(codec, resize)) as TCodec;
+}

package/src/reverse-codec.ts

@@ -0,0 +1,159 @@
+import {
+    assertIsFixedSize,
+    createDecoder,
+    createEncoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+} from './codec';
+import { combineCodec } from './combine-codec';
+import { ReadonlyUint8Array } from './readonly-uint8array';
+
+function copySourceToTargetInReverse(
+    source: ReadonlyUint8Array,
+    target_WILL_MUTATE: Uint8Array,
+    sourceOffset: number,
+    sourceLength: number,
+    targetOffset: number = 0,
+) {
+    while (sourceOffset < --sourceLength) {
+        const leftValue = source[sourceOffset];
+        target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceLength];
+        target_WILL_MUTATE[sourceLength + targetOffset] = leftValue;
+        sourceOffset++;
+    }
+    if (sourceOffset === sourceLength) {
+        target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceOffset];
+    }
+}
+
+/**
+ * Reverses the bytes of a fixed-size encoder.
+ *
+ * Given a `FixedSizeEncoder`, this function returns a new `FixedSizeEncoder` that
+ * reverses the bytes within the fixed-size byte array when encoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * For more details, see {@link reverseCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TSize - The fixed size of the encoded value in bytes.
+ *
+ * @param encoder - The fixed-size encoder to reverse.
+ * @returns A new encoder that writes bytes in reverse order.
+ *
+ * @example
+ * Encoding a `u16` value in reverse order.
+ * ```ts
+ * const encoder = reverseEncoder(getU16Encoder({ endian: Endian.Big }));
+ * const bytes = encoder.encode(0x1234); // 0x3412 (bytes are flipped)
+ * ```
+ *
+ * @see {@link reverseCodec}
+ * @see {@link reverseDecoder}
+ */
+export function reverseEncoder<TFrom, TSize extends number>(
+    encoder: FixedSizeEncoder<TFrom, TSize>,
+): FixedSizeEncoder<TFrom, TSize> {
+    assertIsFixedSize(encoder);
+    return createEncoder({
+        ...encoder,
+        write: (value: TFrom, bytes, offset) => {
+            const newOffset = encoder.write(value, bytes, offset);
+            copySourceToTargetInReverse(
+                bytes /* source */,
+                bytes /* target_WILL_MUTATE */,
+                offset /* sourceOffset */,
+                offset + encoder.fixedSize /* sourceLength */,
+            );
+            return newOffset;
+        },
+    });
+}
+
+/**
+ * Reverses the bytes of a fixed-size decoder.
+ *
+ * Given a `FixedSizeDecoder`, this function returns a new `FixedSizeDecoder` that
+ * reverses the bytes within the fixed-size byte array before decoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * For more details, see {@link reverseCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The fixed size of the decoded value in bytes.
+ *
+ * @param decoder - The fixed-size decoder to reverse.
+ * @returns A new decoder that reads bytes in reverse order.
+ *
+ * @example
+ * Decoding a reversed `u16` value.
+ * ```ts
+ * const decoder = reverseDecoder(getU16Decoder({ endian: Endian.Big }));
+ * const value = decoder.decode(new Uint8Array([0x34, 0x12])); // 0x1234 (bytes are flipped back)
+ * ```
+ *
+ * @see {@link reverseCodec}
+ * @see {@link reverseEncoder}
+ */
+export function reverseDecoder<TTo, TSize extends number>(
+    decoder: FixedSizeDecoder<TTo, TSize>,
+): FixedSizeDecoder<TTo, TSize> {
+    assertIsFixedSize(decoder);
+    return createDecoder({
+        ...decoder,
+        read: (bytes, offset) => {
+            const reversedBytes = bytes.slice();
+            copySourceToTargetInReverse(
+                bytes /* source */,
+                reversedBytes /* target_WILL_MUTATE */,
+                offset /* sourceOffset */,
+                offset + decoder.fixedSize /* sourceLength */,
+            );
+            return decoder.read(reversedBytes, offset);
+        },
+    });
+}
+
+/**
+ * Reverses the bytes of a fixed-size codec.
+ *
+ * Given a `FixedSizeCodec`, this function returns a new `FixedSizeCodec` that
+ * reverses the bytes within the fixed-size byte array during encoding and decoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The fixed size of the encoded/decoded value in bytes.
+ *
+ * @param codec - The fixed-size codec to reverse.
+ * @returns A new codec that encodes and decodes bytes in reverse order.
+ *
+ * @example
+ * Reversing a `u16` codec.
+ * ```ts
+ * const codec = reverseCodec(getU16Codec({ endian: Endian.Big }));
+ * const bytes = codec.encode(0x1234); // 0x3412 (bytes are flipped)
+ * const value = codec.decode(bytes);  // 0x1234 (bytes are flipped back)
+ * ```
+ *
+ * @remarks
+ * If you only need to reverse an encoder, use {@link reverseEncoder}.
+ * If you only need to reverse a decoder, use {@link reverseDecoder}.
+ *
+ * ```ts
+ * const bytes = reverseEncoder(getU16Encoder()).encode(0x1234);
+ * const value = reverseDecoder(getU16Decoder()).decode(bytes);
+ * ```
+ *
+ * @see {@link reverseEncoder}
+ * @see {@link reverseDecoder}
+ */
+export function reverseCodec<TFrom, TTo extends TFrom, TSize extends number>(
+    codec: FixedSizeCodec<TFrom, TTo, TSize>,
+): FixedSizeCodec<TFrom, TTo, TSize> {
+    return combineCodec(reverseEncoder(codec), reverseDecoder(codec));
+}

package/src/transform-codec.ts

@@ -0,0 +1,208 @@
+import {
+    Codec,
+    createCodec,
+    createDecoder,
+    createEncoder,
+    Decoder,
+    Encoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    isVariableSize,
+    VariableSizeCodec,
+    VariableSizeDecoder,
+    VariableSizeEncoder,
+} from './codec';
+import { ReadonlyUint8Array } from './readonly-uint8array';
+
+/**
+ * Transforms an encoder by mapping its input values.
+ *
+ * This function takes an existing `Encoder<A>` and returns an `Encoder<B>`, allowing values of type `B`
+ * to be converted into values of type `A` before encoding. The transformation is applied via the `unmap` function.
+ *
+ * This is useful for handling type conversions, applying default values, or structuring data before encoding.
+ *
+ * For more details, see {@link transformCodec}.
+ *
+ * @typeParam TOldFrom - The original type expected by the encoder.
+ * @typeParam TNewFrom - The new type that will be transformed before encoding.
+ *
+ * @param encoder - The encoder to transform.
+ * @param unmap - A function that converts values of `TNewFrom` into `TOldFrom` before encoding.
+ * @returns A new encoder that accepts `TNewFrom` values and transforms them before encoding.
+ *
+ * @example
+ * Encoding a string by counting its characters and storing the length as a `u32`.
+ * ```ts
+ * const encoder = transformEncoder(getU32Encoder(), (value: string) => value.length);
+ * encoder.encode("hello"); // 0x05000000 (stores length 5)
+ * ```
+ *
+ * @see {@link transformCodec}
+ * @see {@link transformDecoder}
+ */
+export function transformEncoder<TOldFrom, TNewFrom, TSize extends number>(
+    encoder: FixedSizeEncoder<TOldFrom, TSize>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): FixedSizeEncoder<TNewFrom, TSize>;
+export function transformEncoder<TOldFrom, TNewFrom>(
+    encoder: VariableSizeEncoder<TOldFrom>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): VariableSizeEncoder<TNewFrom>;
+export function transformEncoder<TOldFrom, TNewFrom>(
+    encoder: Encoder<TOldFrom>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): Encoder<TNewFrom>;
+export function transformEncoder<TOldFrom, TNewFrom>(
+    encoder: Encoder<TOldFrom>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): Encoder<TNewFrom> {
+    return createEncoder({
+        ...(isVariableSize(encoder)
+            ? { ...encoder, getSizeFromValue: (value: TNewFrom) => encoder.getSizeFromValue(unmap(value)) }
+            : encoder),
+        write: (value: TNewFrom, bytes, offset) => encoder.write(unmap(value), bytes, offset),
+    });
+}
+
+/**
+ * Transforms a decoder by mapping its output values.
+ *
+ * This function takes an existing `Decoder<A>` and returns a `Decoder<B>`, allowing values of type `A`
+ * to be converted into values of type `B` after decoding. The transformation is applied via the `map` function.
+ *
+ * This is useful for post-processing, type conversions, or enriching decoded data.
+ *
+ * For more details, see {@link transformCodec}.
+ *
+ * @typeParam TOldTo - The original type returned by the decoder.
+ * @typeParam TNewTo - The new type that will be transformed after decoding.
+ *
+ * @param decoder - The decoder to transform.
+ * @param map - A function that converts values of `TOldTo` into `TNewTo` after decoding.
+ * @returns A new decoder that decodes into `TNewTo`.
+ *
+ * @example
+ * Decoding a stored `u32` length into a string of `'x'` characters.
+ * ```ts
+ * const decoder = transformDecoder(getU32Decoder(), (length) => 'x'.repeat(length));
+ * decoder.decode(new Uint8Array([0x05, 0x00, 0x00, 0x00])); // "xxxxx"
+ * ```
+ *
+ * @see {@link transformCodec}
+ * @see {@link transformEncoder}
+ */
+export function transformDecoder<TOldTo, TNewTo, TSize extends number>(
+    decoder: FixedSizeDecoder<TOldTo, TSize>,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): FixedSizeDecoder<TNewTo, TSize>;
+export function transformDecoder<TOldTo, TNewTo>(
+    decoder: VariableSizeDecoder<TOldTo>,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): VariableSizeDecoder<TNewTo>;
+export function transformDecoder<TOldTo, TNewTo>(
+    decoder: Decoder<TOldTo>,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): Decoder<TNewTo>;
+export function transformDecoder<TOldTo, TNewTo>(
+    decoder: Decoder<TOldTo>,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): Decoder<TNewTo> {
+    return createDecoder({
+        ...decoder,
+        read: (bytes: ReadonlyUint8Array | Uint8Array, offset) => {
+            const [value, newOffset] = decoder.read(bytes, offset);
+            return [map(value, bytes, offset), newOffset];
+        },
+    });
+}
+
+/**
+ * Transforms a codec by mapping its input and output values.
+ *
+ * This function takes an existing `Codec<A, B>` and returns a `Codec<C, D>`, allowing:
+ * - Values of type `C` to be transformed into `A` before encoding.
+ * - Values of type `B` to be transformed into `D` after decoding.
+ *
+ * This is useful for adapting codecs to work with different representations, handling default values, or
+ * converting between primitive and structured types.
+ *
+ * @typeParam TOldFrom - The original type expected by the codec.
+ * @typeParam TNewFrom - The new type that will be transformed before encoding.
+ * @typeParam TOldTo - The original type returned by the codec.
+ * @typeParam TNewTo - The new type that will be transformed after decoding.
+ *
+ * @param codec - The codec to transform.
+ * @param unmap - A function that converts values of `TNewFrom` into `TOldFrom` before encoding.
+ * @param map - A function that converts values of `TOldTo` into `TNewTo` after decoding (optional).
+ * @returns A new codec that encodes `TNewFrom` and decodes into `TNewTo`.
+ *
+ * @example
+ * Mapping a `u32` codec to encode string lengths and decode them into `'x'` characters.
+ * ```ts
+ * const codec = transformCodec(
+ *     getU32Codec(),
+ *     (value: string) => value.length, // Encode string length
+ *     (length) => 'x'.repeat(length)  // Decode length into a string of 'x's
+ * );
+ *
+ * const bytes = codec.encode("hello"); // 0x05000000 (stores length 5)
+ * const value = codec.decode(bytes);   // "xxxxx"
+ * ```
+ *
+ * @remarks
+ * If only input transformation is needed, use {@link transformEncoder}.
+ * If only output transformation is needed, use {@link transformDecoder}.
+ *
+ * ```ts
+ * const bytes = transformEncoder(getU32Encoder(), (value: string) => value.length).encode("hello");
+ * const value = transformDecoder(getU32Decoder(), (length) => 'x'.repeat(length)).decode(bytes);
+ * ```
+ *
+ * @see {@link transformEncoder}
+ * @see {@link transformDecoder}
+ */
+export function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom, TSize extends number>(
+    codec: FixedSizeCodec<TOldFrom, TTo, TSize>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): FixedSizeCodec<TNewFrom, TTo, TSize>;
+export function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(
+    codec: VariableSizeCodec<TOldFrom, TTo>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): VariableSizeCodec<TNewFrom, TTo>;
+export function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(
+    codec: Codec<TOldFrom, TTo>,
+    unmap: (value: TNewFrom) => TOldFrom,
+): Codec<TNewFrom, TTo>;
+export function transformCodec<
+    TOldFrom,
+    TNewFrom,
+    TOldTo extends TOldFrom,
+    TNewTo extends TNewFrom,
+    TSize extends number,
+>(
+    codec: FixedSizeCodec<TOldFrom, TOldTo, TSize>,
+    unmap: (value: TNewFrom) => TOldFrom,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): FixedSizeCodec<TNewFrom, TNewTo, TSize>;
+export function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(
+    codec: VariableSizeCodec<TOldFrom, TOldTo>,
+    unmap: (value: TNewFrom) => TOldFrom,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): VariableSizeCodec<TNewFrom, TNewTo>;
+export function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(
+    codec: Codec<TOldFrom, TOldTo>,
+    unmap: (value: TNewFrom) => TOldFrom,
+    map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): Codec<TNewFrom, TNewTo>;
+export function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(
+    codec: Codec<TOldFrom, TOldTo>,
+    unmap: (value: TNewFrom) => TOldFrom,
+    map?: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo,
+): Codec<TNewFrom, TNewTo> {
+    return createCodec({
+        ...transformEncoder(codec, unmap),
+        read: map ? transformDecoder(codec, map).read : (codec.read as unknown as Decoder<TNewTo>['read']),
+    });
+}