@ts-for-gir/cli 4.0.0-beta.37 → 4.0.0-beta.39

package/bin/ts-for-gir

@@ -29,12 +29,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../.yarn/cache/lodash-npm-4.17.21-6382451519-c08619c038.zip/node_modules/lodash/lodash.js
+// ../../.yarn/cache/lodash-npm-4.17.23-50bdb1c01a-82504c8825.zip/node_modules/lodash/lodash.js
 var require_lodash = __commonJS({
-  "../../.yarn/cache/lodash-npm-4.17.21-6382451519-c08619c038.zip/node_modules/lodash/lodash.js"(exports2, module) {
+  "../../.yarn/cache/lodash-npm-4.17.23-50bdb1c01a-82504c8825.zip/node_modules/lodash/lodash.js"(exports2, module) {
     (function() {
       var undefined2;
-      var VERSION = "4.17.21";
+      var VERSION = "4.17.23";
       var LARGE_ARRAY_SIZE = 200;
       var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
       var HASH_UNDEFINED = "__lodash_hash_undefined__";
@@ -1962,8 +1962,28 @@ var require_lodash = __commonJS({
         }
         function baseUnset(object, path) {
           path = castPath(path, object);
-          object = parent(object, path);
-          return object == null || delete object[toKey(last(path))];
+          var index = -1, length = path.length;
+          if (!length) {
+            return true;
+          }
+          var isRootPrimitive = object == null || typeof object !== "object" && typeof object !== "function";
+          while (++index < length) {
+            var key = path[index];
+            if (typeof key !== "string") {
+              continue;
+            }
+            if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
+              return false;
+            }
+            if (key === "constructor" && index + 1 < length && typeof path[index + 1] === "string" && path[index + 1] === "prototype") {
+              if (isRootPrimitive && index === 0) {
+                continue;
+              }
+              return false;
+            }
+          }
+          var obj = parent(object, path);
+          return obj == null || delete obj[toKey(last(path))];
         }
         function baseUpdate(object, path, updater, customizer) {
           return baseSet(object, path, updater(baseGet(object, path)), customizer);
@@ -4127,7 +4147,7 @@ var require_lodash = __commonJS({
           var tag = baseGetTag(value);
           return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
         }
-        function isFinite(value) {
+        function isFinite2(value) {
           return typeof value == "number" && nativeIsFinite(value);
         }
         function isFunction(value) {
@@ -5228,7 +5248,7 @@ var require_lodash = __commonJS({
         lodash2.isEqual = isEqual2;
         lodash2.isEqualWith = isEqualWith;
         lodash2.isError = isError;
-        lodash2.isFinite = isFinite;
+        lodash2.isFinite = isFinite2;
         lodash2.isFunction = isFunction;
         lodash2.isInteger = isInteger;
         lodash2.isLength = isLength;
@@ -6576,7 +6596,7 @@ __export(parser_exports, {
   parseGir: () => parseGir
 });
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/util.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/util.js
 var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
 var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
 var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
@@ -6604,7 +6624,7 @@ function isExist(v) {
   return typeof v !== "undefined";
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/validator.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/validator.js
 var defaultOptions = {
   allowBooleanAttributes: false,
   //A tag can have attributes without any value
@@ -6842,7 +6862,7 @@ function validateAttributeString(attrStr, options2) {
     if (!validateAttrName(attrName)) {
       return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
     }
-    if (!attrNames.hasOwnProperty(attrName)) {
+    if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) {
       attrNames[attrName] = 1;
     } else {
       return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
@@ -6910,7 +6930,7 @@ function getPositionFromMatch(match) {
   return match.startIndex + match[1].length;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
 var defaultOptions2 = {
   preserveOrder: false,
   attributeNamePrefix: "@_",
@@ -6954,24 +6974,55 @@ var defaultOptions2 = {
     return tagName;
   },
   // skipEmptyListItem: false
-  captureMetaData: false
+  captureMetaData: false,
+  maxNestedTags: 100,
+  strictReservedNames: true
 };
+function normalizeProcessEntities(value) {
+  if (typeof value === "boolean") {
+    return {
+      enabled: value,
+      // true or false
+      maxEntitySize: 1e4,
+      maxExpansionDepth: 10,
+      maxTotalExpansions: 1e3,
+      maxExpandedLength: 1e5,
+      allowedTags: null,
+      tagFilter: null
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    return {
+      enabled: value.enabled !== false,
+      // default true if not specified
+      maxEntitySize: value.maxEntitySize ?? 1e4,
+      maxExpansionDepth: value.maxExpansionDepth ?? 10,
+      maxTotalExpansions: value.maxTotalExpansions ?? 1e3,
+      maxExpandedLength: value.maxExpandedLength ?? 1e5,
+      allowedTags: value.allowedTags ?? null,
+      tagFilter: value.tagFilter ?? null
+    };
+  }
+  return normalizeProcessEntities(true);
+}
 var buildOptions = function(options2) {
-  return Object.assign({}, defaultOptions2, options2);
+  const built = Object.assign({}, defaultOptions2, options2);
+  built.processEntities = normalizeProcessEntities(built.processEntities);
+  return built;
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
 var METADATA_SYMBOL;
 if (typeof Symbol !== "function") {
   METADATA_SYMBOL = "@@xmlMetadata";
 } else {
-  METADATA_SYMBOL = Symbol("XML Node Metadata");
+  METADATA_SYMBOL = /* @__PURE__ */ Symbol("XML Node Metadata");
 }
 var XmlNode = class {
   constructor(tagname) {
     this.tagname = tagname;
     this.child = [];
-    this[":@"] = {};
+    this[":@"] = /* @__PURE__ */ Object.create(null);
   }
   add(key, val) {
     if (key === "__proto__") key = "#__proto__";
@@ -6994,170 +7045,263 @@ var XmlNode = class {
   }
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
-function readDocType(xmlData, i) {
-  const entities = {};
-  if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
-    i = i + 9;
-    let angleBracketsCount = 1;
-    let hasBody = false, comment = false;
-    let exp = "";
-    for (; i < xmlData.length; i++) {
-      if (xmlData[i] === "<" && !comment) {
-        if (hasBody && hasSeq(xmlData, "!ENTITY", i)) {
-          i += 7;
-          let entityName, val;
-          [entityName, val, i] = readEntityExp(xmlData, i + 1);
-          if (val.indexOf("&") === -1)
-            entities[entityName] = {
-              regx: RegExp(`&${entityName};`, "g"),
-              val
-            };
-        } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
-          i += 8;
-          const { index } = readElementExp(xmlData, i + 1);
-          i = index;
-        } else if (hasBody && hasSeq(xmlData, "!ATTLIST", i)) {
-          i += 8;
-        } else if (hasBody && hasSeq(xmlData, "!NOTATION", i)) {
-          i += 9;
-          const { index } = readNotationExp(xmlData, i + 1);
-          i = index;
-        } else if (hasSeq(xmlData, "!--", i)) comment = true;
-        else throw new Error(`Invalid DOCTYPE`);
-        angleBracketsCount++;
-        exp = "";
-      } else if (xmlData[i] === ">") {
-        if (comment) {
-          if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
-            comment = false;
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+var DocTypeReader = class {
+  constructor(options2) {
+    this.suppressValidationErr = !options2;
+    this.options = options2;
+  }
+  readDocType(xmlData, i) {
+    const entities = /* @__PURE__ */ Object.create(null);
+    if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
+      i = i + 9;
+      let angleBracketsCount = 1;
+      let hasBody = false, comment = false;
+      let exp = "";
+      for (; i < xmlData.length; i++) {
+        if (xmlData[i] === "<" && !comment) {
+          if (hasBody && hasSeq(xmlData, "!ENTITY", i)) {
+            i += 7;
+            let entityName, val;
+            [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
+            if (val.indexOf("&") === -1) {
+              const escaped = entityName.replace(/[.\-+*:]/g, "\\.");
+              entities[entityName] = {
+                regx: RegExp(`&${escaped};`, "g"),
+                val
+              };
+            }
+          } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
+            i += 8;
+            const { index } = this.readElementExp(xmlData, i + 1);
+            i = index;
+          } else if (hasBody && hasSeq(xmlData, "!ATTLIST", i)) {
+            i += 8;
+          } else if (hasBody && hasSeq(xmlData, "!NOTATION", i)) {
+            i += 9;
+            const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);
+            i = index;
+          } else if (hasSeq(xmlData, "!--", i)) comment = true;
+          else throw new Error(`Invalid DOCTYPE`);
+          angleBracketsCount++;
+          exp = "";
+        } else if (xmlData[i] === ">") {
+          if (comment) {
+            if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
+              comment = false;
+              angleBracketsCount--;
+            }
+          } else {
             angleBracketsCount--;
           }
+          if (angleBracketsCount === 0) {
+            break;
+          }
+        } else if (xmlData[i] === "[") {
+          hasBody = true;
         } else {
-          angleBracketsCount--;
-        }
-        if (angleBracketsCount === 0) {
-          break;
+          exp += xmlData[i];
         }
-      } else if (xmlData[i] === "[") {
-        hasBody = true;
-      } else {
-        exp += xmlData[i];
       }
+      if (angleBracketsCount !== 0) {
+        throw new Error(`Unclosed DOCTYPE`);
+      }
+    } else {
+      throw new Error(`Invalid Tag instead of DOCTYPE`);
     }
-    if (angleBracketsCount !== 0) {
-      throw new Error(`Unclosed DOCTYPE`);
-    }
-  } else {
-    throw new Error(`Invalid Tag instead of DOCTYPE`);
+    return { entities, i };
   }
-  return { entities, i };
-}
-var skipWhitespace = (data, index) => {
-  while (index < data.length && /\s/.test(data[index])) {
-    index++;
-  }
-  return index;
-};
-function readEntityExp(xmlData, i) {
-  i = skipWhitespace(xmlData, i);
-  let entityName = "";
-  while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
-    entityName += xmlData[i];
-    i++;
-  }
-  validateEntityName(entityName);
-  i = skipWhitespace(xmlData, i);
-  if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
-    throw new Error("External entities are not supported");
-  } else if (xmlData[i] === "%") {
-    throw new Error("Parameter entities are not supported");
-  }
-  let entityValue = "";
-  [i, entityValue] = readIdentifierVal(xmlData, i, "entity");
-  i--;
-  return [entityName, entityValue, i];
-}
-function readNotationExp(xmlData, i) {
-  i = skipWhitespace(xmlData, i);
-  let notationName = "";
-  while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-    notationName += xmlData[i];
-    i++;
-  }
-  validateEntityName(notationName);
-  i = skipWhitespace(xmlData, i);
-  const identifierType = xmlData.substring(i, i + 6).toUpperCase();
-  if (identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
-    throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
-  }
-  i += identifierType.length;
-  i = skipWhitespace(xmlData, i);
-  let publicIdentifier = null;
-  let systemIdentifier = null;
-  if (identifierType === "PUBLIC") {
-    [i, publicIdentifier] = readIdentifierVal(xmlData, i, "publicIdentifier");
+  readEntityExp(xmlData, i) {
     i = skipWhitespace(xmlData, i);
-    if (xmlData[i] === '"' || xmlData[i] === "'") {
-      [i, systemIdentifier] = readIdentifierVal(xmlData, i, "systemIdentifier");
+    let entityName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
+      entityName += xmlData[i];
+      i++;
     }
-  } else if (identifierType === "SYSTEM") {
-    [i, systemIdentifier] = readIdentifierVal(xmlData, i, "systemIdentifier");
-    if (!systemIdentifier) {
-      throw new Error("Missing mandatory system identifier for SYSTEM notation");
+    validateEntityName(entityName);
+    i = skipWhitespace(xmlData, i);
+    if (!this.suppressValidationErr) {
+      if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
+        throw new Error("External entities are not supported");
+      } else if (xmlData[i] === "%") {
+        throw new Error("Parameter entities are not supported");
+      }
+    }
+    let entityValue = "";
+    [i, entityValue] = this.readIdentifierVal(xmlData, i, "entity");
+    if (this.options.enabled !== false && this.options.maxEntitySize && entityValue.length > this.options.maxEntitySize) {
+      throw new Error(
+        `Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`
+      );
     }
+    i--;
+    return [entityName, entityValue, i];
   }
-  return { notationName, publicIdentifier, systemIdentifier, index: --i };
-}
-function readIdentifierVal(xmlData, i, type) {
-  let identifierVal = "";
-  const startChar = xmlData[i];
-  if (startChar !== '"' && startChar !== "'") {
-    throw new Error(`Expected quoted string, found "${startChar}"`);
+  readNotationExp(xmlData, i) {
+    i = skipWhitespace(xmlData, i);
+    let notationName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+      notationName += xmlData[i];
+      i++;
+    }
+    !this.suppressValidationErr && validateEntityName(notationName);
+    i = skipWhitespace(xmlData, i);
+    const identifierType = xmlData.substring(i, i + 6).toUpperCase();
+    if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
+      throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+    }
+    i += identifierType.length;
+    i = skipWhitespace(xmlData, i);
+    let publicIdentifier = null;
+    let systemIdentifier = null;
+    if (identifierType === "PUBLIC") {
+      [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, "publicIdentifier");
+      i = skipWhitespace(xmlData, i);
+      if (xmlData[i] === '"' || xmlData[i] === "'") {
+        [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
+      }
+    } else if (identifierType === "SYSTEM") {
+      [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
+      if (!this.suppressValidationErr && !systemIdentifier) {
+        throw new Error("Missing mandatory system identifier for SYSTEM notation");
+      }
+    }
+    return { notationName, publicIdentifier, systemIdentifier, index: --i };
   }
-  i++;
-  while (i < xmlData.length && xmlData[i] !== startChar) {
-    identifierVal += xmlData[i];
+  readIdentifierVal(xmlData, i, type) {
+    let identifierVal = "";
+    const startChar = xmlData[i];
+    if (startChar !== '"' && startChar !== "'") {
+      throw new Error(`Expected quoted string, found "${startChar}"`);
+    }
     i++;
-  }
-  if (xmlData[i] !== startChar) {
-    throw new Error(`Unterminated ${type} value`);
-  }
-  i++;
-  return [i, identifierVal];
-}
-function readElementExp(xmlData, i) {
-  i = skipWhitespace(xmlData, i);
-  let elementName = "";
-  while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-    elementName += xmlData[i];
+    while (i < xmlData.length && xmlData[i] !== startChar) {
+      identifierVal += xmlData[i];
+      i++;
+    }
+    if (xmlData[i] !== startChar) {
+      throw new Error(`Unterminated ${type} value`);
+    }
     i++;
+    return [i, identifierVal];
   }
-  if (!validateEntityName(elementName)) {
-    throw new Error(`Invalid element name: "${elementName}"`);
+  readElementExp(xmlData, i) {
+    i = skipWhitespace(xmlData, i);
+    let elementName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+      elementName += xmlData[i];
+      i++;
+    }
+    if (!this.suppressValidationErr && !isName(elementName)) {
+      throw new Error(`Invalid element name: "${elementName}"`);
+    }
+    i = skipWhitespace(xmlData, i);
+    let contentModel = "";
+    if (xmlData[i] === "E" && hasSeq(xmlData, "MPTY", i)) i += 4;
+    else if (xmlData[i] === "A" && hasSeq(xmlData, "NY", i)) i += 2;
+    else if (xmlData[i] === "(") {
+      i++;
+      while (i < xmlData.length && xmlData[i] !== ")") {
+        contentModel += xmlData[i];
+        i++;
+      }
+      if (xmlData[i] !== ")") {
+        throw new Error("Unterminated content model");
+      }
+    } else if (!this.suppressValidationErr) {
+      throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+    }
+    return {
+      elementName,
+      contentModel: contentModel.trim(),
+      index: i
+    };
   }
-  i = skipWhitespace(xmlData, i);
-  let contentModel = "";
-  if (xmlData[i] === "E" && hasSeq(xmlData, "MPTY", i)) i += 4;
-  else if (xmlData[i] === "A" && hasSeq(xmlData, "NY", i)) i += 2;
-  else if (xmlData[i] === "(") {
-    i++;
-    while (i < xmlData.length && xmlData[i] !== ")") {
-      contentModel += xmlData[i];
+  readAttlistExp(xmlData, i) {
+    i = skipWhitespace(xmlData, i);
+    let elementName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+      elementName += xmlData[i];
+      i++;
+    }
+    validateEntityName(elementName);
+    i = skipWhitespace(xmlData, i);
+    let attributeName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+      attributeName += xmlData[i];
       i++;
     }
-    if (xmlData[i] !== ")") {
-      throw new Error("Unterminated content model");
+    if (!validateEntityName(attributeName)) {
+      throw new Error(`Invalid attribute name: "${attributeName}"`);
     }
-  } else {
-    throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+    i = skipWhitespace(xmlData, i);
+    let attributeType = "";
+    if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
+      attributeType = "NOTATION";
+      i += 8;
+      i = skipWhitespace(xmlData, i);
+      if (xmlData[i] !== "(") {
+        throw new Error(`Expected '(', found "${xmlData[i]}"`);
+      }
+      i++;
+      let allowedNotations = [];
+      while (i < xmlData.length && xmlData[i] !== ")") {
+        let notation = "";
+        while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
+          notation += xmlData[i];
+          i++;
+        }
+        notation = notation.trim();
+        if (!validateEntityName(notation)) {
+          throw new Error(`Invalid notation name: "${notation}"`);
+        }
+        allowedNotations.push(notation);
+        if (xmlData[i] === "|") {
+          i++;
+          i = skipWhitespace(xmlData, i);
+        }
+      }
+      if (xmlData[i] !== ")") {
+        throw new Error("Unterminated list of notations");
+      }
+      i++;
+      attributeType += " (" + allowedNotations.join("|") + ")";
+    } else {
+      while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+        attributeType += xmlData[i];
+        i++;
+      }
+      const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
+      if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
+        throw new Error(`Invalid attribute type: "${attributeType}"`);
+      }
+    }
+    i = skipWhitespace(xmlData, i);
+    let defaultValue = "";
+    if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
+      defaultValue = "#REQUIRED";
+      i += 8;
+    } else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
+      defaultValue = "#IMPLIED";
+      i += 7;
+    } else {
+      [i, defaultValue] = this.readIdentifierVal(xmlData, i, "ATTLIST");
+    }
+    return {
+      elementName,
+      attributeName,
+      attributeType,
+      defaultValue,
+      index: i
+    };
   }
-  return {
-    elementName,
-    contentModel: contentModel.trim(),
-    index: i
-  };
-}
+};
+var skipWhitespace = (data, index) => {
+  while (index < data.length && /\s/.test(data[index])) {
+    index++;
+  }
+  return index;
+};
 function hasSeq(data, seq, i) {
   for (let j = 0; j < seq.length; j++) {
     if (seq[j] !== data[i + j + 1]) return false;
@@ -7171,7 +7315,7 @@ function validateEntityName(name) {
     throw new Error(`Invalid entity name ${name}`);
 }
 
-// ../../.yarn/cache/strnum-npm-2.1.1-2f45f2aae3-d5fe6e4333.zip/node_modules/strnum/strnum.js
+// ../../.yarn/cache/strnum-npm-2.2.0-671febd32d-2969dbc844.zip/node_modules/strnum/strnum.js
 var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
 var numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
 var consider = {
@@ -7179,8 +7323,10 @@ var consider = {
   // oct: false,
   leadingZeros: true,
   decimalPoint: ".",
-  eNotation: true
-  //skipLike: /regex/
+  eNotation: true,
+  //skipLike: /regex/,
+  infinity: "original"
+  // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
 };
 function toNumber(str, options2 = {}) {
   options2 = Object.assign({}, consider, options2);
@@ -7190,7 +7336,9 @@ function toNumber(str, options2 = {}) {
   else if (str === "0") return 0;
   else if (options2.hex && hexRegex.test(trimmedStr)) {
     return parse_int(trimmedStr, 16);
-  } else if (trimmedStr.search(/.+[eE].+/) !== -1) {
+  } else if (!isFinite(trimmedStr)) {
+    return handleInfinity(str, Number(trimmedStr), options2);
+  } else if (trimmedStr.includes("e") || trimmedStr.includes("E")) {
     return resolveEnotation(str, trimmedStr, options2);
   } else {
     const match = numRegex.exec(trimmedStr);
@@ -7268,8 +7416,23 @@ function parse_int(numStr, base) {
   else if (window && window.parseInt) return window.parseInt(numStr, base);
   else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
 }
+function handleInfinity(str, num, options2) {
+  const isPositive = num === Infinity;
+  switch (options2.infinity.toLowerCase()) {
+    case "null":
+      return null;
+    case "infinity":
+      return num;
+    // Return Infinity or -Infinity
+    case "string":
+      return isPositive ? "Infinity" : "-Infinity";
+    case "original":
+    default:
+      return str;
+  }
+}
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
 function getIgnoreAttributesFn(ignoreAttributes) {
   if (typeof ignoreAttributes === "function") {
     return ignoreAttributes;
@@ -7289,7 +7452,7 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
 var OrderedObjParser = class {
   constructor(options2) {
     this.options = options2;
@@ -7317,8 +7480,8 @@ var OrderedObjParser = class {
       "copyright": { regex: /&(copy|#169);/g, val: "\xA9" },
       "reg": { regex: /&(reg|#174);/g, val: "\xAE" },
       "inr": { regex: /&(inr|#8377);/g, val: "\u20B9" },
-      "num_dec": { regex: /&#([0-9]{1,7});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 10)) },
-      "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) }
+      "num_dec": { regex: /&#([0-9]{1,7});/g, val: (_, str) => fromCodePoint(str, 10, "&#") },
+      "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => fromCodePoint(str, 16, "&#x") }
     };
     this.addExternalEntities = addExternalEntities;
     this.parseXml = parseXml;
@@ -7331,14 +7494,30 @@ var OrderedObjParser = class {
     this.saveTextToParentTag = saveTextToParentTag;
     this.addChild = addChild;
     this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
+    this.entityExpansionCount = 0;
+    this.currentExpandedLength = 0;
+    if (this.options.stopNodes && this.options.stopNodes.length > 0) {
+      this.stopNodesExact = /* @__PURE__ */ new Set();
+      this.stopNodesWildcard = /* @__PURE__ */ new Set();
+      for (let i = 0; i < this.options.stopNodes.length; i++) {
+        const stopNodeExp = this.options.stopNodes[i];
+        if (typeof stopNodeExp !== "string") continue;
+        if (stopNodeExp.startsWith("*.")) {
+          this.stopNodesWildcard.add(stopNodeExp.substring(2));
+        } else {
+          this.stopNodesExact.add(stopNodeExp);
+        }
+      }
+    }
   }
 };
 function addExternalEntities(externalEntities) {
   const entKeys = Object.keys(externalEntities);
   for (let i = 0; i < entKeys.length; i++) {
     const ent = entKeys[i];
+    const escaped = ent.replace(/[.\-+*:]/g, "\\.");
     this.lastEntities[ent] = {
-      regex: new RegExp("&" + ent + ";", "g"),
+      regex: new RegExp("&" + escaped + ";", "g"),
       val: externalEntities[ent]
     };
   }
@@ -7349,7 +7528,7 @@ function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode,
       val = val.trim();
     }
     if (val.length > 0) {
-      if (!escapeEntities) val = this.replaceEntitiesValue(val);
+      if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
       const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
       if (newval === null || newval === void 0) {
         return val;
@@ -7403,7 +7582,7 @@ function buildAttributesMap(attrStr, jPath, tagName) {
           if (this.options.trimValues) {
             oldVal = oldVal.trim();
           }
-          oldVal = this.replaceEntitiesValue(oldVal);
+          oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
           const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
           if (newVal === null || newVal === void 0) {
             attrs[aName] = oldVal;
@@ -7438,6 +7617,9 @@ var parseXml = function(xmlData) {
   let currentNode = xmlObj;
   let textData = "";
   let jPath = "";
+  this.entityExpansionCount = 0;
+  this.currentExpandedLength = 0;
+  const docTypeReader = new DocTypeReader(this.options.processEntities);
   for (let i = 0; i < xmlData.length; i++) {
     const ch = xmlData[i];
     if (ch === "<") {
@@ -7494,7 +7676,7 @@ var parseXml = function(xmlData) {
         }
         i = endIndex;
       } else if (xmlData.substr(i + 1, 2) === "!D") {
-        const result = readDocType(xmlData, i);
+        const result = docTypeReader.readDocType(xmlData, i);
         this.docTypeEntities = result.entities;
         i = result.i;
       } else if (xmlData.substr(i + 1, 2) === "![") {
@@ -7517,7 +7699,14 @@ var parseXml = function(xmlData) {
         let attrExpPresent = result.attrExpPresent;
         let closeIndex = result.closeIndex;
         if (this.options.transformTagName) {
-          tagName = this.options.transformTagName(tagName);
+          const newTagName = this.options.transformTagName(tagName);
+          if (tagExp === tagName) {
+            tagExp = newTagName;
+          }
+          tagName = newTagName;
+        }
+        if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName)) {
+          throw new Error(`Invalid tag name: ${tagName}`);
         }
         if (currentNode && textData) {
           if (currentNode.tagname !== "!xml") {
@@ -7533,7 +7722,7 @@ var parseXml = function(xmlData) {
           jPath += jPath ? "." + tagName : tagName;
         }
         const startIndex = i;
-        if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
+        if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, jPath, tagName)) {
           let tagContent = "";
           if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
             if (tagName[tagName.length - 1] === "/") {
@@ -7572,7 +7761,11 @@ var parseXml = function(xmlData) {
               tagExp = tagExp.substr(0, tagExp.length - 1);
             }
             if (this.options.transformTagName) {
-              tagName = this.options.transformTagName(tagName);
+              const newTagName = this.options.transformTagName(tagName);
+              if (tagExp === tagName) {
+                tagExp = newTagName;
+              }
+              tagName = newTagName;
             }
             const childNode = new XmlNode(tagName);
             if (tagName !== tagExp && attrExpPresent) {
@@ -7580,8 +7773,20 @@ var parseXml = function(xmlData) {
             }
             this.addChild(currentNode, childNode, jPath, startIndex);
             jPath = jPath.substr(0, jPath.lastIndexOf("."));
+          } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+            const childNode = new XmlNode(tagName);
+            if (tagName !== tagExp && attrExpPresent) {
+              childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+            }
+            this.addChild(currentNode, childNode, jPath, startIndex);
+            jPath = jPath.substr(0, jPath.lastIndexOf("."));
+            i = result.closeIndex;
+            continue;
           } else {
             const childNode = new XmlNode(tagName);
+            if (this.tagsNodeStack.length > this.options.maxNestedTags) {
+              throw new Error("Maximum nested tags exceeded");
+            }
             this.tagsNodeStack.push(currentNode);
             if (tagName !== tagExp && attrExpPresent) {
               childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
@@ -7610,49 +7815,81 @@ function addChild(currentNode, childNode, jPath, startIndex) {
     currentNode.addChild(childNode, startIndex);
   }
 }
-var replaceEntitiesValue = function(val) {
-  if (this.options.processEntities) {
-    for (let entityName in this.docTypeEntities) {
-      const entity = this.docTypeEntities[entityName];
-      val = val.replace(entity.regx, entity.val);
+var replaceEntitiesValue = function(val, tagName, jPath) {
+  if (val.indexOf("&") === -1) {
+    return val;
+  }
+  const entityConfig = this.options.processEntities;
+  if (!entityConfig.enabled) {
+    return val;
+  }
+  if (entityConfig.allowedTags) {
+    if (!entityConfig.allowedTags.includes(tagName)) {
+      return val;
     }
-    for (let entityName in this.lastEntities) {
-      const entity = this.lastEntities[entityName];
-      val = val.replace(entity.regex, entity.val);
+  }
+  if (entityConfig.tagFilter) {
+    if (!entityConfig.tagFilter(tagName, jPath)) {
+      return val;
     }
-    if (this.options.htmlEntities) {
-      for (let entityName in this.htmlEntities) {
-        const entity = this.htmlEntities[entityName];
-        val = val.replace(entity.regex, entity.val);
+  }
+  for (let entityName in this.docTypeEntities) {
+    const entity = this.docTypeEntities[entityName];
+    const matches = val.match(entity.regx);
+    if (matches) {
+      this.entityExpansionCount += matches.length;
+      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+        throw new Error(
+          `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+        );
       }
+      const lengthBefore = val.length;
+      val = val.replace(entity.regx, entity.val);
+      if (entityConfig.maxExpandedLength) {
+        this.currentExpandedLength += val.length - lengthBefore;
+        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {
+          throw new Error(
+            `Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`
+          );
+        }
+      }
+    }
+  }
+  if (val.indexOf("&") === -1) return val;
+  for (let entityName in this.lastEntities) {
+    const entity = this.lastEntities[entityName];
+    val = val.replace(entity.regex, entity.val);
+  }
+  if (val.indexOf("&") === -1) return val;
+  if (this.options.htmlEntities) {
+    for (let entityName in this.htmlEntities) {
+      const entity = this.htmlEntities[entityName];
+      val = val.replace(entity.regex, entity.val);
     }
-    val = val.replace(this.ampEntity.regex, this.ampEntity.val);
   }
+  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
   return val;
 };
-function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
+function saveTextToParentTag(textData, parentNode, jPath, isLeafNode) {
   if (textData) {
-    if (isLeafNode === void 0) isLeafNode = currentNode.child.length === 0;
+    if (isLeafNode === void 0) isLeafNode = parentNode.child.length === 0;
     textData = this.parseTextData(
       textData,
-      currentNode.tagname,
+      parentNode.tagname,
       jPath,
       false,
-      currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false,
+      parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false,
       isLeafNode
     );
     if (textData !== void 0 && textData !== "")
-      currentNode.add(this.options.textNodeName, textData);
+      parentNode.add(this.options.textNodeName, textData);
     textData = "";
   }
   return textData;
 }
-function isItStopNode(stopNodes, jPath, currentTagName) {
-  const allNodesExp = "*." + currentTagName;
-  for (const stopNodePath in stopNodes) {
-    const stopNodeExp = stopNodes[stopNodePath];
-    if (allNodesExp === stopNodeExp || jPath === stopNodeExp) return true;
-  }
+function isItStopNode(stopNodesExact, stopNodesWildcard, jPath, currentTagName) {
+  if (stopNodesWildcard && stopNodesWildcard.has(currentTagName)) return true;
+  if (stopNodesExact && stopNodesExact.has(jPath)) return true;
   return false;
 }
 function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
@@ -7774,8 +8011,16 @@ function parseValue(val, shouldParse, options2) {
     }
   }
 }
+function fromCodePoint(str, base, prefix) {
+  const codePoint = Number.parseInt(str, base);
+  if (codePoint >= 0 && codePoint <= 1114111) {
+    return String.fromCodePoint(codePoint);
+  } else {
+    return prefix + str + ";";
+  }
+}
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/node2json.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/node2json.js
 var METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
 function prettify(node, options2) {
   return compress(node, options2);
@@ -7797,9 +8042,6 @@ function compress(arr, options2, jPath) {
     } else if (tagObj[property]) {
       let val = compress(tagObj[property], options2, newJpath);
       const isLeaf = isLeafTag(val, options2);
-      if (tagObj[METADATA_SYMBOL2] !== void 0) {
-        val[METADATA_SYMBOL2] = tagObj[METADATA_SYMBOL2];
-      }
       if (tagObj[":@"]) {
         assignAttributes(val, tagObj[":@"], newJpath, options2);
       } else if (Object.keys(val).length === 1 && val[options2.textNodeName] !== void 0 && !options2.alwaysCreateTextNode) {
@@ -7808,7 +8050,10 @@ function compress(arr, options2, jPath) {
         if (options2.alwaysCreateTextNode) val[options2.textNodeName] = "";
         else val = "";
       }
-      if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
+      if (tagObj[METADATA_SYMBOL2] !== void 0 && typeof val === "object" && val !== null) {
+        val[METADATA_SYMBOL2] = tagObj[METADATA_SYMBOL2];
+      }
+      if (compressedObj[property] !== void 0 && Object.prototype.hasOwnProperty.call(compressedObj, property)) {
         if (!Array.isArray(compressedObj[property])) {
           compressedObj[property] = [compressedObj[property]];
         }
@@ -7860,7 +8105,7 @@ function isLeafTag(obj, options2) {
   return false;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.2.5-4fd49da1b5-305017cff6.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.4.1-48bbd2c631-2b40067c3a.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
 var XMLParser = class {
   constructor(options2) {
     this.externalEntities = {};
@@ -7868,14 +8113,13 @@ var XMLParser = class {
   }
   /**
    * Parse XML dats to JS object 
-   * @param {string|Buffer} xmlData 
+   * @param {string|Uint8Array} xmlData 
    * @param {boolean|Object} validationOption 
    */
   parse(xmlData, validationOption) {
-    if (typeof xmlData === "string") {
-    } else if (xmlData.toString) {
+    if (typeof xmlData !== "string" && xmlData.toString) {
       xmlData = xmlData.toString();
-    } else {
+    } else if (typeof xmlData !== "string") {
       throw new Error("XML data is accepted in String or Bytes[] form.");
     }
     if (validationOption) {
@@ -19112,7 +19356,7 @@ export const ${node.name}: ${node.name}Namespace & {
       def.push(`
 constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: any[]);
 `);
-    if (!girClass.__ts__indexSignature || girClass.__ts__indexSignature.includes("[key: string]: any")) {
+    if (girClass instanceof IntrospectedClass && (!girClass.__ts__indexSignature || girClass.__ts__indexSignature.includes("[key: string]: any"))) {
       def.push("_init(...args: any[]): void;\n");
     }
     def.push(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/cli",
-  "version": "4.0.0-beta.37",
+  "version": "4.0.0-beta.39",
   "description": "TypeScript type definition generator for GObject introspection GIR files",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -18,8 +18,7 @@
     "start:prod": "node bin/ts-for-gir",
     "build": "node --experimental-specifier-resolution=node --experimental-strip-types --experimental-transform-types --no-warnings esbuild.ts && chmod +x bin/ts-for-gir-dev && chmod +x bin/ts-for-gir",
     "check:types": "tsc --noEmit",
-    "check:deps": "dpdm -T src/index.ts",
-    "check": "yarn check:types && yarn check:deps"
+    "check": "yarn check:types"
   },
   "repository": {
     "type": "git",
@@ -53,30 +52,29 @@
     ".": "./src/index.ts"
   },
   "devDependencies": {
-    "@gi.ts/parser": "^4.0.0-beta.37",
-    "@ts-for-gir/generator-base": "^4.0.0-beta.37",
-    "@ts-for-gir/generator-html-doc": "^4.0.0-beta.37",
-    "@ts-for-gir/generator-json": "^4.0.0-beta.37",
-    "@ts-for-gir/generator-typescript": "^4.0.0-beta.37",
-    "@ts-for-gir/lib": "^4.0.0-beta.37",
-    "@ts-for-gir/reporter": "^4.0.0-beta.37",
+    "@gi.ts/parser": "^4.0.0-beta.39",
+    "@ts-for-gir/generator-base": "^4.0.0-beta.39",
+    "@ts-for-gir/generator-html-doc": "^4.0.0-beta.39",
+    "@ts-for-gir/generator-json": "^4.0.0-beta.39",
+    "@ts-for-gir/generator-typescript": "^4.0.0-beta.39",
+    "@ts-for-gir/lib": "^4.0.0-beta.39",
+    "@ts-for-gir/reporter": "^4.0.0-beta.39",
     "@types/ejs": "^3.1.5",
     "@types/inquirer": "^9.0.9",
-    "@types/node": "^24.5.2",
-    "@types/yargs": "^17.0.33",
-    "dpdm": "^3.14.0",
-    "esbuild": "^0.25.10",
-    "typescript": "^5.9.2"
+    "@types/node": "^24.11.0",
+    "@types/yargs": "^17.0.35",
+    "esbuild": "^0.27.3",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.8.6",
-    "@ts-for-gir/templates": "^4.0.0-beta.37",
+    "@inquirer/prompts": "^8.3.0",
+    "@ts-for-gir/templates": "^4.0.0-beta.39",
     "colorette": "^2.0.20",
     "cosmiconfig": "^9.0.0",
-    "ejs": "^3.1.10",
-    "glob": "^11.0.3",
-    "inquirer": "^12.9.6",
-    "prettier": "^3.6.2",
+    "ejs": "^4.0.1",
+    "glob": "^13.0.6",
+    "inquirer": "^13.3.0",
+    "prettier": "^3.8.1",
     "yargs": "^18.0.0"
   }
 }

package/src/types/command-args.ts

@@ -2,109 +2,109 @@
  * Base interface for all command arguments extending ConfigFlags
  */
 export interface BaseCommandArgs {
-    /** GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules */
-    modules: string[]
-    /** GIR directories */
-    girDirectories: string[]
-    /** Root directory of your project */
-    root: string
-    /** Modules that should be ignored */
-    ignore: string[]
-    /** Specify a custom name for the configuration file */
-    configName: string
-    /** Switch on/off the verbose mode */
-    verbose: boolean
+	/** GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules */
+	modules: string[];
+	/** GIR directories */
+	girDirectories: string[];
+	/** Root directory of your project */
+	root: string;
+	/** Modules that should be ignored */
+	ignore: string[];
+	/** Specify a custom name for the configuration file */
+	configName: string;
+	/** Switch on/off the verbose mode */
+	verbose: boolean;
 }
 
 /**
  * Arguments for the generate command
  */
 export interface GenerateCommandArgs extends BaseCommandArgs {
-    /** Directory to output to */
-    outdir: string | null
-    /** Skip prompts for library version selection when multiple versions are detected */
-    ignoreVersionConflicts: boolean
-    /** Print the output to console and create no files */
-    print: boolean
-    /** Do not export all symbols for each module as a namespace */
-    noNamespace: boolean
-    /** Do not generate documentation comments */
-    noComments: boolean
-    /** Generate promisified functions for async/finish calls */
-    promisify: boolean
-    /** Scope of the generated NPM packages */
-    npmScope: string
-    /** Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM */
-    workspace: boolean
-    /** Only use the version prefix for the ambient module exports */
-    onlyVersionPrefix: boolean
-    /** Do not prettify the generated types */
-    noPrettyPrint: boolean
-    /** Disable GLib.Variant class with string parsing */
-    noAdvancedVariants: boolean
-    /** Generate the typescript types with package.json support */
-    package: boolean
-    /** Enable generation problem reporter and create a detailed report file */
-    reporter: boolean
-    /** Output file path for the reporter */
-    reporterOutput: string
+	/** Directory to output to */
+	outdir: string | null;
+	/** Skip prompts for library version selection when multiple versions are detected */
+	ignoreVersionConflicts: boolean;
+	/** Print the output to console and create no files */
+	print: boolean;
+	/** Do not export all symbols for each module as a namespace */
+	noNamespace: boolean;
+	/** Do not generate documentation comments */
+	noComments: boolean;
+	/** Generate promisified functions for async/finish calls */
+	promisify: boolean;
+	/** Scope of the generated NPM packages */
+	npmScope: string;
+	/** Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM */
+	workspace: boolean;
+	/** Only use the version prefix for the ambient module exports */
+	onlyVersionPrefix: boolean;
+	/** Do not prettify the generated types */
+	noPrettyPrint: boolean;
+	/** Disable GLib.Variant class with string parsing */
+	noAdvancedVariants: boolean;
+	/** Generate the typescript types with package.json support */
+	package: boolean;
+	/** Enable generation problem reporter and create a detailed report file */
+	reporter: boolean;
+	/** Output file path for the reporter */
+	reporterOutput: string;
 }
 
 /**
  * Arguments for the list command
  */
 export interface ListCommandArgs extends BaseCommandArgs {
-    // List command only uses base arguments
+	// List command only uses base arguments
 }
 
 /**
  * Arguments for the copy command
  */
 export interface CopyCommandArgs extends BaseCommandArgs {
-    /** Directory to output to */
-    outdir: string | null
+	/** Directory to output to */
+	outdir: string | null;
 }
 
 /**
  * Arguments for the doc command
  */
 export interface DocCommandArgs extends BaseCommandArgs {
-    /** Directory to output to */
-    outdir: string | null
-    /** Skip prompts for library version selection when multiple versions are detected */
-    ignoreVersionConflicts: boolean
+	/** Directory to output to */
+	outdir: string | null;
+	/** Skip prompts for library version selection when multiple versions are detected */
+	ignoreVersionConflicts: boolean;
 }
 
 /**
  * Arguments for the analyze command
  */
 export interface AnalyzeCommandArgs {
-    /** Path to the report file to analyze */
-    reportFile: string
-    /** Filter by problem severity (debug, info, warning, error, critical) */
-    severity?: string[]
-    /** Filter by problem category */
-    category?: string[]
-    /** Filter by namespace/module */
-    namespace?: string[]
-    /** Filter by specific type name */
-    type?: string[]
-    /** Show top N most problematic items */
-    top?: number
-    /** Export filtered results to file */
-    export?: string
-    /** Output format (json, csv, table) */
-    format?: string
-    /** Show detailed problem information */
-    detailed?: boolean
-    /** Show summary statistics only */
-    summary?: boolean
-    /** Search for problems containing specific text */
-    search?: string
-    /** Show problems from a specific time range (ISO date) */
-    since?: string
-    /** Show problems until a specific time (ISO date) */
-    until?: string
-    /** Switch on/off the verbose mode */
-    verbose?: boolean
-}
+	/** Path to the report file to analyze */
+	reportFile: string;
+	/** Filter by problem severity (debug, info, warning, error, critical) */
+	severity?: string[];
+	/** Filter by problem category */
+	category?: string[];
+	/** Filter by namespace/module */
+	namespace?: string[];
+	/** Filter by specific type name */
+	type?: string[];
+	/** Show top N most problematic items */
+	top?: number;
+	/** Export filtered results to file */
+	export?: string;
+	/** Output format (json, csv, table) */
+	format?: string;
+	/** Show detailed problem information */
+	detailed?: boolean;
+	/** Show summary statistics only */
+	summary?: boolean;
+	/** Search for problems containing specific text */
+	search?: string;
+	/** Show problems from a specific time range (ISO date) */
+	since?: string;
+	/** Show problems until a specific time (ISO date) */
+	until?: string;
+	/** Switch on/off the verbose mode */
+	verbose?: boolean;
+}

package/src/types/command-definition.ts

@@ -1,15 +1,17 @@
+import type { ConfigFlags } from "@ts-for-gir/lib";
+import type { BuilderCallback } from "yargs";
 /**
  * Base interface for command definition structure
  */
 export interface CommandDefinition<TArgs> {
-    /** Command name and parameters */
-    command: string
-    /** Command description */
-    description: string
-    /** Builder function for yargs configuration */
-    builder: (yargs: any) => any
-    /** Handler function for command execution */
-    handler: (args: TArgs) => Promise<void>
-    /** Example usage array */
-    examples: ReadonlyArray<[string, string?]>
-}
+	/** Command name and parameters */
+	command: string;
+	/** Command description */
+	description: string;
+	/** Builder function for yargs configuration */
+	builder: BuilderCallback<TArgs, ConfigFlags>;
+	/** Handler function for command execution */
+	handler: (args: ConfigFlags) => Promise<void>;
+	/** Example usage array */
+	examples: ReadonlyArray<[string, string?]>;
+}

package/src/types/commands.ts

@@ -1,35 +1,30 @@
 /**
  * Type definitions for command structure and exports
  */
-import type { 
-    GenerateCommandArgs, 
-    ListCommandArgs, 
-    CopyCommandArgs, 
-    DocCommandArgs
-} from './command-args.ts'
-import type { CommandDefinition } from './command-definition.ts'
+import type { CopyCommandArgs, DocCommandArgs, GenerateCommandArgs, ListCommandArgs } from "./command-args.ts";
+import type { CommandDefinition } from "./command-definition.ts";
 
 /**
  * Generate command definition type
  */
-export type GenerateCommand = CommandDefinition<GenerateCommandArgs>
+export type GenerateCommand = CommandDefinition<GenerateCommandArgs>;
 
 /**
  * List command definition type
  */
-export type ListCommand = CommandDefinition<ListCommandArgs>
+export type ListCommand = CommandDefinition<ListCommandArgs>;
 
 /**
  * Copy command definition type
  */
-export type CopyCommand = CommandDefinition<CopyCommandArgs>
+export type CopyCommand = CommandDefinition<CopyCommandArgs>;
 
 /**
  * Doc command definition type
  */
-export type DocCommand = CommandDefinition<DocCommandArgs>
+export type DocCommand = CommandDefinition<DocCommandArgs>;
 
 /**
  * Union type for all command types
  */
-export type AnyCommand = GenerateCommand | ListCommand | CopyCommand | DocCommand
+export type AnyCommand = GenerateCommand | ListCommand | CopyCommand | DocCommand;

package/src/types/index.ts

@@ -3,13 +3,13 @@
  */
 
 // Command argument interfaces
-export * from './command-args.ts'
+export * from "./command-args.ts";
 
 // Command definition interfaces
-export * from './command-definition.ts'
+export * from "./command-definition.ts";
 
 // Command type definitions
-export * from './commands.ts'
+export * from "./commands.ts";
 
 // Report analysis types
-export * from './report-types.ts'
+export * from "./report-types.ts";

package/src/types/report-types.ts

@@ -31,4 +31,4 @@ export interface ReportData {
 	metadata: ReportMetadata;
 	statistics: ReportStatistics;
 	problems: ProblemEntry[];
-} 
+}