@gtkx/gir 0.20.0 → 0.21.0

package/dist/internal/parser.js

@@ -1,11 +1,3 @@
-/**
- * GObject Introspection XML (GIR) parser.
- *
- * Parses GIR files to extract type information for GTK/GLib libraries.
- * Outputs raw GIR types that are then normalized by the normalizer.
- *
- * @internal
- */
 import { XMLParser } from "fast-xml-parser";
 const ARRAY_ELEMENT_PATHS = new Set([
     "namespace.class",
@@ -18,7 +10,7 @@ const ARRAY_ELEMENT_PATHS = new Set([
     "namespace.constant",
     "namespace.alias",
     "namespace.class.method",
-    "namespace.class.constructor",
+    "namespace.class._constructor",
     "namespace.class.function",
     "namespace.class.property",
     "namespace.class.signal",
@@ -28,11 +20,11 @@ const ARRAY_ELEMENT_PATHS = new Set([
     "namespace.interface.signal",
     "namespace.interface.glib:signal",
     "namespace.record.method",
-    "namespace.record.constructor",
+    "namespace.record._constructor",
     "namespace.record.function",
     "namespace.record.field",
     "namespace.class.method.parameters.parameter",
-    "namespace.class.constructor.parameters.parameter",
+    "namespace.class._constructor.parameters.parameter",
     "namespace.class.function.parameters.parameter",
     "namespace.function.parameters.parameter",
     "namespace.enumeration.member",
@@ -41,11 +33,14 @@ const ARRAY_ELEMENT_PATHS = new Set([
     "namespace.class.glib:signal.parameters.parameter",
     "namespace.interface.glib:signal.parameters.parameter",
     "namespace.record.method.parameters.parameter",
-    "namespace.record.constructor.parameters.parameter",
+    "namespace.record._constructor.parameters.parameter",
     "namespace.record.function.parameters.parameter",
     "namespace.callback.parameters.parameter",
 ]);
-const extractDoc = (node) => {
+const INCLUDE_RE = /<include\s+name="([^"]+)"\s+version="([^"]+)"/g;
+const NS_NAME_RE = /<namespace\s[^>]*name="([^"]+)"/;
+const NS_VERSION_RE = /<namespace\s[^>]*version="([^"]+)"/;
+function extractDoc(node) {
     const doc = node.doc;
     if (!doc)
         return undefined;
@@ -53,49 +48,69 @@ const extractDoc = (node) => {
     if (typeof text !== "string")
         return undefined;
     return text.trim();
-};
-const ensureArray = (value) => Array.isArray(value) ? value : [];
+}
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [];
+}
 /**
  * Parser for GObject Introspection XML (GIR) files.
  *
- * Converts GIR XML into raw TypeScript objects.
+ * Provides both a lightweight header parse (for dependency graph discovery)
+ * and a full parse (for complete namespace extraction).
  */
-export class RawGirParser {
+export class GirParser {
     parser;
-    includeNonIntrospectableNamespaces;
-    currentNamespace = "";
-    constructor(options = {}) {
-        this.includeNonIntrospectableNamespaces = options.includeNonIntrospectableNamespaces ?? new Set();
+    constructor() {
         this.parser = new XMLParser({
             ignoreAttributes: false,
             attributeNamePrefix: "@_",
             textNodeName: "#text",
+            transformTagName: (tagName) => (tagName === "constructor" ? "_constructor" : tagName),
             isArray: (_name, jpath, _isLeafNode, _isAttribute) => {
+                if (typeof jpath !== "string")
+                    return false;
                 const path = jpath.split(".").slice(1).join(".");
                 return ARRAY_ELEMENT_PATHS.has(path);
             },
+            processEntities: { maxTotalExpansions: 100000 },
         });
     }
-    shouldIncludeNonIntrospectable() {
-        return this.includeNonIntrospectableNamespaces.has(this.currentNamespace);
-    }
-    isIntrospectable(node) {
-        if (node["@_introspectable"] === "0") {
-            return this.shouldIncludeNonIntrospectable();
+    /**
+     * Lightweight header parse using regex — extracts namespace name, version,
+     * and `<include>` dependencies without paying the cost of full XML parsing.
+     */
+    parseHeader(girXml) {
+        const nameMatch = NS_NAME_RE.exec(girXml);
+        const versionMatch = NS_VERSION_RE.exec(girXml);
+        if (!nameMatch || !versionMatch) {
+            throw new Error("Failed to parse GIR header: missing namespace name or version");
         }
-        return true;
+        const dependencies = [];
+        INCLUDE_RE.lastIndex = 0;
+        for (let m = INCLUDE_RE.exec(girXml); m !== null; m = INCLUDE_RE.exec(girXml)) {
+            const name = m[1];
+            const version = m[2];
+            if (name && version) {
+                dependencies.push({ name, version });
+            }
+        }
+        const namespaceName = nameMatch[1];
+        const namespaceVersion = versionMatch[1];
+        if (!namespaceName || !namespaceVersion) {
+            throw new Error("Failed to parse GIR header: missing namespace name or version");
+        }
+        return { namespaceName, namespaceVersion, dependencies };
     }
     /**
-     * Parses a GIR XML string into a raw namespace object.
+     * Full parse of a GIR XML string into a raw namespace.
      */
-    parse(girXml) {
+    parseNamespace(girXml) {
         const parsed = this.parser.parse(girXml);
         const repository = parsed.repository;
         if (!repository?.namespace) {
             throw new Error("Failed to parse GIR file: missing repository or namespace element");
         }
         const namespace = repository.namespace;
-        this.currentNamespace = namespace["@_name"];
         return {
             name: namespace["@_name"],
             version: namespace["@_version"],
@@ -112,22 +127,6 @@ export class RawGirParser {
             aliases: this.parseAliases(namespace.alias ?? []),
         };
     }
-    parseCallbacks(callbacks) {
-        if (!callbacks || !Array.isArray(callbacks)) {
-            return [];
-        }
-        return callbacks
-            .filter((cb) => this.isIntrospectable(cb))
-            .map((cb) => ({
-            name: String(cb["@_name"] ?? ""),
-            cType: String(cb["@_c:type"] ?? ""),
-            returnType: this.parseReturnType(cb["return-value"]),
-            parameters: this.parseParameters((cb.parameters && typeof cb.parameters === "object" && cb.parameters !== null
-                ? cb.parameters
-                : {})),
-            doc: extractDoc(cb),
-        }));
-    }
     parseClasses(classes) {
         return classes.map((cls) => ({
             name: String(cls["@_name"] ?? ""),
@@ -142,7 +141,7 @@ export class RawGirParser {
             unrefFunc: cls["@_glib:unref-func"] ? String(cls["@_glib:unref-func"]) : undefined,
             implements: this.parseImplements(cls.implements),
             methods: this.parseMethods(ensureArray(cls.method)),
-            constructors: this.parseConstructors(ensureArray(cls.constructor)),
+            constructors: this.parseConstructors(ensureArray(cls._constructor)),
             functions: this.parseFunctions(ensureArray(cls.function)),
             properties: this.parseProperties(ensureArray(cls.property)),
             signals: this.parseSignals(ensureArray(cls["glib:signal"])),
@@ -156,9 +155,8 @@ export class RawGirParser {
         return arr.map((impl) => String(impl["@_name"] ?? "")).filter(Boolean);
     }
     parseInterfaces(interfaces) {
-        if (!interfaces || !Array.isArray(interfaces)) {
+        if (!interfaces || !Array.isArray(interfaces))
             return [];
-        }
         return interfaces.map((iface) => ({
             name: String(iface["@_name"] ?? ""),
             cType: String(iface["@_c:type"] ?? iface["@_glib:type-name"] ?? ""),
@@ -177,19 +175,13 @@ export class RawGirParser {
         return arr.map((prereq) => String(prereq["@_name"] ?? "")).filter(Boolean);
     }
     parseMethods(methods) {
-        if (!methods || !Array.isArray(methods)) {
+        if (!methods || !Array.isArray(methods))
             return [];
-        }
         return methods
-            .filter((method) => this.isIntrospectable(method))
+            .filter((m) => m["@_introspectable"] !== "0")
             .map((method) => {
             const returnValue = method["return-value"];
-            const finishFunc = method["@_glib:finish-func"];
-            const shadows = method["@_shadows"];
-            const shadowedBy = method["@_shadowed-by"];
-            const parametersNode = method.parameters && typeof method.parameters === "object" && method.parameters !== null
-                ? method.parameters
-                : {};
+            const parametersNode = this.extractParametersNode(method);
             return {
                 name: String(method["@_name"] ?? ""),
                 cIdentifier: String(method["@_c:identifier"] ?? ""),
@@ -199,74 +191,208 @@ export class RawGirParser {
                 throws: method["@_throws"] === "1",
                 doc: extractDoc(method),
                 returnDoc: returnValue ? extractDoc(returnValue) : undefined,
-                finishFunc: finishFunc || undefined,
-                shadows: shadows || undefined,
-                shadowedBy: shadowedBy || undefined,
+                finishFunc: method["@_glib:finish-func"] || undefined,
+                shadows: method["@_shadows"] || undefined,
+                shadowedBy: method["@_shadowed-by"] || undefined,
             };
         });
     }
     parseConstructors(constructors) {
-        if (!constructors || !Array.isArray(constructors)) {
+        if (!constructors || !Array.isArray(constructors))
             return [];
-        }
         return constructors
-            .filter((ctor) => this.isIntrospectable(ctor))
+            .filter((c) => c["@_introspectable"] !== "0")
             .map((ctor) => {
             const returnValue = ctor["return-value"];
-            const shadows = ctor["@_shadows"];
-            const shadowedBy = ctor["@_shadowed-by"];
             return {
                 name: String(ctor["@_name"] ?? ""),
                 cIdentifier: String(ctor["@_c:identifier"] ?? ""),
                 returnType: this.parseReturnType(returnValue),
-                parameters: this.parseParameters((ctor.parameters && typeof ctor.parameters === "object" && ctor.parameters !== null
-                    ? ctor.parameters
-                    : {})),
+                parameters: this.parseParameters(this.extractParametersNode(ctor)),
                 throws: ctor["@_throws"] === "1",
                 doc: extractDoc(ctor),
                 returnDoc: returnValue ? extractDoc(returnValue) : undefined,
-                shadows: shadows || undefined,
-                shadowedBy: shadowedBy || undefined,
+                shadows: ctor["@_shadows"] || undefined,
+                shadowedBy: ctor["@_shadowed-by"] || undefined,
             };
         });
     }
     parseFunctions(functions) {
-        if (!functions || !Array.isArray(functions)) {
+        if (!functions || !Array.isArray(functions))
             return [];
-        }
         return functions
-            .filter((func) => this.isIntrospectable(func))
+            .filter((f) => f["@_introspectable"] !== "0")
             .map((func) => {
             const returnValue = func["return-value"];
-            const shadows = func["@_shadows"];
-            const shadowedBy = func["@_shadowed-by"];
             return {
                 name: String(func["@_name"] ?? ""),
                 cIdentifier: String(func["@_c:identifier"] ?? ""),
                 returnType: this.parseReturnType(returnValue),
-                parameters: this.parseParameters((func.parameters && typeof func.parameters === "object" && func.parameters !== null
-                    ? func.parameters
-                    : {})),
+                parameters: this.parseParameters(this.extractParametersNode(func)),
                 throws: func["@_throws"] === "1",
                 doc: extractDoc(func),
                 returnDoc: returnValue ? extractDoc(returnValue) : undefined,
-                shadows: shadows || undefined,
-                shadowedBy: shadowedBy || undefined,
+                shadows: func["@_shadows"] || undefined,
+                shadowedBy: func["@_shadowed-by"] || undefined,
+            };
+        });
+    }
+    parseCallbacks(callbacks) {
+        if (!callbacks || !Array.isArray(callbacks))
+            return [];
+        return callbacks
+            .filter((cb) => cb["@_introspectable"] !== "0")
+            .map((cb) => ({
+            name: String(cb["@_name"] ?? ""),
+            cType: String(cb["@_c:type"] ?? ""),
+            returnType: this.parseReturnType(cb["return-value"]),
+            parameters: this.parseParameters(this.extractParametersNode(cb)),
+            doc: extractDoc(cb),
+        }));
+    }
+    parseRecords(records) {
+        if (!records || !Array.isArray(records))
+            return [];
+        return records.map((record) => ({
+            name: String(record["@_name"] ?? ""),
+            cType: String(record["@_c:type"] ?? record["@_glib:type-name"] ?? ""),
+            opaque: record["@_opaque"] === "1",
+            disguised: record["@_disguised"] === "1",
+            glibTypeName: record["@_glib:type-name"] ? String(record["@_glib:type-name"]) : undefined,
+            glibGetType: record["@_glib:get-type"] ? String(record["@_glib:get-type"]) : undefined,
+            isGtypeStructFor: record["@_glib:is-gtype-struct-for"]
+                ? String(record["@_glib:is-gtype-struct-for"])
+                : undefined,
+            copyFunction: record["@_copy-function"] ? String(record["@_copy-function"]) : undefined,
+            freeFunction: record["@_free-function"] ? String(record["@_free-function"]) : undefined,
+            fields: this.parseFields(ensureArray(record.field)),
+            methods: this.parseMethods(ensureArray(record.method)),
+            constructors: this.parseConstructors(ensureArray(record._constructor)),
+            functions: this.parseFunctions(ensureArray(record.function)),
+            doc: extractDoc(record),
+        }));
+    }
+    parseEnumerations(enumerations) {
+        if (!enumerations || !Array.isArray(enumerations))
+            return [];
+        return enumerations.map((enumeration) => ({
+            name: String(enumeration["@_name"] ?? ""),
+            cType: String(enumeration["@_c:type"] ?? ""),
+            members: this.parseEnumerationMembers(ensureArray(enumeration.member)),
+            glibGetType: typeof enumeration["@_glib:get-type"] === "string" ? enumeration["@_glib:get-type"] : undefined,
+            doc: extractDoc(enumeration),
+        }));
+    }
+    parseEnumerationMembers(members) {
+        if (!members || !Array.isArray(members))
+            return [];
+        return members.map((member) => ({
+            name: String(member["@_name"] ?? ""),
+            value: String(member["@_value"] ?? ""),
+            cIdentifier: String(member["@_c:identifier"] ?? ""),
+            doc: extractDoc(member),
+        }));
+    }
+    parseConstants(constants) {
+        if (!constants || !Array.isArray(constants))
+            return [];
+        return constants.map((constant) => ({
+            name: String(constant["@_name"] ?? ""),
+            cType: String(constant["@_c:type"] ?? ""),
+            value: String(constant["@_value"] ?? ""),
+            type: this.parseType((constant.type ?? constant.array)),
+            doc: extractDoc(constant),
+        }));
+    }
+    parseAliases(aliases) {
+        if (!aliases || !Array.isArray(aliases))
+            return [];
+        return aliases.map((alias) => ({
+            name: String(alias["@_name"] ?? ""),
+            cType: String(alias["@_c:type"] ?? ""),
+            targetType: this.parseType(alias.type),
+            doc: extractDoc(alias),
+        }));
+    }
+    parseProperties(properties) {
+        if (!properties || !Array.isArray(properties))
+            return [];
+        return properties.map((prop) => {
+            let getter = prop["@_getter"] ? String(prop["@_getter"]) : undefined;
+            let setter = prop["@_setter"] ? String(prop["@_setter"]) : undefined;
+            const attributes = prop.attribute;
+            if (attributes) {
+                const attrList = Array.isArray(attributes) ? attributes : [attributes];
+                for (const attr of attrList) {
+                    if (attr["@_name"] === "org.gtk.Property.get" && attr["@_value"]) {
+                        getter = String(attr["@_value"]);
+                    }
+                    else if (attr["@_name"] === "org.gtk.Property.set" && attr["@_value"]) {
+                        setter = String(attr["@_value"]);
+                    }
+                }
+            }
+            return {
+                name: String(prop["@_name"] ?? ""),
+                type: this.parseType((prop.type ?? prop.array)),
+                readable: prop["@_readable"] !== "0",
+                writable: prop["@_writable"] === "1",
+                constructOnly: prop["@_construct-only"] === "1",
+                defaultValueRaw: prop["@_default-value"] !== undefined ? String(prop["@_default-value"]) : undefined,
+                getter,
+                setter,
+                doc: extractDoc(prop),
+            };
+        });
+    }
+    parseSignals(signals) {
+        if (!signals || !Array.isArray(signals))
+            return [];
+        return signals.map((signal) => {
+            const whenValue = String(signal["@_when"] ?? "last");
+            const validWhen = whenValue === "first" || whenValue === "last" || whenValue === "cleanup";
+            return {
+                name: String(signal["@_name"] ?? ""),
+                when: validWhen ? whenValue : "last",
+                returnType: signal["return-value"]
+                    ? this.parseReturnType(signal["return-value"])
+                    : undefined,
+                parameters: signal.parameters && typeof signal.parameters === "object" && signal.parameters !== null
+                    ? this.parseParameters(signal.parameters)
+                    : [],
+                doc: extractDoc(signal),
             };
         });
     }
+    parseFields(fields) {
+        if (!fields || !Array.isArray(fields))
+            return [];
+        return fields
+            .filter((field) => field.callback === undefined)
+            .map((field) => ({
+            name: String(field["@_name"] ?? ""),
+            type: this.parseType((field.type ?? field.array)),
+            writable: field["@_writable"] === "1",
+            readable: field["@_readable"] !== "0",
+            private: field["@_private"] === "1",
+            doc: extractDoc(field),
+        }));
+    }
+    extractParametersNode(node) {
+        return node.parameters && typeof node.parameters === "object" && node.parameters !== null
+            ? node.parameters
+            : {};
+    }
     parseParameters(parametersNode) {
-        if (!parametersNode?.parameter) {
+        if (!parametersNode?.parameter)
             return [];
-        }
         const params = Array.isArray(parametersNode.parameter) ? parametersNode.parameter : [parametersNode.parameter];
         return params.map((param) => this.parseSingleParameter(param));
     }
     parseInstanceParameter(parametersNode) {
         const instanceParam = parametersNode?.["instance-parameter"];
-        if (!instanceParam) {
+        if (!instanceParam)
             return undefined;
-        }
         return this.parseSingleParameter(instanceParam);
     }
     parseSingleParameter(param) {
@@ -292,9 +418,8 @@ export class RawGirParser {
         };
     }
     parseReturnType(returnValue) {
-        if (!returnValue) {
+        if (!returnValue)
             return { name: "void" };
-        }
         const type = this.parseType((returnValue.type ?? returnValue.array));
         const transferOwnership = returnValue["@_transfer-ownership"];
         if (transferOwnership === "none" || transferOwnership === "full" || transferOwnership === "container") {
@@ -306,33 +431,27 @@ export class RawGirParser {
         return type;
     }
     parseType(typeNode) {
-        if (!typeNode) {
+        if (!typeNode)
             return { name: "void" };
-        }
         const typeName = typeNode["@_name"] ? String(typeNode["@_name"]) : undefined;
         const cType = typeNode["@_c:type"] ? String(typeNode["@_c:type"]) : undefined;
         const containerResult = this.parseGLibContainerType(typeName, typeNode, cType);
-        if (containerResult) {
+        if (containerResult)
             return containerResult;
-        }
-        if (typeName) {
+        if (typeName)
             return { name: typeName, cType };
-        }
         const isArrayNode = typeNode.type ||
             typeNode["@_zero-terminated"] !== undefined ||
             typeNode["@_fixed-size"] !== undefined ||
             typeNode["@_length"] !== undefined;
         if (isArrayNode) {
-            const lengthAttr = typeNode["@_length"];
-            const zeroTerminatedAttr = typeNode["@_zero-terminated"];
-            const fixedSizeAttr = typeNode["@_fixed-size"];
             return {
                 name: "array",
                 isArray: true,
                 elementType: typeNode.type ? this.parseType(typeNode.type) : undefined,
-                sizeParamIndex: lengthAttr !== undefined ? Number(lengthAttr) : undefined,
-                zeroTerminated: zeroTerminatedAttr !== undefined ? zeroTerminatedAttr !== "0" : undefined,
-                fixedSize: fixedSizeAttr !== undefined ? Number(fixedSizeAttr) : undefined,
+                sizeParamIndex: typeNode["@_length"] !== undefined ? Number(typeNode["@_length"]) : undefined,
+                zeroTerminated: typeNode["@_zero-terminated"] !== undefined ? typeNode["@_zero-terminated"] !== "0" : undefined,
+                fixedSize: typeNode["@_fixed-size"] !== undefined ? Number(typeNode["@_fixed-size"]) : undefined,
             };
         }
         return { name: "void" };
@@ -382,6 +501,15 @@ export class RawGirParser {
                 elementType: typeParams[0],
             };
         }
+        if (typeName === "GLib.ByteArray") {
+            return {
+                name: typeName,
+                cType,
+                isArray: true,
+                containerType: "gbytearray",
+                elementType: { name: "guint8", cType: "guint8" },
+            };
+        }
         if (typeName === "GLib.List" || typeName === "GLib.SList") {
             const innerType = (typeNode.type ?? typeNode.array);
             const elementType = innerType ? this.parseType(innerType) : undefined;
@@ -396,149 +524,5 @@ export class RawGirParser {
         }
         return null;
     }
-    parseProperties(properties) {
-        if (!properties || !Array.isArray(properties)) {
-            return [];
-        }
-        return properties.map((prop) => {
-            let getter = prop["@_getter"] ? String(prop["@_getter"]) : undefined;
-            let setter = prop["@_setter"] ? String(prop["@_setter"]) : undefined;
-            const attributes = prop.attribute;
-            if (attributes) {
-                const attrList = Array.isArray(attributes) ? attributes : [attributes];
-                for (const attr of attrList) {
-                    const attrName = attr["@_name"];
-                    const attrValue = attr["@_value"];
-                    if (attrName === "org.gtk.Property.get" && attrValue) {
-                        getter = String(attrValue);
-                    }
-                    else if (attrName === "org.gtk.Property.set" && attrValue) {
-                        setter = String(attrValue);
-                    }
-                }
-            }
-            return {
-                name: String(prop["@_name"] ?? ""),
-                type: this.parseType((prop.type ?? prop.array)),
-                readable: prop["@_readable"] !== "0",
-                writable: prop["@_writable"] === "1",
-                constructOnly: prop["@_construct-only"] === "1",
-                defaultValueRaw: prop["@_default-value"] !== undefined ? String(prop["@_default-value"]) : undefined,
-                getter,
-                setter,
-                doc: extractDoc(prop),
-            };
-        });
-    }
-    parseSignals(signals) {
-        if (!signals || !Array.isArray(signals)) {
-            return [];
-        }
-        return signals.map((signal) => {
-            const whenValue = String(signal["@_when"] ?? "last");
-            const validWhen = whenValue === "first" || whenValue === "last" || whenValue === "cleanup";
-            return {
-                name: String(signal["@_name"] ?? ""),
-                when: validWhen ? whenValue : "last",
-                returnType: signal["return-value"]
-                    ? this.parseReturnType(signal["return-value"])
-                    : undefined,
-                parameters: signal.parameters && typeof signal.parameters === "object" && signal.parameters !== null
-                    ? this.parseParameters(signal.parameters)
-                    : [],
-                doc: extractDoc(signal),
-            };
-        });
-    }
-    parseRecords(records) {
-        if (!records || !Array.isArray(records)) {
-            return [];
-        }
-        return records.map((record) => ({
-            name: String(record["@_name"] ?? ""),
-            cType: String(record["@_c:type"] ?? record["@_glib:type-name"] ?? ""),
-            opaque: record["@_opaque"] === "1",
-            disguised: record["@_disguised"] === "1",
-            glibTypeName: record["@_glib:type-name"] ? String(record["@_glib:type-name"]) : undefined,
-            glibGetType: record["@_glib:get-type"] ? String(record["@_glib:get-type"]) : undefined,
-            isGtypeStructFor: record["@_glib:is-gtype-struct-for"]
-                ? String(record["@_glib:is-gtype-struct-for"])
-                : undefined,
-            copyFunction: record["@_copy-function"] ? String(record["@_copy-function"]) : undefined,
-            freeFunction: record["@_free-function"] ? String(record["@_free-function"]) : undefined,
-            fields: this.parseFields(ensureArray(record.field)),
-            methods: this.parseMethods(ensureArray(record.method)),
-            constructors: this.parseConstructors(ensureArray(record.constructor)),
-            functions: this.parseFunctions(ensureArray(record.function)),
-            doc: extractDoc(record),
-        }));
-    }
-    parseFields(fields) {
-        if (!fields || !Array.isArray(fields)) {
-            return [];
-        }
-        return fields
-            .filter((field) => {
-            const hasCallback = field.callback !== undefined;
-            return !hasCallback;
-        })
-            .map((field) => ({
-            name: String(field["@_name"] ?? ""),
-            type: this.parseType((field.type ?? field.array)),
-            writable: field["@_writable"] === "1",
-            readable: field["@_readable"] !== "0",
-            private: field["@_private"] === "1",
-            doc: extractDoc(field),
-        }));
-    }
-    parseEnumerations(enumerations) {
-        if (!enumerations || !Array.isArray(enumerations)) {
-            return [];
-        }
-        return enumerations.map((enumeration) => {
-            const glibGetType = enumeration["@_glib:get-type"];
-            return {
-                name: String(enumeration["@_name"] ?? ""),
-                cType: String(enumeration["@_c:type"] ?? ""),
-                members: this.parseEnumerationMembers(ensureArray(enumeration.member)),
-                glibGetType: typeof glibGetType === "string" ? glibGetType : undefined,
-                doc: extractDoc(enumeration),
-            };
-        });
-    }
-    parseEnumerationMembers(members) {
-        if (!members || !Array.isArray(members)) {
-            return [];
-        }
-        return members.map((member) => ({
-            name: String(member["@_name"] ?? ""),
-            value: String(member["@_value"] ?? ""),
-            cIdentifier: String(member["@_c:identifier"] ?? ""),
-            doc: extractDoc(member),
-        }));
-    }
-    parseConstants(constants) {
-        if (!constants || !Array.isArray(constants)) {
-            return [];
-        }
-        return constants.map((constant) => ({
-            name: String(constant["@_name"] ?? ""),
-            cType: String(constant["@_c:type"] ?? ""),
-            value: String(constant["@_value"] ?? ""),
-            type: this.parseType((constant.type ?? constant.array)),
-            doc: extractDoc(constant),
-        }));
-    }
-    parseAliases(aliases) {
-        if (!aliases || !Array.isArray(aliases)) {
-            return [];
-        }
-        return aliases.map((alias) => ({
-            name: String(alias["@_name"] ?? ""),
-            cType: String(alias["@_c:type"] ?? ""),
-            targetType: this.parseType(alias.type),
-            doc: extractDoc(alias),
-        }));
-    }
 }
 //# sourceMappingURL=parser.js.map