@yume-chan/struct 0.0.23 → 1.0.0

package/src/struct.ts

@@ -1,200 +1,41 @@
-import type {
-    AsyncExactReadable,
-    ExactReadable,
-    StructFieldDefinition,
-    StructFieldValue,
-    StructOptions,
-} from "./basic/index.js";
-import {
-    ExactReadableEndedError,
-    STRUCT_VALUE_SYMBOL,
-    StructDefaultOptions,
-    StructValue,
-} from "./basic/index.js";
-import { SyncPromise } from "./sync-promise.js";
-import type {
-    BufferFieldSubType,
-    FixedLengthBufferLikeFieldOptions,
-    LengthField,
-    VariableLengthBufferLikeFieldOptions,
-} from "./types/index.js";
-import {
-    BigIntFieldDefinition,
-    BigIntFieldType,
-    FixedLengthBufferLikeFieldDefinition,
-    NumberFieldDefinition,
-    NumberFieldType,
-    StringBufferFieldSubType,
-    Uint8ArrayBufferFieldSubType,
-    VariableLengthBufferLikeFieldDefinition,
-} from "./types/index.js";
-import type { Evaluate, Identity, Overwrite, ValueOrPromise } from "./utils.js";
-
-export interface StructLike<TValue> {
-    deserialize(stream: ExactReadable | AsyncExactReadable): Promise<TValue>;
-}
-
-/**
- * Extract the value type of the specified `Struct`
- */
-export type StructValueType<T extends StructLike<unknown>> = Awaited<
-    ReturnType<T["deserialize"]>
->;
-
-/**
- * Create a new `Struct` type with `TDefinition` appended
- */
-type AddFieldDescriptor<
-    TFields extends object,
-    TOmitInitKey extends PropertyKey,
-    TExtra extends object,
-    TPostDeserialized,
-    TFieldName extends PropertyKey,
-    TDefinition extends StructFieldDefinition<any, any, any>,
-> = Identity<
-    Struct<
-        // Merge two types
-        // Evaluate immediately to optimize editor hover tooltip
-        Evaluate<TFields & Record<TFieldName, TDefinition["TValue"]>>,
-        // Merge two `TOmitInitKey`s
-        TOmitInitKey | TDefinition["TOmitInitKey"],
-        TExtra,
-        TPostDeserialized
-    >
->;
-
-/**
- * Overload methods to add an array buffer like field
- */
-interface ArrayBufferLikeFieldCreator<
-    TFields extends object,
-    TOmitInitKey extends PropertyKey,
-    TExtra extends object,
-    TPostDeserialized,
-> {
-    /**
-     * Append a fixed-length array buffer like field to the `Struct`
-     *
-     * @param name Name of the field
-     * @param type `Array.SubType.ArrayBuffer` or `Array.SubType.String`
-     * @param options Fixed-length array options
-     * @param typeScriptType Type of the field in TypeScript.
-     * For example, if this field is a string, you can declare it as a string enum or literal union.
-     */
-    <
-        TName extends PropertyKey,
-        TType extends BufferFieldSubType<any, any>,
-        TTypeScriptType = TType["TTypeScriptType"],
-    >(
-        name: TName,
-        type: TType,
-        options: FixedLengthBufferLikeFieldOptions,
-        typeScriptType?: TTypeScriptType,
-    ): AddFieldDescriptor<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        TName,
-        FixedLengthBufferLikeFieldDefinition<
-            TType,
-            FixedLengthBufferLikeFieldOptions
+import type { MaybePromiseLike } from "@yume-chan/async";
+
+import { bipedal } from "./bipedal.js";
+import type { DeserializeContext, Field, SerializeContext } from "./field.js";
+import type { AsyncExactReadable, ExactReadable } from "./readable.js";
+import { ExactReadableEndedError } from "./readable.js";
+
+export type FieldsType<
+    T extends Record<string, Field<unknown, string, unknown>>,
+> = {
+    [K in keyof T]: T[K] extends Field<infer TK, string, unknown> ? TK : never;
+};
+
+export type StructInit<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    T extends Struct<any, any, any>,
+> = Omit<
+    FieldsType<T["fields"]>,
+    {
+        [K in keyof T["fields"]]: T["fields"][K] extends Field<
+            unknown,
+            infer U,
+            unknown
         >
-    >;
-
-    /**
-     * Append a variable-length array buffer like field to the `Struct`
-     */
-    <
-        TName extends PropertyKey,
-        TType extends BufferFieldSubType<any, any>,
-        TOptions extends VariableLengthBufferLikeFieldOptions<TFields>,
-        TTypeScriptType = TType["TTypeScriptType"],
-    >(
-        name: TName,
-        type: TType,
-        options: TOptions,
-        typeScriptType?: TTypeScriptType,
-    ): AddFieldDescriptor<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        TName,
-        VariableLengthBufferLikeFieldDefinition<TType, TOptions>
-    >;
-}
-
-/**
- * Similar to `ArrayBufferLikeFieldCreator`, but bind to `TType`
- */
-interface BoundArrayBufferLikeFieldDefinitionCreator<
-    TFields extends object,
-    TOmitInitKey extends PropertyKey,
-    TExtra extends object,
-    TPostDeserialized,
-    TType extends BufferFieldSubType<any, any>,
-> {
-    <TName extends PropertyKey, TTypeScriptType = TType["TTypeScriptType"]>(
-        name: TName,
-        options: FixedLengthBufferLikeFieldOptions,
-        typeScriptType?: TTypeScriptType,
-    ): AddFieldDescriptor<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        TName,
-        FixedLengthBufferLikeFieldDefinition<
-            TType,
-            FixedLengthBufferLikeFieldOptions,
-            TTypeScriptType
-        >
-    >;
-
-    <
-        TName extends PropertyKey,
-        TLengthField extends LengthField<TFields>,
-        TOptions extends VariableLengthBufferLikeFieldOptions<
-            TFields,
-            TLengthField
-        >,
-        TTypeScriptType = TType["TTypeScriptType"],
-    >(
-        name: TName,
-        options: TOptions,
-        typeScriptType?: TTypeScriptType,
-    ): AddFieldDescriptor<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        TName,
-        VariableLengthBufferLikeFieldDefinition<
-            TType,
-            TOptions,
-            TTypeScriptType
-        >
-    >;
-}
-
-export type StructPostDeserialized<TFields, TPostDeserialized> = (
-    this: TFields,
-    object: TFields,
-) => TPostDeserialized;
+            ? U
+            : never;
+    }[keyof T["fields"]]
+>;
 
-export type StructDeserializedResult<
-    TFields extends object,
-    TExtra extends object,
-    TPostDeserialized,
-> = TPostDeserialized extends undefined
-    ? Overwrite<TExtra, TFields>
-    : TPostDeserialized;
+export type StructValue<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    T extends Struct<any, any, any>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+> = T extends Struct<any, any, infer P> ? P : never;
 
 export class StructDeserializeError extends Error {
     constructor(message: string) {
         super(message);
-        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 
@@ -212,458 +53,145 @@ export class StructEmptyError extends StructDeserializeError {
     }
 }
 
-export class Struct<
-    TFields extends object = Record<never, never>,
-    TOmitInitKey extends PropertyKey = never,
-    TExtra extends object = Record<never, never>,
-    TPostDeserialized = undefined,
-> implements
-        StructLike<
-            StructDeserializedResult<TFields, TExtra, TPostDeserialized>
-        >
-{
-    readonly TFields!: TFields;
-
-    readonly TOmitInitKey!: TOmitInitKey;
-
-    readonly TExtra!: TExtra;
-
-    readonly TInit!: Evaluate<Omit<TFields, TOmitInitKey>>;
-
-    readonly TDeserializeResult!: StructDeserializedResult<
-        TFields,
-        TExtra,
-        TPostDeserialized
-    >;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type StructLike<T> = Struct<any, any, T>;
 
-    readonly options: Readonly<StructOptions>;
-
-    #size = 0;
-    /**
-     * Gets the static size (exclude fields that can change size at runtime)
-     */
-    get size() {
-        return this.#size;
-    }
-
-    #fields: [
-        name: PropertyKey,
-        definition: StructFieldDefinition<any, any, any>,
-    ][] = [];
-    get fields(): readonly [
-        name: PropertyKey,
-        definition: StructFieldDefinition<any, any, any>,
-    ][] {
-        return this.#fields;
-    }
-
-    #extra: Record<PropertyKey, unknown> = {};
+export interface Struct<
+    T extends Record<string, Field<unknown, string, Partial<FieldsType<T>>>>,
+    Extra extends Record<PropertyKey, unknown> | undefined = undefined,
+    PostDeserialize = FieldsType<T> & Extra,
+> {
+    fields: T;
+    size: number;
+    extra: Extra;
 
-    #postDeserialized?: StructPostDeserialized<any, any> | undefined;
+    serialize(runtimeStruct: StructInit<this>): Uint8Array;
+    serialize(runtimeStruct: StructInit<this>, buffer: Uint8Array): number;
 
-    constructor(options?: Partial<Readonly<StructOptions>>) {
-        this.options = { ...StructDefaultOptions, ...options };
-    }
+    deserialize(reader: ExactReadable): PostDeserialize;
+    deserialize(reader: AsyncExactReadable): MaybePromiseLike<PostDeserialize>;
+}
 
-    /**
-     * Appends a `StructFieldDefinition` to the `Struct
-     */
-    field<
-        TName extends PropertyKey,
-        TDefinition extends StructFieldDefinition<any, any, any>,
-    >(
-        name: TName,
-        definition: TDefinition,
-    ): AddFieldDescriptor<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        TName,
-        TDefinition
-    > {
-        for (const field of this.#fields) {
-            if (field[0] === name) {
-                // Convert Symbol to string
-                const nameString = String(name);
-                throw new Error(
-                    `This struct already have a field with name '${nameString}'`,
-                );
+/* #__NO_SIDE_EFFECTS__ */
+export function struct<
+    T extends Record<string, Field<unknown, string, Partial<FieldsType<T>>>>,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    Extra extends Record<PropertyKey, unknown> = {},
+    PostDeserialize = FieldsType<T> & Extra,
+>(
+    fields: T,
+    options: {
+        littleEndian?: boolean;
+        extra?: Extra & ThisType<FieldsType<T>>;
+        postDeserialize?: (
+            this: FieldsType<T> & Extra,
+            fields: FieldsType<T> & Extra,
+        ) => PostDeserialize;
+    },
+): Struct<T, Extra, PostDeserialize> {
+    const fieldList = Object.entries(fields);
+    const size = fieldList.reduce((sum, [, field]) => sum + field.size, 0);
+
+    const littleEndian = !!options.littleEndian;
+    const extra = options.extra
+        ? Object.getOwnPropertyDescriptors(options.extra)
+        : undefined;
+
+    return {
+        fields,
+        size,
+        extra: options.extra,
+        serialize(
+            runtimeStruct: StructInit<Struct<T, Extra, PostDeserialize>>,
+            buffer?: Uint8Array,
+        ): Uint8Array | number {
+            for (const [key, field] of fieldList) {
+                if (key in runtimeStruct) {
+                    field.preSerialize?.(
+                        runtimeStruct[key as never],
+                        runtimeStruct as never,
+                    );
+                }
             }
-        }
-
-        this.#fields.push([name, definition]);
-
-        const size = definition.getSize();
-        this.#size += size;
-
-        // Force cast `this` to another type
-        return this as any;
-    }
-
-    /**
-     * Merges (flats) another `Struct`'s fields and extra fields into this one.
-     */
-    concat<TOther extends Struct<any, any, any, any>>(
-        other: TOther,
-    ): Struct<
-        TFields & TOther["TFields"],
-        TOmitInitKey | TOther["TOmitInitKey"],
-        TExtra & TOther["TExtra"],
-        TPostDeserialized
-    > {
-        for (const field of other.#fields) {
-            this.#fields.push(field);
-        }
-        this.#size += other.#size;
-        Object.defineProperties(
-            this.#extra,
-            Object.getOwnPropertyDescriptors(other.#extra),
-        );
-        return this as any;
-    }
-
-    #number<
-        TName extends PropertyKey,
-        TType extends NumberFieldType = NumberFieldType,
-        TTypeScriptType = number,
-    >(name: TName, type: TType, typeScriptType?: TTypeScriptType) {
-        return this.field(
-            name,
-            new NumberFieldDefinition(type, typeScriptType),
-        );
-    }
-
-    /**
-     * Appends an `int8` field to the `Struct`
-     */
-    int8<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Int8, typeScriptType);
-    }
-
-    /**
-     * Appends an `uint8` field to the `Struct`
-     */
-    uint8<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Uint8, typeScriptType);
-    }
-
-    /**
-     * Appends an `int16` field to the `Struct`
-     */
-    int16<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Int16, typeScriptType);
-    }
-
-    /**
-     * Appends an `uint16` field to the `Struct`
-     */
-    uint16<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Uint16, typeScriptType);
-    }
-
-    /**
-     * Appends an `int32` field to the `Struct`
-     */
-    int32<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Int32, typeScriptType);
-    }
-
-    /**
-     * Appends an `uint32` field to the `Struct`
-     */
-    uint32<TName extends PropertyKey, TTypeScriptType = number>(
-        name: TName,
-        typeScriptType?: TTypeScriptType,
-    ) {
-        return this.#number(name, NumberFieldType.Uint32, typeScriptType);
-    }
-
-    #bigint<
-        TName extends PropertyKey,
-        TType extends BigIntFieldType = BigIntFieldType,
-        TTypeScriptType = TType["TTypeScriptType"],
-    >(name: TName, type: TType, typeScriptType?: TTypeScriptType) {
-        return this.field(
-            name,
-            new BigIntFieldDefinition(type, typeScriptType),
-        );
-    }
 
-    /**
-     * Appends an `int64` field to the `Struct`
-     *
-     * Requires native `BigInt` support
-     */
-    int64<
-        TName extends PropertyKey,
-        TTypeScriptType = BigIntFieldType["TTypeScriptType"],
-    >(name: TName, typeScriptType?: TTypeScriptType) {
-        return this.#bigint(name, BigIntFieldType.Int64, typeScriptType);
-    }
-
-    /**
-     * Appends an `uint64` field to the `Struct`
-     *
-     * Requires native `BigInt` support
-     */
-    uint64<
-        TName extends PropertyKey,
-        TTypeScriptType = BigIntFieldType["TTypeScriptType"],
-    >(name: TName, typeScriptType?: TTypeScriptType) {
-        return this.#bigint(name, BigIntFieldType.Uint64, typeScriptType);
-    }
-
-    #arrayBufferLike: ArrayBufferLikeFieldCreator<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized
-    > = (
-        name: PropertyKey,
-        type: BufferFieldSubType,
-        options:
-            | FixedLengthBufferLikeFieldOptions
-            | VariableLengthBufferLikeFieldOptions,
-    ): any => {
-        if ("length" in options) {
-            return this.field(
-                name,
-                new FixedLengthBufferLikeFieldDefinition(type, options),
-            );
-        } else {
-            return this.field(
-                name,
-                new VariableLengthBufferLikeFieldDefinition(type, options),
+            const sizes = fieldList.map(
+                ([key, field]) =>
+                    field.dynamicSize?.(runtimeStruct[key as never]) ??
+                    field.size,
             );
-        }
-    };
-
-    uint8Array: BoundArrayBufferLikeFieldDefinitionCreator<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        Uint8ArrayBufferFieldSubType
-    > = (name: PropertyKey, options: any, typeScriptType: any): any => {
-        return this.#arrayBufferLike(
-            name,
-            Uint8ArrayBufferFieldSubType.Instance,
-            options,
-            typeScriptType,
-        );
-    };
-
-    string: BoundArrayBufferLikeFieldDefinitionCreator<
-        TFields,
-        TOmitInitKey,
-        TExtra,
-        TPostDeserialized,
-        StringBufferFieldSubType
-    > = (name: PropertyKey, options: any, typeScriptType: any): any => {
-        return this.#arrayBufferLike(
-            name,
-            StringBufferFieldSubType.Instance,
-            options,
-            typeScriptType,
-        );
-    };
-
-    /**
-     * Adds some extra properties into every `Struct` value.
-     *
-     * Extra properties will not affect serialize or deserialize process.
-     *
-     * Multiple calls to `extra` will merge all properties together.
-     *
-     * @param value
-     * An object containing properties to be added to the result value. Accessors and methods are also allowed.
-     */
-    extra<
-        T extends Record<
-            // This trick disallows any keys that are already in `TValue`
-            Exclude<keyof T, Exclude<keyof T, keyof TFields>>,
-            never
-        >,
-    >(
-        value: T & ThisType<Overwrite<Overwrite<TExtra, T>, TFields>>,
-    ): Struct<TFields, TOmitInitKey, Overwrite<TExtra, T>, TPostDeserialized> {
-        Object.defineProperties(
-            this.#extra,
-            Object.getOwnPropertyDescriptors(value),
-        );
-        return this as any;
-    }
-
-    /**
-     * Registers (or replaces) a custom callback to be run after deserialized.
-     *
-     * A callback returning `never` (always throw an error)
-     * will also change the return type of `deserialize` to `never`.
-     */
-    postDeserialize(
-        callback: StructPostDeserialized<TFields, never>,
-    ): Struct<TFields, TOmitInitKey, TExtra, never>;
-    /**
-     * Registers (or replaces) a custom callback to be run after deserialized.
-     *
-     * A callback returning `void` means it modify the result object in-place
-     * (or doesn't modify it at all), so `deserialize` will still return the result object.
-     */
-    postDeserialize(
-        callback?: StructPostDeserialized<TFields, void>,
-    ): Struct<TFields, TOmitInitKey, TExtra, undefined>;
-    /**
-     * Registers (or replaces) a custom callback to be run after deserialized.
-     *
-     * A callback returning anything other than `undefined`
-     * will `deserialize` to return that object instead.
-     */
-    postDeserialize<TPostSerialize>(
-        callback?: StructPostDeserialized<TFields, TPostSerialize>,
-    ): Struct<TFields, TOmitInitKey, TExtra, TPostSerialize>;
-    postDeserialize(callback?: StructPostDeserialized<TFields, any>) {
-        this.#postDeserialized = callback;
-        return this as any;
-    }
+            const size = sizes.reduce((sum, size) => sum + size, 0);
 
-    /**
-     * Deserialize a struct value from `stream`.
-     */
-    deserialize(
-        stream: ExactReadable,
-    ): StructDeserializedResult<TFields, TExtra, TPostDeserialized>;
-    deserialize(
-        stream: AsyncExactReadable,
-    ): Promise<StructDeserializedResult<TFields, TExtra, TPostDeserialized>>;
-    deserialize(
-        stream: ExactReadable | AsyncExactReadable,
-    ): ValueOrPromise<
-        StructDeserializedResult<TFields, TExtra, TPostDeserialized>
-    > {
-        const structValue = new StructValue(this.#extra);
-
-        let promise = SyncPromise.resolve();
-
-        const startPosition = stream.position;
-        for (const [name, definition] of this.#fields) {
-            promise = promise
-                .then(() =>
-                    definition.deserialize(this.options, stream, structValue),
-                )
-                .then(
-                    (fieldValue) => {
-                        structValue.set(name, fieldValue);
-                    },
-                    (e) => {
-                        if (!(e instanceof ExactReadableEndedError)) {
-                            throw e;
-                        }
+            let externalBuffer = false;
+            if (buffer) {
+                if (buffer.length < size) {
+                    throw new Error("Buffer too small");
+                }
 
-                        if (stream.position === startPosition) {
-                            throw new StructEmptyError();
-                        } else {
-                            throw new StructNotEnoughDataError();
-                        }
-                    },
-                );
-        }
+                externalBuffer = true;
+            } else {
+                buffer = new Uint8Array(size);
+            }
 
-        return promise
-            .then(() => {
-                const value = structValue.value;
+            const context: SerializeContext = {
+                buffer,
+                index: 0,
+                littleEndian,
+            };
+            for (const [index, [key, field]] of fieldList.entries()) {
+                field.serialize(runtimeStruct[key as never], context);
+                context.index += sizes[index]!;
+            }
 
-                // Run `postDeserialized`
-                if (this.#postDeserialized) {
-                    const override = this.#postDeserialized.call(value, value);
-                    // If it returns a new value, use that as result
-                    // Otherwise it only inspects/mutates the object in place.
-                    if (override !== undefined) {
-                        return override;
-                    }
+            if (externalBuffer) {
+                return size;
+            } else {
+                return buffer;
+            }
+        },
+        deserialize: bipedal(function* (
+            this: Struct<T, Extra, PostDeserialize>,
+            then,
+            reader: AsyncExactReadable,
+        ) {
+            const startPosition = reader.position;
+
+            const runtimeStruct = {} as Record<string, unknown>;
+            const context: DeserializeContext<Partial<FieldsType<T>>> = {
+                reader,
+                runtimeStruct: runtimeStruct as never,
+                littleEndian: littleEndian,
+            };
+
+            try {
+                for (const [key, field] of fieldList) {
+                    runtimeStruct[key] = yield* then(
+                        field.deserialize(context),
+                    );
+                }
+            } catch (e) {
+                if (!(e instanceof ExactReadableEndedError)) {
+                    throw e;
                 }
 
-                return value;
-            })
-            .valueOrPromise();
-    }
-
-    serialize(init: Evaluate<Omit<TFields, TOmitInitKey>>): Uint8Array;
-    serialize(
-        init: Evaluate<Omit<TFields, TOmitInitKey>>,
-        output: Uint8Array,
-    ): number;
-    serialize(
-        init: Evaluate<Omit<TFields, TOmitInitKey>>,
-        output?: Uint8Array,
-    ): Uint8Array | number {
-        let structValue: StructValue;
-        if (STRUCT_VALUE_SYMBOL in init) {
-            structValue = (init as any)[STRUCT_VALUE_SYMBOL];
-            for (const [key, value] of Object.entries(init)) {
-                const fieldValue = structValue.get(key);
-                if (fieldValue) {
-                    fieldValue.set(value);
+                if (reader.position === startPosition) {
+                    throw new StructEmptyError();
+                } else {
+                    throw new StructNotEnoughDataError();
                 }
             }
-        } else {
-            structValue = new StructValue({});
-            for (const [name, definition] of this.#fields) {
-                const fieldValue = definition.create(
-                    this.options,
-                    structValue,
-                    (init as any)[name],
-                );
-                structValue.set(name, fieldValue);
-            }
-        }
-
-        let structSize = 0;
-        const fieldsInfo: { fieldValue: StructFieldValue; size: number }[] = [];
-
-        for (const [name] of this.#fields) {
-            const fieldValue = structValue.get(name);
-            const size = fieldValue.getSize();
-            fieldsInfo.push({ fieldValue, size });
-            structSize += size;
-        }
-
-        let outputType = "number";
-        if (!output) {
-            output = new Uint8Array(structSize);
-            outputType = "Uint8Array";
-        }
 
-        const dataView = new DataView(
-            output.buffer,
-            output.byteOffset,
-            output.byteLength,
-        );
-        let offset = 0;
-        for (const { fieldValue, size } of fieldsInfo) {
-            fieldValue.serialize(dataView, offset);
-            offset += size;
-        }
+            if (extra) {
+                Object.defineProperties(runtimeStruct, extra);
+            }
 
-        if (outputType === "number") {
-            return structSize;
-        } else {
-            return output;
-        }
-    }
+            if (options.postDeserialize) {
+                return options.postDeserialize.call(
+                    runtimeStruct as never,
+                    runtimeStruct as never,
+                );
+            } else {
+                return runtimeStruct;
+            }
+        }),
+    } as never;
 }