@gtkx/gir 0.19.0 → 0.21.0

package/dist/internal/normalizer.js

@@ -1,440 +1,409 @@
-/**
- * Normalizer that converts raw GIR types to normalized types.
- *
- * The key job is to qualify all type references with their namespace,
- * except for intrinsic types which remain unqualified.
- *
- * @internal
- */
 import { isIntrinsicType } from "../intrinsics.js";
-import { GirAlias, GirCallback, GirClass, GirConstant, GirConstructor, GirEnumeration, GirEnumerationMember, GirField, GirFunction, GirInterface, GirMethod, GirNamespace, GirParameter, GirProperty, GirRecord, GirSignal, GirType, parseDefaultValue, qualifiedName, } from "../types.js";
+import { GirAlias } from "../model/alias.js";
+import { GirConstructor, GirFunction, GirMethod } from "../model/callables.js";
+import { GirCallback } from "../model/callback.js";
+import { GirConstant } from "../model/constant.js";
+import { GirEnumeration, GirEnumerationMember } from "../model/enumeration.js";
+import { GirField } from "../model/field.js";
+import { GirParameter } from "../model/parameter.js";
+import { GirProperty, parseDefaultValue } from "../model/property.js";
+import { GirRecord } from "../model/record.js";
+import { GirSignal } from "../model/signal.js";
+import { GirType } from "../model/type.js";
 /**
- * Normalizes a raw namespace into a normalized namespace.
+ * Converts raw parsed GIR data into model instances with fully qualified
+ * type names.
+ *
+ * Uses indexed lookups for O(1) type name resolution and strict error
+ * handling (throws on unresolvable type references).
  */
-export const normalizeNamespace = (raw, ctx) => {
-    const nsName = raw.name;
-    const classes = new Map();
-    const interfaces = new Map();
-    const records = new Map();
-    const enumerations = new Map();
-    const bitfields = new Map();
-    const callbacks = new Map();
-    const functions = new Map();
-    const constants = new Map();
-    const aliases = new Map();
-    for (const rawClass of raw.classes) {
-        const normalized = normalizeClass(rawClass, nsName, ctx);
-        classes.set(normalized.name, normalized);
-    }
-    for (const rawInterface of raw.interfaces) {
-        const normalized = normalizeInterface(rawInterface, nsName, ctx);
-        interfaces.set(normalized.name, normalized);
+export class GirNormalizer {
+    typeIndex = new Map();
+    /**
+     * Normalizes all raw namespaces into intermediate namespace data.
+     *
+     * @param rawNamespaces - Raw namespaces keyed by name, in dependency order
+     * @returns Intermediate namespace data keyed by name, in the same order
+     */
+    normalize(rawNamespaces) {
+        this.typeIndex = this.buildTypeIndex(rawNamespaces);
+        const result = new Map();
+        for (const [name, raw] of rawNamespaces) {
+            result.set(name, this.normalizeNamespace(raw));
+        }
+        return result;
     }
-    for (const rawRecord of raw.records) {
-        const normalized = normalizeRecord(rawRecord, nsName, ctx);
-        records.set(normalized.name, normalized);
+    buildTypeIndex(rawNamespaces) {
+        const index = new Map();
+        for (const [nsName, raw] of rawNamespaces) {
+            const names = new Set();
+            for (const c of raw.classes)
+                names.add(c.name);
+            for (const i of raw.interfaces)
+                names.add(i.name);
+            for (const r of raw.records)
+                names.add(r.name);
+            for (const e of raw.enumerations)
+                names.add(e.name);
+            for (const b of raw.bitfields)
+                names.add(b.name);
+            for (const cb of raw.callbacks)
+                names.add(cb.name);
+            for (const a of raw.aliases)
+                names.add(a.name);
+            index.set(nsName, names);
+        }
+        return index;
     }
-    for (const rawEnum of raw.enumerations) {
-        const normalized = normalizeEnumeration(rawEnum, nsName);
-        enumerations.set(normalized.name, normalized);
+    normalizeNamespace(raw) {
+        const nsName = raw.name;
+        const classes = new Map();
+        for (const rawClass of raw.classes) {
+            const data = this.normalizeClass(rawClass, nsName);
+            classes.set(data.name, data);
+        }
+        const interfaces = new Map();
+        for (const rawIface of raw.interfaces) {
+            const data = this.normalizeInterface(rawIface, nsName);
+            interfaces.set(data.name, data);
+        }
+        const records = new Map();
+        for (const rawRecord of raw.records) {
+            const record = this.normalizeRecord(rawRecord, nsName);
+            records.set(record.name, record);
+        }
+        const enumerations = new Map();
+        for (const rawEnum of raw.enumerations) {
+            const enumeration = this.normalizeEnumeration(rawEnum, nsName);
+            enumerations.set(enumeration.name, enumeration);
+        }
+        const bitfields = new Map();
+        for (const rawBitfield of raw.bitfields) {
+            const bitfield = this.normalizeEnumeration(rawBitfield, nsName);
+            bitfields.set(bitfield.name, bitfield);
+        }
+        const callbacks = new Map();
+        for (const rawCb of raw.callbacks) {
+            const cb = this.normalizeCallback(rawCb, nsName);
+            callbacks.set(cb.name, cb);
+        }
+        const functions = new Map();
+        for (const rawFunc of raw.functions) {
+            const func = this.normalizeFunction(rawFunc, nsName);
+            functions.set(func.name, func);
+        }
+        const constants = new Map();
+        for (const rawConst of raw.constants) {
+            const constant = this.normalizeConstant(rawConst, nsName);
+            constants.set(constant.name, constant);
+        }
+        const aliases = new Map();
+        for (const rawAlias of raw.aliases) {
+            const alias = this.normalizeAlias(rawAlias, nsName);
+            aliases.set(alias.name, alias);
+        }
+        return {
+            name: raw.name,
+            version: raw.version,
+            sharedLibrary: raw.sharedLibrary,
+            cPrefix: raw.cPrefix,
+            classes,
+            interfaces,
+            records,
+            enumerations,
+            bitfields,
+            callbacks,
+            functions,
+            constants,
+            aliases,
+            doc: raw.doc,
+        };
     }
-    for (const rawBitfield of raw.bitfields) {
-        const normalized = normalizeEnumeration(rawBitfield, nsName);
-        bitfields.set(normalized.name, normalized);
+    qualifyTypeName(typeName, currentNamespace) {
+        if (isIntrinsicType(typeName))
+            return typeName;
+        if (typeName.includes("."))
+            return typeName;
+        if (this.typeIndex.get(currentNamespace)?.has(typeName)) {
+            return `${currentNamespace}.${typeName}`;
+        }
+        for (const [nsName, names] of this.typeIndex) {
+            if (nsName !== currentNamespace && names.has(typeName)) {
+                return `${nsName}.${typeName}`;
+            }
+        }
+        return `${currentNamespace}.${typeName}`;
     }
-    for (const rawCallback of raw.callbacks) {
-        const normalized = normalizeCallback(rawCallback, nsName, ctx);
-        callbacks.set(normalized.name, normalized);
+    normalizeType(raw, currentNamespace) {
+        if (raw.containerType === "ghashtable") {
+            const typeParams = (raw.typeParameters ?? []).map((tp) => this.normalizeType(tp, currentNamespace));
+            return new GirType({
+                name: `GLib.HashTable`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: false,
+                elementType: typeParams[1] ?? null,
+                typeParameters: typeParams,
+            });
+        }
+        if (raw.containerType === "gptrarray" || raw.containerType === "garray") {
+            const typeParams = (raw.typeParameters ?? []).map((tp) => this.normalizeType(tp, currentNamespace));
+            const typeName = raw.containerType === "gptrarray" ? "PtrArray" : "Array";
+            return new GirType({
+                name: `GLib.${typeName}`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType: typeParams[0] ?? null,
+                typeParameters: typeParams,
+            });
+        }
+        if (raw.containerType === "gbytearray") {
+            const elementType = raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null;
+            return new GirType({
+                name: `GLib.ByteArray`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType,
+            });
+        }
+        if (raw.containerType === "glist" || raw.containerType === "gslist") {
+            const elementType = raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null;
+            return new GirType({
+                name: "array",
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType,
+                typeParameters: elementType ? [elementType] : [],
+            });
+        }
+        const isArray = raw.isArray === true || raw.name === "array";
+        if (isArray) {
+            return new GirType({
+                name: "array",
+                cType: raw.cType,
+                isArray: true,
+                elementType: raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                sizeParamIndex: raw.sizeParamIndex,
+                zeroTerminated: raw.zeroTerminated,
+                fixedSize: raw.fixedSize,
+            });
+        }
+        return new GirType({
+            name: this.qualifyTypeName(raw.name, currentNamespace),
+            cType: raw.cType,
+            isArray: false,
+            elementType: null,
+            transferOwnership: raw.transferOwnership,
+            nullable: raw.nullable ?? false,
+        });
     }
-    for (const rawFunction of raw.functions) {
-        const normalized = normalizeFunction(rawFunction, nsName, ctx);
-        functions.set(normalized.name, normalized);
+    normalizeClass(raw, currentNamespace) {
+        let parent = null;
+        if (raw.parent) {
+            const qualified = this.qualifyTypeName(raw.parent, currentNamespace);
+            if (qualified.includes(".")) {
+                parent = qualified;
+            }
+        }
+        return {
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            parent,
+            abstract: raw.abstract ?? false,
+            glibTypeName: raw.glibTypeName,
+            glibGetType: raw.glibGetType,
+            cSymbolPrefix: raw.cSymbolPrefix,
+            fundamental: raw.fundamental ?? false,
+            refFunc: raw.refFunc,
+            unrefFunc: raw.unrefFunc,
+            implements: raw.implements.map((impl) => this.qualifyTypeName(impl, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            constructors: raw.constructors.map((c) => this.normalizeConstructor(c, currentNamespace)),
+            staticFunctions: raw.functions.map((f) => this.normalizeFunction(f, currentNamespace)),
+            properties: raw.properties.map((p) => this.normalizeProperty(p, currentNamespace)),
+            signals: raw.signals.map((s) => this.normalizeSignal(s, currentNamespace)),
+            doc: raw.doc,
+        };
     }
-    for (const rawConstant of raw.constants) {
-        const normalized = normalizeConstant(rawConstant, nsName, ctx);
-        constants.set(normalized.name, normalized);
+    normalizeInterface(raw, currentNamespace) {
+        return {
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            glibTypeName: raw.glibTypeName,
+            prerequisites: raw.prerequisites.map((prereq) => this.qualifyTypeName(prereq, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            properties: raw.properties.map((p) => this.normalizeProperty(p, currentNamespace)),
+            signals: raw.signals.map((s) => this.normalizeSignal(s, currentNamespace)),
+            doc: raw.doc,
+        };
     }
-    for (const rawAlias of raw.aliases) {
-        const normalized = normalizeAlias(rawAlias, nsName, ctx);
-        aliases.set(normalized.name, normalized);
+    normalizeRecord(raw, currentNamespace) {
+        return new GirRecord({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            opaque: raw.opaque ?? false,
+            disguised: raw.disguised ?? false,
+            glibTypeName: raw.glibTypeName,
+            glibGetType: raw.glibGetType,
+            isGtypeStructFor: raw.isGtypeStructFor,
+            copyFunction: raw.copyFunction,
+            freeFunction: raw.freeFunction,
+            fields: raw.fields.map((f) => this.normalizeField(f, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            constructors: raw.constructors.map((c) => this.normalizeConstructor(c, currentNamespace)),
+            staticFunctions: raw.functions.map((f) => this.normalizeFunction(f, currentNamespace)),
+            doc: raw.doc,
+        });
     }
-    return new GirNamespace({
-        name: raw.name,
-        version: raw.version,
-        sharedLibrary: raw.sharedLibrary,
-        cPrefix: raw.cPrefix,
-        classes,
-        interfaces,
-        records,
-        enumerations,
-        bitfields,
-        callbacks,
-        functions,
-        constants,
-        aliases,
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a type reference, qualifying it with its namespace if not intrinsic.
- */
-const normalizeTypeName = (typeName, currentNamespace, ctx) => {
-    if (isIntrinsicType(typeName)) {
-        return typeName;
+    normalizeEnumeration(raw, currentNamespace) {
+        return new GirEnumeration({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            members: raw.members.map((m) => new GirEnumerationMember({
+                name: m.name,
+                value: m.value,
+                cIdentifier: m.cIdentifier,
+                doc: m.doc,
+            })),
+            glibGetType: raw.glibGetType,
+            doc: raw.doc,
+        });
     }
-    if (typeName.includes(".")) {
-        return typeName;
+    normalizeCallback(raw, currentNamespace) {
+        return new GirCallback({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            doc: raw.doc,
+        });
     }
-    const currentNs = ctx.rawNamespaces.get(currentNamespace);
-    if (currentNs && typeExistsInNamespace(typeName, currentNs)) {
-        return qualifiedName(currentNamespace, typeName);
+    normalizeConstant(raw, currentNamespace) {
+        return new GirConstant({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            value: raw.value,
+            type: this.normalizeType(raw.type, currentNamespace),
+            doc: raw.doc,
+        });
     }
-    for (const [nsName, ns] of ctx.rawNamespaces) {
-        if (nsName !== currentNamespace && typeExistsInNamespace(typeName, ns)) {
-            return qualifiedName(nsName, typeName);
-        }
+    normalizeAlias(raw, currentNamespace) {
+        return new GirAlias({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            targetType: this.normalizeType(raw.targetType, currentNamespace),
+            doc: raw.doc,
+        });
     }
-    return qualifiedName(currentNamespace, typeName);
-};
-/**
- * Checks if a type name exists in a namespace.
- */
-const typeExistsInNamespace = (typeName, ns) => {
-    return (ns.classes.some((c) => c.name === typeName) ||
-        ns.interfaces.some((i) => i.name === typeName) ||
-        ns.records.some((r) => r.name === typeName) ||
-        ns.enumerations.some((e) => e.name === typeName) ||
-        ns.bitfields.some((b) => b.name === typeName) ||
-        ns.callbacks.some((c) => c.name === typeName) ||
-        ns.aliases.some((a) => a.name === typeName));
-};
-const buildContainerTypeBase = (raw) => ({
-    cType: raw.cType,
-    containerType: raw.containerType,
-    transferOwnership: raw.transferOwnership,
-    nullable: raw.nullable ?? false,
-});
-/**
- * Normalizes a raw type to a normalized type.
- */
-const normalizeType = (raw, currentNamespace, ctx) => {
-    if (raw.containerType === "ghashtable") {
-        const typeParams = (raw.typeParameters ?? []).map((tp) => normalizeType(tp, currentNamespace, ctx));
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: qualifiedName("GLib", "HashTable"),
-            isArray: false,
-            elementType: typeParams[1] ?? null,
-            typeParameters: typeParams,
+    normalizeMethod(raw, currentNamespace) {
+        return new GirMethod({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            instanceParameter: raw.instanceParameter
+                ? this.normalizeParameter(raw.instanceParameter, currentNamespace)
+                : undefined,
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            finishFunc: raw.finishFunc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
         });
     }
-    if (raw.containerType === "gptrarray" || raw.containerType === "garray") {
-        const typeParams = (raw.typeParameters ?? []).map((tp) => normalizeType(tp, currentNamespace, ctx));
-        const typeName = raw.containerType === "gptrarray" ? "PtrArray" : "Array";
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: qualifiedName("GLib", typeName),
-            isArray: true,
-            elementType: typeParams[0] ?? null,
-            typeParameters: typeParams,
+    normalizeConstructor(raw, currentNamespace) {
+        return new GirConstructor({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
         });
     }
-    if (raw.containerType === "glist" || raw.containerType === "gslist") {
-        const elementType = raw.elementType ? normalizeType(raw.elementType, currentNamespace, ctx) : null;
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: "array",
-            isArray: true,
-            elementType,
-            typeParameters: elementType ? [elementType] : [],
+    normalizeFunction(raw, currentNamespace) {
+        return new GirFunction({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
         });
     }
-    const isArray = raw.isArray === true || raw.name === "array";
-    if (isArray && raw.elementType) {
-        return new GirType({
-            name: "array",
-            cType: raw.cType,
-            isArray: true,
-            elementType: normalizeType(raw.elementType, currentNamespace, ctx),
-            transferOwnership: raw.transferOwnership,
+    normalizeParameter(raw, currentNamespace) {
+        return new GirParameter({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            direction: raw.direction ?? "in",
+            callerAllocates: raw.callerAllocates ?? false,
             nullable: raw.nullable ?? false,
-            sizeParamIndex: raw.sizeParamIndex,
-            zeroTerminated: raw.zeroTerminated,
-            fixedSize: raw.fixedSize,
+            optional: raw.optional ?? false,
+            scope: raw.scope,
+            closure: raw.closure,
+            destroy: raw.destroy,
+            transferOwnership: raw.transferOwnership,
+            doc: raw.doc,
         });
     }
-    if (isArray) {
-        return new GirType({
-            name: "array",
-            cType: raw.cType,
-            isArray: true,
-            elementType: null,
-            transferOwnership: raw.transferOwnership,
-            nullable: raw.nullable ?? false,
-            sizeParamIndex: raw.sizeParamIndex,
-            zeroTerminated: raw.zeroTerminated,
-            fixedSize: raw.fixedSize,
+    normalizeProperty(raw, currentNamespace) {
+        return new GirProperty({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            readable: raw.readable ?? true,
+            writable: raw.writable ?? false,
+            constructOnly: raw.constructOnly ?? false,
+            defaultValue: parseDefaultValue(raw.defaultValueRaw),
+            getter: raw.getter,
+            setter: raw.setter,
+            doc: raw.doc,
         });
     }
-    return new GirType({
-        name: normalizeTypeName(raw.name, currentNamespace, ctx),
-        cType: raw.cType,
-        isArray: false,
-        elementType: null,
-        transferOwnership: raw.transferOwnership,
-        nullable: raw.nullable ?? false,
-    });
-};
-/**
- * Normalizes a raw class to a normalized class.
- */
-const normalizeClass = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    let parent = null;
-    if (raw.parent) {
-        const normalizedParent = normalizeTypeName(raw.parent, currentNamespace, ctx);
-        if (typeof normalizedParent !== "string" || normalizedParent.includes(".")) {
-            parent = normalizedParent;
-        }
+    normalizeSignal(raw, currentNamespace) {
+        return new GirSignal({
+            name: raw.name,
+            when: raw.when ?? "last",
+            returnType: raw.returnType ? this.normalizeType(raw.returnType, currentNamespace) : null,
+            parameters: (raw.parameters ?? []).map((p) => this.normalizeParameter(p, currentNamespace)),
+            doc: raw.doc,
+        });
     }
-    const implementsRefs = raw.implements.map((impl) => {
-        const normalized = normalizeTypeName(impl, currentNamespace, ctx);
-        return normalized;
-    });
-    return new GirClass({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        parent,
-        abstract: raw.abstract ?? false,
-        glibTypeName: raw.glibTypeName,
-        glibGetType: raw.glibGetType,
-        cSymbolPrefix: raw.cSymbolPrefix,
-        fundamental: raw.fundamental ?? false,
-        refFunc: raw.refFunc,
-        unrefFunc: raw.unrefFunc,
-        implements: implementsRefs,
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        constructors: raw.constructors.map((c) => normalizeConstructor(c, currentNamespace, ctx)),
-        staticFunctions: raw.functions.map((f) => normalizeFunction(f, currentNamespace, ctx)),
-        properties: raw.properties.map((p) => normalizeProperty(p, currentNamespace, ctx)),
-        signals: raw.signals.map((s) => normalizeSignal(s, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw interface to a normalized interface.
- */
-const normalizeInterface = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    const prerequisites = raw.prerequisites.map((prereq) => {
-        const normalized = normalizeTypeName(prereq, currentNamespace, ctx);
-        return normalized;
-    });
-    return new GirInterface({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        glibTypeName: raw.glibTypeName,
-        prerequisites,
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        properties: raw.properties.map((p) => normalizeProperty(p, currentNamespace, ctx)),
-        signals: raw.signals.map((s) => normalizeSignal(s, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw record to a normalized record.
- */
-const normalizeRecord = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    return new GirRecord({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        opaque: raw.opaque ?? false,
-        disguised: raw.disguised ?? false,
-        glibTypeName: raw.glibTypeName,
-        glibGetType: raw.glibGetType,
-        isGtypeStructFor: raw.isGtypeStructFor,
-        copyFunction: raw.copyFunction,
-        freeFunction: raw.freeFunction,
-        fields: raw.fields.map((f) => normalizeField(f, currentNamespace, ctx)),
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        constructors: raw.constructors.map((c) => normalizeConstructor(c, currentNamespace, ctx)),
-        staticFunctions: raw.functions.map((f) => normalizeFunction(f, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw enumeration to a normalized enumeration.
- */
-const normalizeEnumeration = (raw, currentNamespace) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    return new GirEnumeration({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        members: raw.members.map((m) => new GirEnumerationMember({
-            name: m.name,
-            value: m.value,
-            cIdentifier: m.cIdentifier,
-            doc: m.doc,
-        })),
-        glibGetType: raw.glibGetType,
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw callback to a normalized callback.
- */
-const normalizeCallback = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    return new GirCallback({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw constant to a normalized constant.
- */
-const normalizeConstant = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    return new GirConstant({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        value: raw.value,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw alias to a normalized alias.
- */
-const normalizeAlias = (raw, currentNamespace, ctx) => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-    return new GirAlias({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        targetType: normalizeType(raw.targetType, currentNamespace, ctx),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw method to a normalized method.
- */
-const normalizeMethod = (raw, currentNamespace, ctx) => {
-    return new GirMethod({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        instanceParameter: raw.instanceParameter
-            ? normalizeParameter(raw.instanceParameter, currentNamespace, ctx)
-            : undefined,
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        finishFunc: raw.finishFunc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
-/**
- * Normalizes a raw constructor to a normalized constructor.
- */
-const normalizeConstructor = (raw, currentNamespace, ctx) => {
-    return new GirConstructor({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
-/**
- * Normalizes a raw function to a normalized function.
- */
-const normalizeFunction = (raw, currentNamespace, ctx) => {
-    return new GirFunction({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
-/**
- * Normalizes a raw parameter to a normalized parameter.
- */
-const normalizeParameter = (raw, currentNamespace, ctx) => {
-    return new GirParameter({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        direction: raw.direction ?? "in",
-        callerAllocates: raw.callerAllocates ?? false,
-        nullable: raw.nullable ?? false,
-        optional: raw.optional ?? false,
-        scope: raw.scope,
-        closure: raw.closure,
-        destroy: raw.destroy,
-        transferOwnership: raw.transferOwnership,
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw property to a normalized property.
- */
-const normalizeProperty = (raw, currentNamespace, ctx) => {
-    return new GirProperty({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        readable: raw.readable ?? true,
-        writable: raw.writable ?? false,
-        constructOnly: raw.constructOnly ?? false,
-        defaultValue: parseDefaultValue(raw.defaultValueRaw),
-        getter: raw.getter,
-        setter: raw.setter,
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw signal to a normalized signal.
- */
-const normalizeSignal = (raw, currentNamespace, ctx) => {
-    return new GirSignal({
-        name: raw.name,
-        when: raw.when ?? "last",
-        returnType: raw.returnType ? normalizeType(raw.returnType, currentNamespace, ctx) : null,
-        parameters: (raw.parameters ?? []).map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
-/**
- * Normalizes a raw field to a normalized field.
- */
-const normalizeField = (raw, currentNamespace, ctx) => {
-    return new GirField({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        writable: raw.writable ?? false,
-        readable: raw.readable ?? true,
-        private: raw.private ?? false,
-        doc: raw.doc,
-    });
-};
+    normalizeField(raw, currentNamespace) {
+        return new GirField({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            writable: raw.writable ?? false,
+            readable: raw.readable ?? true,
+            private: raw.private ?? false,
+            doc: raw.doc,
+        });
+    }
+}
 //# sourceMappingURL=normalizer.js.map