@ts-for-gir/cli 4.0.0-rc.3 → 4.0.0-rc.5

package/bin/ts-for-gir

@@ -3346,7 +3346,7 @@ var require_lodash = __commonJS({
           }
           return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
         });
-        function join16(array, separator) {
+        function join17(array, separator) {
           return array == null ? "" : nativeJoin.call(array, separator);
         }
         function last(array) {
@@ -4304,7 +4304,7 @@ var require_lodash = __commonJS({
           copyObject(source, keys(source), object, customizer);
         });
         var at = flatRest(baseAt);
-        function create(prototype, properties) {
+        function create2(prototype, properties) {
           var result2 = baseCreate(prototype);
           return properties == null ? result2 : baseAssign(result2, properties);
         }
@@ -5056,7 +5056,7 @@ var require_lodash = __commonJS({
         lodash2.conforms = conforms;
         lodash2.constant = constant;
         lodash2.countBy = countBy;
-        lodash2.create = create;
+        lodash2.create = create2;
         lodash2.curry = curry;
         lodash2.curryRight = curryRight;
         lodash2.debounce = debounce;
@@ -5270,7 +5270,7 @@ var require_lodash = __commonJS({
         lodash2.isUndefined = isUndefined;
         lodash2.isWeakMap = isWeakMap;
         lodash2.isWeakSet = isWeakSet;
-        lodash2.join = join16;
+        lodash2.join = join17;
         lodash2.kebabCase = kebabCase;
         lodash2.last = last;
         lodash2.lastIndexOf = lastIndexOf;
@@ -5532,17 +5532,17 @@ var require_lunr = __commonJS({
   "../../.yarn/cache/lunr-npm-2.3.9-fa3aa9c2d6-f2f6db34c0.zip/node_modules/lunr/lunr.js"(exports2, module) {
     (function() {
       var lunr2 = function(config) {
-        var builder7 = new lunr2.Builder();
-        builder7.pipeline.add(
+        var builder8 = new lunr2.Builder();
+        builder8.pipeline.add(
           lunr2.trimmer,
           lunr2.stopWordFilter,
           lunr2.stemmer
         );
-        builder7.searchPipeline.add(
+        builder8.searchPipeline.add(
           lunr2.stemmer
         );
-        config.call(builder7, builder7);
-        return builder7.build();
+        config.call(builder8, builder8);
+        return builder8.build();
       };
       lunr2.version = "2.3.9";
       lunr2.utils = {};
@@ -6218,12 +6218,12 @@ var require_lunr = __commonJS({
       };
       lunr2.TokenSet._nextId = 1;
       lunr2.TokenSet.fromArray = function(arr) {
-        var builder7 = new lunr2.TokenSet.Builder();
+        var builder8 = new lunr2.TokenSet.Builder();
         for (var i = 0, len = arr.length; i < len; i++) {
-          builder7.insert(arr[i]);
+          builder8.insert(arr[i]);
         }
-        builder7.finish();
-        return builder7.root;
+        builder8.finish();
+        return builder8.root;
       };
       lunr2.TokenSet.fromClause = function(clause) {
         if ("editDistance" in clause) {
@@ -7268,7 +7268,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 function getPackageVersion() {
   if (true) {
-    return "4.0.0-rc.3";
+    return "4.0.0-rc.5";
   }
   const currentModulePath = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentModulePath);
@@ -7879,10 +7879,10 @@ ${"=".repeat(50)}`);
       if (statistics.typeStatistics.commonTypeConflicts.length > 0) {
         console.log(`
 \u2694\uFE0F  Type Conflicts:`);
-        statistics.typeStatistics.commonTypeConflicts.forEach(({ conflictType, count, examples: examples7 }) => {
+        statistics.typeStatistics.commonTypeConflicts.forEach(({ conflictType, count, examples: examples8 }) => {
           console.log(`  ${yellow(conflictType)}: ${count} conflicts`);
-          if (examples7.length > 0) {
-            console.log(`    \u2514\u2500 Examples: ${gray(examples7.join(", "))}`);
+          if (examples8.length > 0) {
+            console.log(`    \u2514\u2500 Examples: ${gray(examples8.join(", "))}`);
           }
         });
       }
@@ -8165,7 +8165,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 var NEW_LINE_REG_EXP = /[\n\r]+/g;
 function getPackageVersion2() {
   if (true) {
-    return "4.0.0-rc.3";
+    return "4.0.0-rc.5";
   }
   const currentModulePath = fileURLToPath2(import.meta.url);
   const currentDir = dirname2(currentModulePath);
@@ -8197,7 +8197,7 @@ __export(parser_exports, {
   parseGir: () => parseGir
 });
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/util.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.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 + "]*";
@@ -8238,7 +8238,7 @@ var DANGEROUS_PROPERTY_NAMES = [
 ];
 var criticalProperties = ["__proto__", "constructor", "prototype"];
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/validator.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/validator.js
 var defaultOptions = {
   allowBooleanAttributes: false,
   //A tag can have attributes without any value
@@ -8544,7 +8544,1476 @@ function getPositionFromMatch(match) {
   return match.startIndex + match[1].length;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+// ../../.yarn/cache/@nodable-entities-npm-2.1.0-6eb9f06ac0-355c55e82a.zip/node_modules/@nodable/entities/src/entities.js
+var BASIC_LATIN = {
+  amp: "&",
+  AMP: "&",
+  lt: "<",
+  LT: "<",
+  gt: ">",
+  GT: ">",
+  quot: '"',
+  QUOT: '"',
+  apos: "'",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  lsquor: "\u201A",
+  rsquor: "\u2019",
+  ldquor: "\u201E",
+  bdquo: "\u201E",
+  comma: ",",
+  period: ".",
+  colon: ":",
+  semi: ";",
+  excl: "!",
+  quest: "?",
+  num: "#",
+  dollar: "$",
+  percent: "%",
+  amp: "&",
+  ast: "*",
+  commat: "@",
+  lowbar: "_",
+  verbar: "|",
+  vert: "|",
+  sol: "/",
+  bsol: "\\",
+  lbrace: "{",
+  rbrace: "}",
+  lbrack: "[",
+  rbrack: "]",
+  lpar: "(",
+  rpar: ")",
+  nbsp: "\xA0",
+  iexcl: "\xA1",
+  cent: "\xA2",
+  pound: "\xA3",
+  curren: "\xA4",
+  yen: "\xA5",
+  brvbar: "\xA6",
+  sect: "\xA7",
+  uml: "\xA8",
+  copy: "\xA9",
+  COPY: "\xA9",
+  ordf: "\xAA",
+  laquo: "\xAB",
+  not: "\xAC",
+  shy: "\xAD",
+  reg: "\xAE",
+  REG: "\xAE",
+  macr: "\xAF",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  acute: "\xB4",
+  micro: "\xB5",
+  para: "\xB6",
+  middot: "\xB7",
+  cedil: "\xB8",
+  sup1: "\xB9",
+  ordm: "\xBA",
+  raquo: "\xBB",
+  frac14: "\xBC",
+  frac12: "\xBD",
+  half: "\xBD",
+  frac34: "\xBE",
+  iquest: "\xBF",
+  times: "\xD7",
+  div: "\xF7",
+  divide: "\xF7"
+};
+var LATIN_ACCENTS = {
+  Agrave: "\xC0",
+  agrave: "\xE0",
+  Aacute: "\xC1",
+  aacute: "\xE1",
+  Acirc: "\xC2",
+  acirc: "\xE2",
+  Atilde: "\xC3",
+  atilde: "\xE3",
+  Auml: "\xC4",
+  auml: "\xE4",
+  Aring: "\xC5",
+  aring: "\xE5",
+  AElig: "\xC6",
+  aelig: "\xE6",
+  Ccedil: "\xC7",
+  ccedil: "\xE7",
+  Egrave: "\xC8",
+  egrave: "\xE8",
+  Eacute: "\xC9",
+  eacute: "\xE9",
+  Ecirc: "\xCA",
+  ecirc: "\xEA",
+  Euml: "\xCB",
+  euml: "\xEB",
+  Igrave: "\xCC",
+  igrave: "\xEC",
+  Iacute: "\xCD",
+  iacute: "\xED",
+  Icirc: "\xCE",
+  icirc: "\xEE",
+  Iuml: "\xCF",
+  iuml: "\xEF",
+  ETH: "\xD0",
+  eth: "\xF0",
+  Ntilde: "\xD1",
+  ntilde: "\xF1",
+  Ograve: "\xD2",
+  ograve: "\xF2",
+  Oacute: "\xD3",
+  oacute: "\xF3",
+  Ocirc: "\xD4",
+  ocirc: "\xF4",
+  Otilde: "\xD5",
+  otilde: "\xF5",
+  Ouml: "\xD6",
+  ouml: "\xF6",
+  Oslash: "\xD8",
+  oslash: "\xF8",
+  Ugrave: "\xD9",
+  ugrave: "\xF9",
+  Uacute: "\xDA",
+  uacute: "\xFA",
+  Ucirc: "\xDB",
+  ucirc: "\xFB",
+  Uuml: "\xDC",
+  uuml: "\xFC",
+  Yacute: "\xDD",
+  yacute: "\xFD",
+  THORN: "\xDE",
+  thorn: "\xFE",
+  szlig: "\xDF",
+  yuml: "\xFF",
+  Yuml: "\u0178"
+};
+var LATIN_EXTENDED = {
+  Amacr: "\u0100",
+  amacr: "\u0101",
+  Abreve: "\u0102",
+  abreve: "\u0103",
+  Aogon: "\u0104",
+  aogon: "\u0105",
+  Cacute: "\u0106",
+  cacute: "\u0107",
+  Ccirc: "\u0108",
+  ccirc: "\u0109",
+  Cdot: "\u010A",
+  cdot: "\u010B",
+  Ccaron: "\u010C",
+  ccaron: "\u010D",
+  Dcaron: "\u010E",
+  dcaron: "\u010F",
+  Dstrok: "\u0110",
+  dstrok: "\u0111",
+  Emacr: "\u0112",
+  emacr: "\u0113",
+  Ecaron: "\u011A",
+  ecaron: "\u011B",
+  Edot: "\u0116",
+  edot: "\u0117",
+  Eogon: "\u0118",
+  eogon: "\u0119",
+  Gcirc: "\u011C",
+  gcirc: "\u011D",
+  Gbreve: "\u011E",
+  gbreve: "\u011F",
+  Gdot: "\u0120",
+  gdot: "\u0121",
+  Gcedil: "\u0122",
+  Hcirc: "\u0124",
+  hcirc: "\u0125",
+  Hstrok: "\u0126",
+  hstrok: "\u0127",
+  Itilde: "\u0128",
+  itilde: "\u0129",
+  Imacr: "\u012A",
+  imacr: "\u012B",
+  Iogon: "\u012E",
+  iogon: "\u012F",
+  Idot: "\u0130",
+  IJlig: "\u0132",
+  ijlig: "\u0133",
+  Jcirc: "\u0134",
+  jcirc: "\u0135",
+  Kcedil: "\u0136",
+  kcedil: "\u0137",
+  kgreen: "\u0138",
+  Lacute: "\u0139",
+  lacute: "\u013A",
+  Lcedil: "\u013B",
+  lcedil: "\u013C",
+  Lcaron: "\u013D",
+  lcaron: "\u013E",
+  Lmidot: "\u013F",
+  lmidot: "\u0140",
+  Lstrok: "\u0141",
+  lstrok: "\u0142",
+  Nacute: "\u0143",
+  nacute: "\u0144",
+  Ncaron: "\u0147",
+  ncaron: "\u0148",
+  Ncedil: "\u0145",
+  ncedil: "\u0146",
+  ENG: "\u014A",
+  eng: "\u014B",
+  Omacr: "\u014C",
+  omacr: "\u014D",
+  Odblac: "\u0150",
+  odblac: "\u0151",
+  OElig: "\u0152",
+  oelig: "\u0153",
+  Racute: "\u0154",
+  racute: "\u0155",
+  Rcaron: "\u0158",
+  rcaron: "\u0159",
+  Rcedil: "\u0156",
+  rcedil: "\u0157",
+  Sacute: "\u015A",
+  sacute: "\u015B",
+  Scirc: "\u015C",
+  scirc: "\u015D",
+  Scedil: "\u015E",
+  scedil: "\u015F",
+  Scaron: "\u0160",
+  scaron: "\u0161",
+  Tcedil: "\u0162",
+  tcedil: "\u0163",
+  Tcaron: "\u0164",
+  tcaron: "\u0165",
+  Tstrok: "\u0166",
+  tstrok: "\u0167",
+  Utilde: "\u0168",
+  utilde: "\u0169",
+  Umacr: "\u016A",
+  umacr: "\u016B",
+  Ubreve: "\u016C",
+  ubreve: "\u016D",
+  Uring: "\u016E",
+  uring: "\u016F",
+  Udblac: "\u0170",
+  udblac: "\u0171",
+  Uogon: "\u0172",
+  uogon: "\u0173",
+  Wcirc: "\u0174",
+  wcirc: "\u0175",
+  Ycirc: "\u0176",
+  ycirc: "\u0177",
+  Zacute: "\u0179",
+  zacute: "\u017A",
+  Zdot: "\u017B",
+  zdot: "\u017C",
+  Zcaron: "\u017D",
+  zcaron: "\u017E"
+};
+var GREEK = {
+  Alpha: "\u0391",
+  alpha: "\u03B1",
+  Beta: "\u0392",
+  beta: "\u03B2",
+  Gamma: "\u0393",
+  gamma: "\u03B3",
+  Delta: "\u0394",
+  delta: "\u03B4",
+  Epsilon: "\u0395",
+  epsilon: "\u03B5",
+  epsiv: "\u03F5",
+  varepsilon: "\u03F5",
+  Zeta: "\u0396",
+  zeta: "\u03B6",
+  Eta: "\u0397",
+  eta: "\u03B7",
+  Theta: "\u0398",
+  theta: "\u03B8",
+  thetasym: "\u03D1",
+  vartheta: "\u03D1",
+  Iota: "\u0399",
+  iota: "\u03B9",
+  Kappa: "\u039A",
+  kappa: "\u03BA",
+  kappav: "\u03F0",
+  varkappa: "\u03F0",
+  Lambda: "\u039B",
+  lambda: "\u03BB",
+  Mu: "\u039C",
+  mu: "\u03BC",
+  Nu: "\u039D",
+  nu: "\u03BD",
+  Xi: "\u039E",
+  xi: "\u03BE",
+  Omicron: "\u039F",
+  omicron: "\u03BF",
+  Pi: "\u03A0",
+  pi: "\u03C0",
+  piv: "\u03D6",
+  varpi: "\u03D6",
+  Rho: "\u03A1",
+  rho: "\u03C1",
+  rhov: "\u03F1",
+  varrho: "\u03F1",
+  Sigma: "\u03A3",
+  sigma: "\u03C3",
+  sigmaf: "\u03C2",
+  sigmav: "\u03C2",
+  varsigma: "\u03C2",
+  Tau: "\u03A4",
+  tau: "\u03C4",
+  Upsilon: "\u03A5",
+  upsilon: "\u03C5",
+  upsi: "\u03C5",
+  Upsi: "\u03D2",
+  upsih: "\u03D2",
+  Phi: "\u03A6",
+  phi: "\u03C6",
+  phiv: "\u03D5",
+  varphi: "\u03D5",
+  Chi: "\u03A7",
+  chi: "\u03C7",
+  Psi: "\u03A8",
+  psi: "\u03C8",
+  Omega: "\u03A9",
+  omega: "\u03C9",
+  ohm: "\u03A9",
+  Gammad: "\u03DC",
+  gammad: "\u03DD",
+  digamma: "\u03DD"
+};
+var CYRILLIC = {
+  Afr: "\u{1D504}",
+  afr: "\u{1D51E}",
+  Acy: "\u0410",
+  acy: "\u0430",
+  Bcy: "\u0411",
+  bcy: "\u0431",
+  Vcy: "\u0412",
+  vcy: "\u0432",
+  Gcy: "\u0413",
+  gcy: "\u0433",
+  Dcy: "\u0414",
+  dcy: "\u0434",
+  IEcy: "\u0415",
+  iecy: "\u0435",
+  IOcy: "\u0401",
+  iocy: "\u0451",
+  ZHcy: "\u0416",
+  zhcy: "\u0436",
+  Zcy: "\u0417",
+  zcy: "\u0437",
+  Icy: "\u0418",
+  icy: "\u0438",
+  Jcy: "\u0419",
+  jcy: "\u0439",
+  Kcy: "\u041A",
+  kcy: "\u043A",
+  Lcy: "\u041B",
+  lcy: "\u043B",
+  Mcy: "\u041C",
+  mcy: "\u043C",
+  Ncy: "\u041D",
+  ncy: "\u043D",
+  Ocy: "\u041E",
+  ocy: "\u043E",
+  Pcy: "\u041F",
+  pcy: "\u043F",
+  Rcy: "\u0420",
+  rcy: "\u0440",
+  Scy: "\u0421",
+  scy: "\u0441",
+  Tcy: "\u0422",
+  tcy: "\u0442",
+  Ucy: "\u0423",
+  ucy: "\u0443",
+  Fcy: "\u0424",
+  fcy: "\u0444",
+  KHcy: "\u0425",
+  khcy: "\u0445",
+  TScy: "\u0426",
+  tscy: "\u0446",
+  CHcy: "\u0427",
+  chcy: "\u0447",
+  SHcy: "\u0428",
+  shcy: "\u0448",
+  SHCHcy: "\u0429",
+  shchcy: "\u0449",
+  HARDcy: "\u042A",
+  hardcy: "\u044A",
+  Ycy: "\u042B",
+  ycy: "\u044B",
+  SOFTcy: "\u042C",
+  softcy: "\u044C",
+  Ecy: "\u042D",
+  ecy: "\u044D",
+  YUcy: "\u042E",
+  yucy: "\u044E",
+  YAcy: "\u042F",
+  yacy: "\u044F",
+  DJcy: "\u0402",
+  djcy: "\u0452",
+  GJcy: "\u0403",
+  gjcy: "\u0453",
+  Jukcy: "\u0404",
+  jukcy: "\u0454",
+  DScy: "\u0405",
+  dscy: "\u0455",
+  Iukcy: "\u0406",
+  iukcy: "\u0456",
+  YIcy: "\u0407",
+  yicy: "\u0457",
+  Jsercy: "\u0408",
+  jsercy: "\u0458",
+  LJcy: "\u0409",
+  ljcy: "\u0459",
+  NJcy: "\u040A",
+  njcy: "\u045A",
+  TSHcy: "\u040B",
+  tshcy: "\u045B",
+  KJcy: "\u040C",
+  kjcy: "\u045C",
+  Ubrcy: "\u040E",
+  ubrcy: "\u045E",
+  DZcy: "\u040F",
+  dzcy: "\u045F"
+};
+var MATH = {
+  plus: "+",
+  minus: "\u2212",
+  mnplus: "\u2213",
+  mp: "\u2213",
+  pm: "\xB1",
+  times: "\xD7",
+  div: "\xF7",
+  divide: "\xF7",
+  sdot: "\u22C5",
+  star: "\u2606",
+  starf: "\u2605",
+  bigstar: "\u2605",
+  lowast: "\u2217",
+  ast: "*",
+  midast: "*",
+  compfn: "\u2218",
+  smallcircle: "\u2218",
+  bullet: "\u2022",
+  bull: "\u2022",
+  nbsp: "\xA0",
+  hellip: "\u2026",
+  mldr: "\u2026",
+  prime: "\u2032",
+  Prime: "\u2033",
+  tprime: "\u2034",
+  bprime: "\u2035",
+  backprime: "\u2035",
+  minus: "\u2212",
+  minusd: "\u2238",
+  dotminus: "\u2238",
+  plusdo: "\u2214",
+  dotplus: "\u2214",
+  plusmn: "\xB1",
+  minusplus: "\u2213",
+  mnplus: "\u2213",
+  mp: "\u2213",
+  setminus: "\u2216",
+  smallsetminus: "\u2216",
+  Backslash: "\u2216",
+  setmn: "\u2216",
+  ssetmn: "\u2216",
+  lowbar: "_",
+  verbar: "|",
+  vert: "|",
+  VerticalLine: "|",
+  colon: ":",
+  Colon: "\u2237",
+  Proportion: "\u2237",
+  ratio: "\u2236",
+  equals: "=",
+  ne: "\u2260",
+  nequiv: "\u2262",
+  equiv: "\u2261",
+  Congruent: "\u2261",
+  sim: "\u223C",
+  thicksim: "\u223C",
+  thksim: "\u223C",
+  sime: "\u2243",
+  simeq: "\u2243",
+  TildeEqual: "\u2243",
+  asymp: "\u2248",
+  approx: "\u2248",
+  thickapprox: "\u2248",
+  thkap: "\u2248",
+  TildeTilde: "\u2248",
+  ncong: "\u2247",
+  cong: "\u2245",
+  TildeFullEqual: "\u2245",
+  asympeq: "\u224D",
+  CupCap: "\u224D",
+  bump: "\u224E",
+  Bumpeq: "\u224E",
+  HumpDownHump: "\u224E",
+  bumpe: "\u224F",
+  bumpeq: "\u224F",
+  HumpEqual: "\u224F",
+  dotminus: "\u2238",
+  minusd: "\u2238",
+  plusdo: "\u2214",
+  dotplus: "\u2214",
+  le: "\u2264",
+  LessEqual: "\u2264",
+  ge: "\u2265",
+  GreaterEqual: "\u2265",
+  lesseqgtr: "\u22DA",
+  lesseqqgtr: "\u2A8B",
+  greater: ">",
+  less: "<"
+};
+var MATH_ADVANCED = {
+  alefsym: "\u2135",
+  aleph: "\u2135",
+  beth: "\u2136",
+  gimel: "\u2137",
+  daleth: "\u2138",
+  forall: "\u2200",
+  ForAll: "\u2200",
+  part: "\u2202",
+  PartialD: "\u2202",
+  exist: "\u2203",
+  Exists: "\u2203",
+  nexist: "\u2204",
+  nexists: "\u2204",
+  empty: "\u2205",
+  emptyset: "\u2205",
+  emptyv: "\u2205",
+  varnothing: "\u2205",
+  nabla: "\u2207",
+  Del: "\u2207",
+  isin: "\u2208",
+  isinv: "\u2208",
+  in: "\u2208",
+  Element: "\u2208",
+  notin: "\u2209",
+  notinva: "\u2209",
+  ni: "\u220B",
+  niv: "\u220B",
+  SuchThat: "\u220B",
+  ReverseElement: "\u220B",
+  notni: "\u220C",
+  notniva: "\u220C",
+  prod: "\u220F",
+  Product: "\u220F",
+  coprod: "\u2210",
+  Coproduct: "\u2210",
+  sum: "\u2211",
+  Sum: "\u2211",
+  minus: "\u2212",
+  mp: "\u2213",
+  plusdo: "\u2214",
+  dotplus: "\u2214",
+  setminus: "\u2216",
+  lowast: "\u2217",
+  radic: "\u221A",
+  Sqrt: "\u221A",
+  prop: "\u221D",
+  propto: "\u221D",
+  Proportional: "\u221D",
+  varpropto: "\u221D",
+  infin: "\u221E",
+  infintie: "\u29DD",
+  ang: "\u2220",
+  angle: "\u2220",
+  angmsd: "\u2221",
+  measuredangle: "\u2221",
+  angsph: "\u2222",
+  mid: "\u2223",
+  VerticalBar: "\u2223",
+  nmid: "\u2224",
+  nsmid: "\u2224",
+  npar: "\u2226",
+  parallel: "\u2225",
+  spar: "\u2225",
+  nparallel: "\u2226",
+  nspar: "\u2226",
+  and: "\u2227",
+  wedge: "\u2227",
+  or: "\u2228",
+  vee: "\u2228",
+  cap: "\u2229",
+  cup: "\u222A",
+  int: "\u222B",
+  Integral: "\u222B",
+  conint: "\u222E",
+  ContourIntegral: "\u222E",
+  Conint: "\u222F",
+  DoubleContourIntegral: "\u222F",
+  Cconint: "\u2230",
+  there4: "\u2234",
+  therefore: "\u2234",
+  Therefore: "\u2234",
+  becaus: "\u2235",
+  because: "\u2235",
+  Because: "\u2235",
+  ratio: "\u2236",
+  Proportion: "\u2237",
+  minusd: "\u2238",
+  dotminus: "\u2238",
+  mDDot: "\u223A",
+  homtht: "\u223B",
+  sim: "\u223C",
+  bsimg: "\u223D",
+  backsim: "\u223D",
+  ac: "\u223E",
+  mstpos: "\u223E",
+  acd: "\u223F",
+  VerticalTilde: "\u2240",
+  wr: "\u2240",
+  wreath: "\u2240",
+  nsime: "\u2244",
+  nsimeq: "\u2244",
+  nsimeq: "\u2244",
+  ncong: "\u2247",
+  simne: "\u2246",
+  ncongdot: "\u2A6D\u0338",
+  ngsim: "\u2275",
+  nsim: "\u2241",
+  napprox: "\u2249",
+  nap: "\u2249",
+  ngeq: "\u2271",
+  nge: "\u2271",
+  nleq: "\u2270",
+  nle: "\u2270",
+  ngtr: "\u226F",
+  ngt: "\u226F",
+  nless: "\u226E",
+  nlt: "\u226E",
+  nprec: "\u2280",
+  npr: "\u2280",
+  nsucc: "\u2281",
+  nsc: "\u2281"
+};
+var ARROWS = {
+  larr: "\u2190",
+  leftarrow: "\u2190",
+  LeftArrow: "\u2190",
+  uarr: "\u2191",
+  uparrow: "\u2191",
+  UpArrow: "\u2191",
+  rarr: "\u2192",
+  rightarrow: "\u2192",
+  RightArrow: "\u2192",
+  darr: "\u2193",
+  downarrow: "\u2193",
+  DownArrow: "\u2193",
+  harr: "\u2194",
+  leftrightarrow: "\u2194",
+  LeftRightArrow: "\u2194",
+  varr: "\u2195",
+  updownarrow: "\u2195",
+  UpDownArrow: "\u2195",
+  nwarr: "\u2196",
+  nwarrow: "\u2196",
+  UpperLeftArrow: "\u2196",
+  nearr: "\u2197",
+  nearrow: "\u2197",
+  UpperRightArrow: "\u2197",
+  searr: "\u2198",
+  searrow: "\u2198",
+  LowerRightArrow: "\u2198",
+  swarr: "\u2199",
+  swarrow: "\u2199",
+  LowerLeftArrow: "\u2199",
+  lArr: "\u21D0",
+  Leftarrow: "\u21D0",
+  uArr: "\u21D1",
+  Uparrow: "\u21D1",
+  rArr: "\u21D2",
+  Rightarrow: "\u21D2",
+  dArr: "\u21D3",
+  Downarrow: "\u21D3",
+  hArr: "\u21D4",
+  Leftrightarrow: "\u21D4",
+  iff: "\u21D4",
+  vArr: "\u21D5",
+  Updownarrow: "\u21D5",
+  lAarr: "\u21DA",
+  Lleftarrow: "\u21DA",
+  rAarr: "\u21DB",
+  Rrightarrow: "\u21DB",
+  lrarr: "\u21C6",
+  leftrightarrows: "\u21C6",
+  rlarr: "\u21C4",
+  rightleftarrows: "\u21C4",
+  lrhar: "\u21CB",
+  leftrightharpoons: "\u21CB",
+  ReverseEquilibrium: "\u21CB",
+  rlhar: "\u21CC",
+  rightleftharpoons: "\u21CC",
+  Equilibrium: "\u21CC",
+  udarr: "\u21C5",
+  UpArrowDownArrow: "\u21C5",
+  duarr: "\u21F5",
+  DownArrowUpArrow: "\u21F5",
+  llarr: "\u21C7",
+  leftleftarrows: "\u21C7",
+  rrarr: "\u21C9",
+  rightrightarrows: "\u21C9",
+  ddarr: "\u21CA",
+  downdownarrows: "\u21CA",
+  har: "\u21BD",
+  lhard: "\u21BD",
+  leftharpoondown: "\u21BD",
+  lharu: "\u21BC",
+  leftharpoonup: "\u21BC",
+  rhard: "\u21C1",
+  rightharpoondown: "\u21C1",
+  rharu: "\u21C0",
+  rightharpoonup: "\u21C0",
+  lsh: "\u21B0",
+  Lsh: "\u21B0",
+  rsh: "\u21B1",
+  Rsh: "\u21B1",
+  ldsh: "\u21B2",
+  rdsh: "\u21B3",
+  hookleftarrow: "\u21A9",
+  hookrightarrow: "\u21AA",
+  mapstoleft: "\u21A4",
+  mapstoup: "\u21A5",
+  map: "\u21A6",
+  mapsto: "\u21A6",
+  mapstodown: "\u21A7",
+  crarr: "\u21B5",
+  nwarrow: "\u2196",
+  nearrow: "\u2197",
+  searrow: "\u2198",
+  swarrow: "\u2199",
+  nleftarrow: "\u219A",
+  nleftrightarrow: "\u21AE",
+  nrightarrow: "\u219B",
+  nrarr: "\u219B",
+  larrtl: "\u21A2",
+  rarrtl: "\u21A3",
+  leftarrowtail: "\u21A2",
+  rightarrowtail: "\u21A3",
+  twoheadleftarrow: "\u219E",
+  twoheadrightarrow: "\u21A0",
+  Larr: "\u219E",
+  Rarr: "\u21A0",
+  larrhk: "\u21A9",
+  rarrhk: "\u21AA",
+  larrlp: "\u21AB",
+  looparrowleft: "\u21AB",
+  rarrlp: "\u21AC",
+  looparrowright: "\u21AC",
+  harrw: "\u21AD",
+  leftrightsquigarrow: "\u21AD",
+  nrarrw: "\u219D\u0338",
+  rarrw: "\u219D",
+  rightsquigarrow: "\u219D",
+  larrbfs: "\u291F",
+  rarrbfs: "\u2920",
+  nvHarr: "\u2904",
+  nvlArr: "\u2902",
+  nvrArr: "\u2903",
+  larrfs: "\u291D",
+  rarrfs: "\u291E",
+  Map: "\u2905",
+  larrsim: "\u2973",
+  rarrsim: "\u2974",
+  harrcir: "\u2948",
+  Uarrocir: "\u2949",
+  lurdshar: "\u294A",
+  ldrdhar: "\u2967",
+  ldrushar: "\u294B",
+  rdldhar: "\u2969",
+  lrhard: "\u296D",
+  rlhar: "\u21CC",
+  uharr: "\u21BE",
+  uharl: "\u21BF",
+  dharr: "\u21C2",
+  dharl: "\u21C3",
+  Uarr: "\u219F",
+  Darr: "\u21A1",
+  zigrarr: "\u21DD",
+  nwArr: "\u21D6",
+  neArr: "\u21D7",
+  seArr: "\u21D8",
+  swArr: "\u21D9",
+  nharr: "\u21AE",
+  nhArr: "\u21CE",
+  nlarr: "\u219A",
+  nlArr: "\u21CD",
+  nrarr: "\u219B",
+  nrArr: "\u21CF",
+  larrb: "\u21E4",
+  LeftArrowBar: "\u21E4",
+  rarrb: "\u21E5",
+  RightArrowBar: "\u21E5"
+};
+var SHAPES = {
+  square: "\u25A1",
+  Square: "\u25A1",
+  squ: "\u25A1",
+  squf: "\u25AA",
+  squarf: "\u25AA",
+  blacksquar: "\u25AA",
+  blacksquare: "\u25AA",
+  FilledVerySmallSquare: "\u25AA",
+  blk34: "\u2593",
+  blk12: "\u2592",
+  blk14: "\u2591",
+  block: "\u2588",
+  srect: "\u25AD",
+  rect: "\u25AD",
+  sdot: "\u22C5",
+  sdotb: "\u22A1",
+  dotsquare: "\u22A1",
+  triangle: "\u25B5",
+  tri: "\u25B5",
+  trine: "\u25B5",
+  utri: "\u25B5",
+  triangledown: "\u25BF",
+  dtri: "\u25BF",
+  tridown: "\u25BF",
+  triangleleft: "\u25C3",
+  ltri: "\u25C3",
+  triangleright: "\u25B9",
+  rtri: "\u25B9",
+  blacktriangle: "\u25B4",
+  utrif: "\u25B4",
+  blacktriangledown: "\u25BE",
+  dtrif: "\u25BE",
+  blacktriangleleft: "\u25C2",
+  ltrif: "\u25C2",
+  blacktriangleright: "\u25B8",
+  rtrif: "\u25B8",
+  loz: "\u25CA",
+  lozenge: "\u25CA",
+  blacklozenge: "\u29EB",
+  lozf: "\u29EB",
+  bigcirc: "\u25EF",
+  xcirc: "\u25EF",
+  circ: "\u02C6",
+  Circle: "\u25CB",
+  cir: "\u25CB",
+  o: "\u25CB",
+  bullet: "\u2022",
+  bull: "\u2022",
+  hellip: "\u2026",
+  mldr: "\u2026",
+  nldr: "\u2025",
+  boxh: "\u2500",
+  HorizontalLine: "\u2500",
+  boxv: "\u2502",
+  boxdr: "\u250C",
+  boxdl: "\u2510",
+  boxur: "\u2514",
+  boxul: "\u2518",
+  boxvr: "\u251C",
+  boxvl: "\u2524",
+  boxhd: "\u252C",
+  boxhu: "\u2534",
+  boxvh: "\u253C",
+  boxH: "\u2550",
+  boxV: "\u2551",
+  boxdR: "\u2552",
+  boxDr: "\u2553",
+  boxDR: "\u2554",
+  boxDl: "\u2555",
+  boxdL: "\u2556",
+  boxDL: "\u2557",
+  boxuR: "\u2558",
+  boxUr: "\u2559",
+  boxUR: "\u255A",
+  boxUl: "\u255C",
+  boxuL: "\u255B",
+  boxUL: "\u255D",
+  boxvR: "\u255E",
+  boxVr: "\u255F",
+  boxVR: "\u2560",
+  boxVl: "\u2562",
+  boxvL: "\u2561",
+  boxVL: "\u2563",
+  boxHd: "\u2564",
+  boxhD: "\u2565",
+  boxHD: "\u2566",
+  boxHu: "\u2567",
+  boxhU: "\u2568",
+  boxHU: "\u2569",
+  boxvH: "\u256A",
+  boxVh: "\u256B",
+  boxVH: "\u256C"
+};
+var PUNCTUATION = {
+  excl: "!",
+  iexcl: "\xA1",
+  brvbar: "\xA6",
+  sect: "\xA7",
+  uml: "\xA8",
+  copy: "\xA9",
+  ordf: "\xAA",
+  laquo: "\xAB",
+  not: "\xAC",
+  shy: "\xAD",
+  reg: "\xAE",
+  macr: "\xAF",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  acute: "\xB4",
+  micro: "\xB5",
+  para: "\xB6",
+  middot: "\xB7",
+  cedil: "\xB8",
+  sup1: "\xB9",
+  ordm: "\xBA",
+  raquo: "\xBB",
+  frac14: "\xBC",
+  frac12: "\xBD",
+  frac34: "\xBE",
+  iquest: "\xBF",
+  nbsp: "\xA0",
+  comma: ",",
+  period: ".",
+  colon: ":",
+  semi: ";",
+  vert: "|",
+  Verbar: "\u2016",
+  verbar: "|",
+  dblac: "\u02DD",
+  circ: "\u02C6",
+  caron: "\u02C7",
+  breve: "\u02D8",
+  dot: "\u02D9",
+  ring: "\u02DA",
+  ogon: "\u02DB",
+  tilde: "\u02DC",
+  DiacriticalGrave: "`",
+  DiacriticalAcute: "\xB4",
+  DiacriticalTilde: "\u02DC",
+  DiacriticalDot: "\u02D9",
+  DiacriticalDoubleAcute: "\u02DD",
+  grave: "`",
+  acute: "\xB4"
+};
+var CURRENCY = {
+  cent: "\xA2",
+  pound: "\xA3",
+  curren: "\xA4",
+  yen: "\xA5",
+  euro: "\u20AC",
+  dollar: "$",
+  euro: "\u20AC",
+  fnof: "\u0192",
+  inr: "\u20B9",
+  af: "\u060B",
+  birr: "\u1265\u122D",
+  peso: "\u20B1",
+  rub: "\u20BD",
+  won: "\u20A9",
+  yuan: "\xA5",
+  cedil: "\xB8"
+};
+var FRACTIONS = {
+  frac12: "\xBD",
+  half: "\xBD",
+  frac13: "\u2153",
+  frac14: "\xBC",
+  frac15: "\u2155",
+  frac16: "\u2159",
+  frac18: "\u215B",
+  frac23: "\u2154",
+  frac25: "\u2156",
+  frac34: "\xBE",
+  frac35: "\u2157",
+  frac38: "\u215C",
+  frac45: "\u2158",
+  frac56: "\u215A",
+  frac58: "\u215D",
+  frac78: "\u215E",
+  frasl: "\u2044"
+};
+var MISC_SYMBOLS = {
+  trade: "\u2122",
+  TRADE: "\u2122",
+  telrec: "\u2315",
+  target: "\u2316",
+  ulcorn: "\u231C",
+  ulcorner: "\u231C",
+  urcorn: "\u231D",
+  urcorner: "\u231D",
+  dlcorn: "\u231E",
+  llcorner: "\u231E",
+  drcorn: "\u231F",
+  lrcorner: "\u231F",
+  intercal: "\u22BA",
+  intcal: "\u22BA",
+  oplus: "\u2295",
+  CirclePlus: "\u2295",
+  ominus: "\u2296",
+  CircleMinus: "\u2296",
+  otimes: "\u2297",
+  CircleTimes: "\u2297",
+  osol: "\u2298",
+  odot: "\u2299",
+  CircleDot: "\u2299",
+  oast: "\u229B",
+  circledast: "\u229B",
+  odash: "\u229D",
+  circleddash: "\u229D",
+  ocirc: "\u229A",
+  circledcirc: "\u229A",
+  boxplus: "\u229E",
+  plusb: "\u229E",
+  boxminus: "\u229F",
+  minusb: "\u229F",
+  boxtimes: "\u22A0",
+  timesb: "\u22A0",
+  boxdot: "\u22A1",
+  sdotb: "\u22A1",
+  veebar: "\u22BB",
+  vee: "\u2228",
+  barvee: "\u22BD",
+  and: "\u2227",
+  wedge: "\u2227",
+  Cap: "\u22D2",
+  Cup: "\u22D3",
+  Fork: "\u22D4",
+  pitchfork: "\u22D4",
+  epar: "\u22D5",
+  ltlarr: "\u2976",
+  nvap: "\u224D\u20D2",
+  nvsim: "\u223C\u20D2",
+  nvge: "\u2265\u20D2",
+  nvle: "\u2264\u20D2",
+  nvlt: "<\u20D2",
+  nvgt: ">\u20D2",
+  nvltrie: "\u22B4\u20D2",
+  nvrtrie: "\u22B5\u20D2",
+  Vdash: "\u22A9",
+  dashv: "\u22A3",
+  vDash: "\u22A8",
+  Vdash: "\u22A9",
+  Vvdash: "\u22AA",
+  nvdash: "\u22AC",
+  nvDash: "\u22AD",
+  nVdash: "\u22AE",
+  nVDash: "\u22AF"
+};
+var ALL_ENTITIES = {
+  ...BASIC_LATIN,
+  ...LATIN_ACCENTS,
+  ...LATIN_EXTENDED,
+  ...GREEK,
+  ...CYRILLIC,
+  ...MATH,
+  ...MATH_ADVANCED,
+  ...ARROWS,
+  ...SHAPES,
+  ...PUNCTUATION,
+  ...CURRENCY,
+  ...FRACTIONS,
+  ...MISC_SYMBOLS
+};
+var XML = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  quot: '"'
+};
+var COMMON_HTML = {
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  hellip: "\u2026",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bull: "\u2022",
+  para: "\xB6",
+  sect: "\xA7",
+  deg: "\xB0",
+  frac12: "\xBD",
+  frac14: "\xBC",
+  frac34: "\xBE"
+};
+
+// ../../.yarn/cache/@nodable-entities-npm-2.1.0-6eb9f06ac0-355c55e82a.zip/node_modules/@nodable/entities/src/EntityDecoder.js
+var SPECIAL_CHARS = new Set("!?\\\\/[]$%{}^&*()<>|+");
+function validateEntityName(name) {
+  if (name[0] === "#") {
+    throw new Error(`[EntityReplacer] Invalid character '#' in entity name: "${name}"`);
+  }
+  for (const ch of name) {
+    if (SPECIAL_CHARS.has(ch)) {
+      throw new Error(`[EntityReplacer] Invalid character '${ch}' in entity name: "${name}"`);
+    }
+  }
+  return name;
+}
+function mergeEntityMaps(...maps) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const map2 of maps) {
+    if (!map2) continue;
+    for (const key of Object.keys(map2)) {
+      const raw = map2[key];
+      if (typeof raw === "string") {
+        out[key] = raw;
+      } else if (raw && typeof raw === "object" && raw.val !== void 0) {
+        const val = raw.val;
+        if (typeof val === "string") {
+          out[key] = val;
+        }
+      }
+    }
+  }
+  return out;
+}
+var LIMIT_TIER_EXTERNAL = "external";
+var LIMIT_TIER_BASE = "base";
+var LIMIT_TIER_ALL = "all";
+function parseLimitTiers(raw) {
+  if (!raw || raw === LIMIT_TIER_EXTERNAL) return /* @__PURE__ */ new Set([LIMIT_TIER_EXTERNAL]);
+  if (raw === LIMIT_TIER_ALL) return /* @__PURE__ */ new Set([LIMIT_TIER_ALL]);
+  if (raw === LIMIT_TIER_BASE) return /* @__PURE__ */ new Set([LIMIT_TIER_BASE]);
+  if (Array.isArray(raw)) return new Set(raw);
+  return /* @__PURE__ */ new Set([LIMIT_TIER_EXTERNAL]);
+}
+var NCR_LEVEL = Object.freeze({ allow: 0, leave: 1, remove: 2, throw: 3 });
+var XML10_ALLOWED_C0 = /* @__PURE__ */ new Set([9, 10, 13]);
+function parseNCRConfig(ncr) {
+  if (!ncr) {
+    return { xmlVersion: 1, onLevel: NCR_LEVEL.allow, nullLevel: NCR_LEVEL.remove };
+  }
+  const xmlVersion = ncr.xmlVersion === 1.1 ? 1.1 : 1;
+  const onLevel = NCR_LEVEL[ncr.onNCR] ?? NCR_LEVEL.allow;
+  const nullLevel = NCR_LEVEL[ncr.nullNCR] ?? NCR_LEVEL.remove;
+  const clampedNull = Math.max(nullLevel, NCR_LEVEL.remove);
+  return { xmlVersion, onLevel, nullLevel: clampedNull };
+}
+var EntityDecoder = class {
+  /**
+   * @param {object} [options]
+   * @param {object|null}  [options.namedEntities]        — extra named entities merged into base map
+   * @param {object}  [options.limit]                 — security limits
+   * @param {number}       [options.limit.maxTotalExpansions=0]  — 0 = unlimited
+   * @param {number}       [options.limit.maxExpandedLength=0]   — 0 = unlimited
+   * @param {'external'|'base'|'all'|string[]} [options.limit.applyLimitsTo='external']
+   *   Which entity tiers count against the security limits:
+   *   - 'external' (default) — only input/runtime + persistent external entities
+   *   - 'base'               — only DEFAULT_XML_ENTITIES + namedEntities
+   *   - 'all'                — every entity regardless of tier
+   *   - string[]             — explicit combination, e.g. ['external', 'base']
+   * @param {((resolved: string, original: string) => string)|null} [options.postCheck=null]
+   * @param {string[]} [options.remove=[]] — entity names (e.g. ['nbsp', '#13']) to delete (replace with empty string)
+   * @param {string[]} [options.leave=[]]  — entity names to keep as literal (unchanged in output)
+   * @param {object}   [options.ncr]       — Numeric Character Reference controls
+   * @param {1.0|1.1}  [options.ncr.xmlVersion=1.0]
+   *   XML version governing which codepoint ranges are restricted:
+   *   - 1.0 — C0 controls U+0001–U+001F (except U+0009/000A/000D) are prohibited
+   *   - 1.1 — C0 controls are allowed when written as NCRs; C1 (U+007F–U+009F) decoded as-is
+   * @param {'allow'|'leave'|'remove'|'throw'} [options.ncr.onNCR='allow']
+   *   Base action for numeric references. Severity order: allow < leave < remove < throw.
+   *   For codepoint ranges that carry a minimum level (surrogates → remove, XML 1.0 C0 → remove),
+   *   the effective action is max(onNCR, rangeMinimum).
+   * @param {'remove'|'throw'} [options.ncr.nullNCR='remove']
+   *   Action for U+0000 (null). 'allow' and 'leave' are clamped to 'remove' since null is never safe.
+   */
+  constructor(options2 = {}) {
+    this._limit = options2.limit || {};
+    this._maxTotalExpansions = this._limit.maxTotalExpansions || 0;
+    this._maxExpandedLength = this._limit.maxExpandedLength || 0;
+    this._postCheck = typeof options2.postCheck === "function" ? options2.postCheck : (r) => r;
+    this._limitTiers = parseLimitTiers(this._limit.applyLimitsTo ?? LIMIT_TIER_EXTERNAL);
+    this._numericAllowed = options2.numericAllowed ?? true;
+    this._baseMap = mergeEntityMaps(XML, options2.namedEntities || null);
+    this._externalMap = /* @__PURE__ */ Object.create(null);
+    this._inputMap = /* @__PURE__ */ Object.create(null);
+    this._totalExpansions = 0;
+    this._expandedLength = 0;
+    this._removeSet = new Set(options2.remove && Array.isArray(options2.remove) ? options2.remove : []);
+    this._leaveSet = new Set(options2.leave && Array.isArray(options2.leave) ? options2.leave : []);
+    const ncrCfg = parseNCRConfig(options2.ncr);
+    this._ncrXmlVersion = ncrCfg.xmlVersion;
+    this._ncrOnLevel = ncrCfg.onLevel;
+    this._ncrNullLevel = ncrCfg.nullLevel;
+  }
+  // -------------------------------------------------------------------------
+  // Persistent external entity registration
+  // -------------------------------------------------------------------------
+  /**
+   * Replace the full set of persistent external entities.
+   * All keys are validated — throws on invalid characters.
+   * @param {Record<string, string | { regex?: RegExp, val: string }>} map
+   */
+  setExternalEntities(map2) {
+    if (map2) {
+      for (const key of Object.keys(map2)) {
+        validateEntityName(key);
+      }
+    }
+    this._externalMap = mergeEntityMaps(map2);
+  }
+  /**
+   * Add a single persistent external entity.
+   * @param {string} key
+   * @param {string} value
+   */
+  addExternalEntity(key, value) {
+    validateEntityName(key);
+    if (typeof value === "string" && value.indexOf("&") === -1) {
+      this._externalMap[key] = value;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Input / runtime entity registration (per document)
+  // -------------------------------------------------------------------------
+  /**
+   * Inject DOCTYPE entities for the current document.
+   * Also resets per-document expansion counters.
+   * @param {Record<string, string | { regx?: RegExp, regex?: RegExp, val: string }>} map
+   */
+  addInputEntities(map2) {
+    this._totalExpansions = 0;
+    this._expandedLength = 0;
+    this._inputMap = mergeEntityMaps(map2);
+  }
+  // -------------------------------------------------------------------------
+  // Per-document reset
+  // -------------------------------------------------------------------------
+  /**
+   * Wipe input/runtime entities and reset counters.
+   * Call this before processing each new document.
+   * @returns {this}
+   */
+  reset() {
+    this._inputMap = /* @__PURE__ */ Object.create(null);
+    this._totalExpansions = 0;
+    this._expandedLength = 0;
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // XML version (can be set after construction, e.g. once parser reads <?xml?>)
+  // -------------------------------------------------------------------------
+  /**
+   * Update the XML version used for NCR classification.
+   * Call this as soon as the document's `<?xml version="...">` declaration is parsed.
+   * @param {1.0|1.1|number} version
+   */
+  setXmlVersion(version) {
+    this._ncrXmlVersion = version === 1.1 ? 1.1 : 1;
+  }
+  // -------------------------------------------------------------------------
+  // Primary API
+  // -------------------------------------------------------------------------
+  /**
+   * Replace all entity references in `str` in a single pass.
+   *
+   * @param {string} str
+   * @returns {string}
+   */
+  decode(str) {
+    if (typeof str !== "string" || str.length === 0) return str;
+    const original = str;
+    const chunks = [];
+    const len = str.length;
+    let last = 0;
+    let i = 0;
+    const limitExpansions = this._maxTotalExpansions > 0;
+    const limitLength = this._maxExpandedLength > 0;
+    const checkLimits = limitExpansions || limitLength;
+    while (i < len) {
+      if (str.charCodeAt(i) !== 38) {
+        i++;
+        continue;
+      }
+      let j = i + 1;
+      while (j < len && str.charCodeAt(j) !== 59 && j - i <= 32) j++;
+      if (j >= len || str.charCodeAt(j) !== 59) {
+        i++;
+        continue;
+      }
+      const token = str.slice(i + 1, j);
+      if (token.length === 0) {
+        i++;
+        continue;
+      }
+      let replacement;
+      let tier;
+      if (this._removeSet.has(token)) {
+        replacement = "";
+        if (tier === void 0) {
+          tier = LIMIT_TIER_EXTERNAL;
+        }
+      } else if (this._leaveSet.has(token)) {
+        i++;
+        continue;
+      } else if (token.charCodeAt(0) === 35) {
+        const ncrResult = this._resolveNCR(token);
+        if (ncrResult === void 0) {
+          i++;
+          continue;
+        }
+        replacement = ncrResult;
+        tier = LIMIT_TIER_BASE;
+      } else {
+        const resolved = this._resolveName(token);
+        replacement = resolved?.value;
+        tier = resolved?.tier;
+      }
+      if (replacement === void 0) {
+        i++;
+        continue;
+      }
+      if (i > last) chunks.push(str.slice(last, i));
+      chunks.push(replacement);
+      last = j + 1;
+      i = last;
+      if (checkLimits && this._tierCounts(tier)) {
+        if (limitExpansions) {
+          this._totalExpansions++;
+          if (this._totalExpansions > this._maxTotalExpansions) {
+            throw new Error(
+              `[EntityReplacer] Entity expansion count limit exceeded: ${this._totalExpansions} > ${this._maxTotalExpansions}`
+            );
+          }
+        }
+        if (limitLength) {
+          const delta = replacement.length - (token.length + 2);
+          if (delta > 0) {
+            this._expandedLength += delta;
+            if (this._expandedLength > this._maxExpandedLength) {
+              throw new Error(
+                `[EntityReplacer] Expanded content length limit exceeded: ${this._expandedLength} > ${this._maxExpandedLength}`
+              );
+            }
+          }
+        }
+      }
+    }
+    if (last < len) chunks.push(str.slice(last));
+    const result = chunks.length === 0 ? str : chunks.join("");
+    return this._postCheck(result, original);
+  }
+  // -------------------------------------------------------------------------
+  // Private: limit tier check
+  // -------------------------------------------------------------------------
+  /**
+   * Returns true if a resolved entity of the given tier should count
+   * against the expansion/length limits.
+   * @param {string} tier  — LIMIT_TIER_EXTERNAL | LIMIT_TIER_BASE
+   * @returns {boolean}
+   */
+  _tierCounts(tier) {
+    if (this._limitTiers.has(LIMIT_TIER_ALL)) return true;
+    return this._limitTiers.has(tier);
+  }
+  // -------------------------------------------------------------------------
+  // Private: entity resolution
+  // -------------------------------------------------------------------------
+  /**
+   * Resolve a named entity token (without & and ;).
+   * Priority: inputMap > externalMap > baseMap
+   * Returns the resolved value tagged with its limit tier.
+   *
+   * @param {string} name
+   * @returns {{ value: string, tier: string }|undefined}
+   */
+  _resolveName(name) {
+    if (name in this._inputMap) return { value: this._inputMap[name], tier: LIMIT_TIER_EXTERNAL };
+    if (name in this._externalMap) return { value: this._externalMap[name], tier: LIMIT_TIER_EXTERNAL };
+    if (name in this._baseMap) return { value: this._baseMap[name], tier: LIMIT_TIER_BASE };
+    return void 0;
+  }
+  /**
+   * Classify a codepoint and return the minimum action level that must be applied.
+   * Returns -1 when no minimum is imposed (normal allow path).
+   *
+   * Ranges checked (in priority order):
+   *   1. U+0000            — null, governed by nullNCR (always ≥ remove)
+   *   2. U+D800–U+DFFF     — surrogates, always prohibited (min: remove)
+   *   3. U+0001–U+001F \ {0x09,0x0A,0x0D}  — XML 1.0 restricted C0 (min: remove)
+   *      (skipped in XML 1.1 — C0 controls are allowed when written as NCRs)
+   *
+   * @param {number} cp  — codepoint
+   * @returns {number}   — minimum NCR_LEVEL value, or -1 for no restriction
+   */
+  _classifyNCR(cp) {
+    if (cp === 0) return this._ncrNullLevel;
+    if (cp >= 55296 && cp <= 57343) return NCR_LEVEL.remove;
+    if (this._ncrXmlVersion === 1) {
+      if (cp >= 1 && cp <= 31 && !XML10_ALLOWED_C0.has(cp)) return NCR_LEVEL.remove;
+    }
+    return -1;
+  }
+  /**
+   * Execute a resolved NCR action.
+   *
+   * @param {number} action   — NCR_LEVEL value
+   * @param {string} token    — raw token (e.g. '#38') for error messages
+   * @param {number} cp       — codepoint, used only for error messages
+   * @returns {string|undefined}
+   *   - decoded character string  → 'allow'
+   *   - ''                        → 'remove'
+   *   - undefined                 → 'leave' (caller must skip past '&' only)
+   *   - throws Error              → 'throw'
+   */
+  _applyNCRAction(action, token, cp) {
+    switch (action) {
+      case NCR_LEVEL.allow:
+        return String.fromCodePoint(cp);
+      case NCR_LEVEL.remove:
+        return "";
+      case NCR_LEVEL.leave:
+        return void 0;
+      // signal: keep literal
+      case NCR_LEVEL.throw:
+        throw new Error(
+          `[EntityDecoder] Prohibited numeric character reference &${token}; (U+${cp.toString(16).toUpperCase().padStart(4, "0")})`
+        );
+      default:
+        return String.fromCodePoint(cp);
+    }
+  }
+  /**
+   * Full NCR resolution pipeline for a numeric token.
+   *
+   * Steps:
+   *   1. Parse the codepoint (decimal or hex).
+   *   2. Validate the raw codepoint range (NaN, <0, >0x10FFFF).
+   *   3. If numericAllowed is false and no minimum restriction applies → leave as-is.
+   *   4. Classify the codepoint to find the minimum required action level.
+   *   5. Resolve effective action = max(onNCR, minimum).
+   *   6. Apply and return.
+   *
+   * @param {string} token  — e.g. '#38', '#x26', '#X26'
+   * @returns {string|undefined}
+   *   - string (incl. '')  — replacement ('' = remove)
+   *   - undefined          — leave original &token; as-is
+   */
+  _resolveNCR(token) {
+    const second = token.charCodeAt(1);
+    let cp;
+    if (second === 120 || second === 88) {
+      cp = parseInt(token.slice(2), 16);
+    } else {
+      cp = parseInt(token.slice(1), 10);
+    }
+    if (Number.isNaN(cp) || cp < 0 || cp > 1114111) return void 0;
+    const minimum = this._classifyNCR(cp);
+    if (!this._numericAllowed && minimum < NCR_LEVEL.remove) return void 0;
+    const effective = minimum === -1 ? this._ncrOnLevel : Math.max(this._ncrOnLevel, minimum);
+    return this._applyNCRAction(effective, token, cp);
+  }
+};
+
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
 var defaultOnDangerousProperty = (name) => {
   if (DANGEROUS_PROPERTY_NAMES.includes(name)) {
     return "__" + name;
@@ -8586,6 +10055,7 @@ var defaultOptions2 = {
   unpairedTags: [],
   processEntities: true,
   htmlEntities: false,
+  entityDecoder: null,
   ignoreDeclaration: false,
   ignorePiTags: false,
   transformTagName: false,
@@ -8617,18 +10087,19 @@ function validatePropertyName(propertyName, optionName) {
     );
   }
 }
-function normalizeProcessEntities(value) {
+function normalizeProcessEntities(value, htmlEntities) {
   if (typeof value === "boolean") {
     return {
       enabled: value,
       // true or false
       maxEntitySize: 1e4,
-      maxExpansionDepth: 10,
-      maxTotalExpansions: 1e3,
+      maxExpansionDepth: 1e4,
+      maxTotalExpansions: Infinity,
       maxExpandedLength: 1e5,
-      maxEntityCount: 100,
+      maxEntityCount: 1e3,
       allowedTags: null,
-      tagFilter: null
+      tagFilter: null,
+      appliesTo: "all"
     };
   }
   if (typeof value === "object" && value !== null) {
@@ -8640,7 +10111,8 @@ function normalizeProcessEntities(value) {
       maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 1e5),
       maxEntityCount: Math.max(1, value.maxEntityCount ?? 1e3),
       allowedTags: value.allowedTags ?? null,
-      tagFilter: value.tagFilter ?? null
+      tagFilter: value.tagFilter ?? null,
+      appliesTo: value.appliesTo ?? "all"
     };
   }
   return normalizeProcessEntities(true);
@@ -8662,7 +10134,8 @@ var buildOptions = function(options2) {
   if (built.onDangerousProperty === null) {
     built.onDangerousProperty = defaultOnDangerousProperty;
   }
-  built.processEntities = normalizeProcessEntities(built.processEntities);
+  built.processEntities = normalizeProcessEntities(built.processEntities, built.htmlEntities);
+  built.unpairedTagsSet = new Set(built.unpairedTags);
   if (built.stopNodes && Array.isArray(built.stopNodes)) {
     built.stopNodes = built.stopNodes.map((node) => {
       if (typeof node === "string" && node.startsWith("*.")) {
@@ -8674,7 +10147,7 @@ var buildOptions = function(options2) {
   return built;
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
 var METADATA_SYMBOL;
 if (typeof Symbol !== "function") {
   METADATA_SYMBOL = "@@xmlMetadata";
@@ -8708,7 +10181,7 @@ var XmlNode = class {
   }
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
 var DocTypeReader = class {
   constructor(options2) {
     this.suppressValidationErr = !options2;
@@ -8734,11 +10207,7 @@ var DocTypeReader = class {
                   `Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`
                 );
               }
-              const escaped = entityName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-              entities[entityName] = {
-                regx: RegExp(`&${escaped};`, "g"),
-                val
-              };
+              entities[entityName] = val;
               entityCount++;
             }
           } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
@@ -8788,7 +10257,7 @@ var DocTypeReader = class {
       i++;
     }
     let entityName = xmlData.substring(startIndex, i);
-    validateEntityName(entityName);
+    validateEntityName2(entityName);
     i = skipWhitespace(xmlData, i);
     if (!this.suppressValidationErr) {
       if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
@@ -8814,7 +10283,7 @@ var DocTypeReader = class {
       i++;
     }
     let notationName = xmlData.substring(startIndex, i);
-    !this.suppressValidationErr && validateEntityName(notationName);
+    !this.suppressValidationErr && validateEntityName2(notationName);
     i = skipWhitespace(xmlData, i);
     const identifierType = xmlData.substring(i, i + 6).toUpperCase();
     if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
@@ -8896,14 +10365,14 @@ var DocTypeReader = class {
       i++;
     }
     let elementName = xmlData.substring(startIndex, i);
-    validateEntityName(elementName);
+    validateEntityName2(elementName);
     i = skipWhitespace(xmlData, i);
     startIndex = i;
     while (i < xmlData.length && !/\s/.test(xmlData[i])) {
       i++;
     }
     let attributeName = xmlData.substring(startIndex, i);
-    if (!validateEntityName(attributeName)) {
+    if (!validateEntityName2(attributeName)) {
       throw new Error(`Invalid attribute name: "${attributeName}"`);
     }
     i = skipWhitespace(xmlData, i);
@@ -8924,7 +10393,7 @@ var DocTypeReader = class {
         }
         let notation = xmlData.substring(startIndex2, i);
         notation = notation.trim();
-        if (!validateEntityName(notation)) {
+        if (!validateEntityName2(notation)) {
           throw new Error(`Invalid notation name: "${notation}"`);
         }
         allowedNotations.push(notation);
@@ -8981,14 +10450,14 @@ function hasSeq(data, seq, i) {
   }
   return true;
 }
-function validateEntityName(name) {
+function validateEntityName2(name) {
   if (isName(name))
     return name;
   else
     throw new Error(`Invalid entity name ${name}`);
 }
 
-// ../../.yarn/cache/strnum-npm-2.2.2-816fd1e52f-c55813cfde.zip/node_modules/strnum/strnum.js
+// ../../.yarn/cache/strnum-npm-2.2.3-3aa06fd3c4-fb70206301.zip/node_modules/strnum/strnum.js
 var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
 var numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
 var consider = {
@@ -9110,7 +10579,7 @@ function handleInfinity(str, num, options2) {
   }
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
 function getIgnoreAttributesFn(ignoreAttributes) {
   if (typeof ignoreAttributes === "function") {
     return ignoreAttributes;
@@ -9130,7 +10599,7 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 
-// ../../.yarn/cache/path-expression-matcher-npm-1.2.1-1aa3be6f8e-2ef295fc82.zip/node_modules/path-expression-matcher/src/Expression.js
+// ../../.yarn/cache/path-expression-matcher-npm-1.5.0-73d258a112-28303bb9ee.zip/node_modules/path-expression-matcher/src/Expression.js
 var Expression = class {
   /**
    * Create a new Expression
@@ -9138,10 +10607,11 @@ var Expression = class {
    * @param {Object} options - Configuration options
    * @param {string} options.separator - Path separator (default: '.')
    */
-  constructor(pattern, options2 = {}) {
+  constructor(pattern, options2 = {}, data) {
     this.pattern = pattern;
     this.separator = options2.separator || ".";
     this.segments = this._parse(pattern);
+    this.data = data;
     this._hasDeepWildcard = this.segments.some((seg) => seg.type === "deep-wildcard");
     this._hasAttributeCondition = this.segments.some((seg) => seg.attrName !== void 0);
     this._hasPositionSelector = this.segments.some((seg) => seg.position !== void 0);
@@ -9292,30 +10762,302 @@ var Expression = class {
   }
 };
 
-// ../../.yarn/cache/path-expression-matcher-npm-1.2.1-1aa3be6f8e-2ef295fc82.zip/node_modules/path-expression-matcher/src/Matcher.js
-var MUTATING_METHODS = /* @__PURE__ */ new Set(["push", "pop", "reset", "updateCurrent", "restore"]);
+// ../../.yarn/cache/path-expression-matcher-npm-1.5.0-73d258a112-28303bb9ee.zip/node_modules/path-expression-matcher/src/ExpressionSet.js
+var ExpressionSet = class {
+  constructor() {
+    this._byDepthAndTag = /* @__PURE__ */ new Map();
+    this._wildcardByDepth = /* @__PURE__ */ new Map();
+    this._deepWildcards = [];
+    this._patterns = /* @__PURE__ */ new Set();
+    this._sealed = false;
+  }
+  /**
+   * Add an Expression to the set.
+   * Duplicate patterns (same pattern string) are silently ignored.
+   *
+   * @param {import('./Expression.js').default} expression - A pre-constructed Expression instance
+   * @returns {this} for chaining
+   * @throws {TypeError} if called after seal()
+   *
+   * @example
+   * set.add(new Expression('root.users.user'));
+   * set.add(new Expression('..script'));
+   */
+  add(expression) {
+    if (this._sealed) {
+      throw new TypeError(
+        "ExpressionSet is sealed. Create a new ExpressionSet to add more expressions."
+      );
+    }
+    if (this._patterns.has(expression.pattern)) return this;
+    this._patterns.add(expression.pattern);
+    if (expression.hasDeepWildcard()) {
+      this._deepWildcards.push(expression);
+      return this;
+    }
+    const depth = expression.length;
+    const lastSeg = expression.segments[expression.segments.length - 1];
+    const tag = lastSeg?.tag;
+    if (!tag || tag === "*") {
+      if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);
+      this._wildcardByDepth.get(depth).push(expression);
+    } else {
+      const key = `${depth}:${tag}`;
+      if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);
+      this._byDepthAndTag.get(key).push(expression);
+    }
+    return this;
+  }
+  /**
+   * Add multiple expressions at once.
+   *
+   * @param {import('./Expression.js').default[]} expressions - Array of Expression instances
+   * @returns {this} for chaining
+   *
+   * @example
+   * set.addAll([
+   *   new Expression('root.users.user'),
+   *   new Expression('root.config.setting'),
+   * ]);
+   */
+  addAll(expressions) {
+    for (const expr of expressions) this.add(expr);
+    return this;
+  }
+  /**
+   * Check whether a pattern string is already present in the set.
+   *
+   * @param {import('./Expression.js').default} expression
+   * @returns {boolean}
+   */
+  has(expression) {
+    return this._patterns.has(expression.pattern);
+  }
+  /**
+   * Number of expressions in the set.
+   * @type {number}
+   */
+  get size() {
+    return this._patterns.size;
+  }
+  /**
+   * Seal the set against further modifications.
+   * Useful to prevent accidental mutations after config is built.
+   * Calling add() or addAll() on a sealed set throws a TypeError.
+   *
+   * @returns {this}
+   */
+  seal() {
+    this._sealed = true;
+    return this;
+  }
+  /**
+   * Whether the set has been sealed.
+   * @type {boolean}
+   */
+  get isSealed() {
+    return this._sealed;
+  }
+  /**
+   * Test whether the matcher's current path matches any expression in the set.
+   *
+   * Evaluation order (cheapest → most expensive):
+   *  1. Exact depth + tag bucket  — O(1) lookup, typically 0–2 expressions
+   *  2. Depth-only wildcard bucket — O(1) lookup, rare
+   *  3. Deep-wildcard list         — always checked, but usually small
+   *
+   * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+   * @returns {boolean} true if any expression matches the current path
+   *
+   * @example
+   * if (stopNodes.matchesAny(matcher)) {
+   *   // handle stop node
+   * }
+   */
+  matchesAny(matcher) {
+    return this.findMatch(matcher) !== null;
+  }
+  /**
+  * Find and return the first Expression that matches the matcher's current path.
+  *
+  * Uses the same evaluation order as matchesAny (cheapest → most expensive):
+  *  1. Exact depth + tag bucket
+  *  2. Depth-only wildcard bucket
+  *  3. Deep-wildcard list
+  *
+  * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+  * @returns {import('./Expression.js').default | null} the first matching Expression, or null
+  *
+  * @example
+  * const expr = stopNodes.findMatch(matcher);
+  * if (expr) {
+  *   // access expr.config, expr.pattern, etc.
+  * }
+  */
+  findMatch(matcher) {
+    const depth = matcher.getDepth();
+    const tag = matcher.getCurrentTag();
+    const exactKey = `${depth}:${tag}`;
+    const exactBucket = this._byDepthAndTag.get(exactKey);
+    if (exactBucket) {
+      for (let i = 0; i < exactBucket.length; i++) {
+        if (matcher.matches(exactBucket[i])) return exactBucket[i];
+      }
+    }
+    const wildcardBucket = this._wildcardByDepth.get(depth);
+    if (wildcardBucket) {
+      for (let i = 0; i < wildcardBucket.length; i++) {
+        if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];
+      }
+    }
+    for (let i = 0; i < this._deepWildcards.length; i++) {
+      if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];
+    }
+    return null;
+  }
+};
+
+// ../../.yarn/cache/path-expression-matcher-npm-1.5.0-73d258a112-28303bb9ee.zip/node_modules/path-expression-matcher/src/Matcher.js
+var MatcherView = class {
+  /**
+   * @param {Matcher} matcher - The parent Matcher instance to read from.
+   */
+  constructor(matcher) {
+    this._matcher = matcher;
+  }
+  /**
+   * Get the path separator used by the parent matcher.
+   * @returns {string}
+   */
+  get separator() {
+    return this._matcher.separator;
+  }
+  /**
+   * Get current tag name.
+   * @returns {string|undefined}
+   */
+  getCurrentTag() {
+    const path = this._matcher.path;
+    return path.length > 0 ? path[path.length - 1].tag : void 0;
+  }
+  /**
+   * Get current namespace.
+   * @returns {string|undefined}
+   */
+  getCurrentNamespace() {
+    const path = this._matcher.path;
+    return path.length > 0 ? path[path.length - 1].namespace : void 0;
+  }
+  /**
+   * Get current node's attribute value.
+   * @param {string} attrName
+   * @returns {*}
+   */
+  getAttrValue(attrName) {
+    const path = this._matcher.path;
+    if (path.length === 0) return void 0;
+    return path[path.length - 1].values?.[attrName];
+  }
+  /**
+   * Check if current node has an attribute.
+   * @param {string} attrName
+   * @returns {boolean}
+   */
+  hasAttr(attrName) {
+    const path = this._matcher.path;
+    if (path.length === 0) return false;
+    const current = path[path.length - 1];
+    return current.values !== void 0 && attrName in current.values;
+  }
+  /**
+   * Get current node's sibling position (child index in parent).
+   * @returns {number}
+   */
+  getPosition() {
+    const path = this._matcher.path;
+    if (path.length === 0) return -1;
+    return path[path.length - 1].position ?? 0;
+  }
+  /**
+   * Get current node's repeat counter (occurrence count of this tag name).
+   * @returns {number}
+   */
+  getCounter() {
+    const path = this._matcher.path;
+    if (path.length === 0) return -1;
+    return path[path.length - 1].counter ?? 0;
+  }
+  /**
+   * Get current node's sibling index (alias for getPosition).
+   * @returns {number}
+   * @deprecated Use getPosition() or getCounter() instead
+   */
+  getIndex() {
+    return this.getPosition();
+  }
+  /**
+   * Get current path depth.
+   * @returns {number}
+   */
+  getDepth() {
+    return this._matcher.path.length;
+  }
+  /**
+   * Get path as string.
+   * @param {string} [separator] - Optional separator (uses default if not provided)
+   * @param {boolean} [includeNamespace=true]
+   * @returns {string}
+   */
+  toString(separator, includeNamespace = true) {
+    return this._matcher.toString(separator, includeNamespace);
+  }
+  /**
+   * Get path as array of tag names.
+   * @returns {string[]}
+   */
+  toArray() {
+    return this._matcher.path.map((n) => n.tag);
+  }
+  /**
+   * Match current path against an Expression.
+   * @param {Expression} expression
+   * @returns {boolean}
+   */
+  matches(expression) {
+    return this._matcher.matches(expression);
+  }
+  /**
+   * Match any expression in the given set against the current path.
+   * @param {ExpressionSet} exprSet
+   * @returns {boolean}
+   */
+  matchesAny(exprSet) {
+    return exprSet.matchesAny(this._matcher);
+  }
+};
 var Matcher = class {
   /**
-   * Create a new Matcher
-   * @param {Object} options - Configuration options
-   * @param {string} options.separator - Default path separator (default: '.')
+   * Create a new Matcher.
+   * @param {Object} [options={}]
+   * @param {string} [options.separator='.'] - Default path separator
    */
   constructor(options2 = {}) {
     this.separator = options2.separator || ".";
     this.path = [];
     this.siblingStacks = [];
+    this._pathStringCache = null;
+    this._view = new MatcherView(this);
   }
   /**
-   * Push a new tag onto the path
-   * @param {string} tagName - Name of the tag
-   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)
-   * @param {string} namespace - Namespace for the tag (optional)
+   * Push a new tag onto the path.
+   * @param {string} tagName
+   * @param {Object|null} [attrValues=null]
+   * @param {string|null} [namespace=null]
    */
   push(tagName, attrValues = null, namespace = null) {
     this._pathStringCache = null;
     if (this.path.length > 0) {
-      const prev = this.path[this.path.length - 1];
-      prev.values = void 0;
+      this.path[this.path.length - 1].values = void 0;
     }
     const currentLevel = this.path.length;
     if (!this.siblingStacks[currentLevel]) {
@@ -9343,13 +11085,11 @@ var Matcher = class {
     this.path.push(node);
   }
   /**
-   * Pop the last tag from the path
+   * Pop the last tag from the path.
    * @returns {Object|undefined} The popped node
    */
   pop() {
-    if (this.path.length === 0) {
-      return void 0;
-    }
+    if (this.path.length === 0) return void 0;
     this._pathStringCache = null;
     const node = this.path.pop();
     if (this.siblingStacks.length > this.path.length + 1) {
@@ -9358,9 +11098,9 @@ var Matcher = class {
     return node;
   }
   /**
-   * Update current node's attribute values
-   * Useful when attributes are parsed after push
-   * @param {Object} attrValues - Attribute values
+   * Update current node's attribute values.
+   * Useful when attributes are parsed after push.
+   * @param {Object} attrValues
    */
   updateCurrent(attrValues) {
     if (this.path.length > 0) {
@@ -9371,32 +11111,31 @@ var Matcher = class {
     }
   }
   /**
-   * Get current tag name
+   * Get current tag name.
    * @returns {string|undefined}
    */
   getCurrentTag() {
     return this.path.length > 0 ? this.path[this.path.length - 1].tag : void 0;
   }
   /**
-   * Get current namespace
+   * Get current namespace.
    * @returns {string|undefined}
    */
   getCurrentNamespace() {
     return this.path.length > 0 ? this.path[this.path.length - 1].namespace : void 0;
   }
   /**
-   * Get current node's attribute value
-   * @param {string} attrName - Attribute name
-   * @returns {*} Attribute value or undefined
+   * Get current node's attribute value.
+   * @param {string} attrName
+   * @returns {*}
    */
   getAttrValue(attrName) {
     if (this.path.length === 0) return void 0;
-    const current = this.path[this.path.length - 1];
-    return current.values?.[attrName];
+    return this.path[this.path.length - 1].values?.[attrName];
   }
   /**
-   * Check if current node has an attribute
-   * @param {string} attrName - Attribute name
+   * Check if current node has an attribute.
+   * @param {string} attrName
    * @returns {boolean}
    */
   hasAttr(attrName) {
@@ -9405,7 +11144,7 @@ var Matcher = class {
     return current.values !== void 0 && attrName in current.values;
   }
   /**
-   * Get current node's sibling position (child index in parent)
+   * Get current node's sibling position (child index in parent).
    * @returns {number}
    */
   getPosition() {
@@ -9413,7 +11152,7 @@ var Matcher = class {
     return this.path[this.path.length - 1].position ?? 0;
   }
   /**
-   * Get current node's repeat counter (occurrence count of this tag name)
+   * Get current node's repeat counter (occurrence count of this tag name).
    * @returns {number}
    */
   getCounter() {
@@ -9421,7 +11160,7 @@ var Matcher = class {
     return this.path[this.path.length - 1].counter ?? 0;
   }
   /**
-   * Get current node's sibling index (alias for getPosition for backward compatibility)
+   * Get current node's sibling index (alias for getPosition).
    * @returns {number}
    * @deprecated Use getPosition() or getCounter() instead
    */
@@ -9429,27 +11168,27 @@ var Matcher = class {
     return this.getPosition();
   }
   /**
-   * Get current path depth
+   * Get current path depth.
    * @returns {number}
    */
   getDepth() {
     return this.path.length;
   }
   /**
-   * Get path as string
-   * @param {string} separator - Optional separator (uses default if not provided)
-   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)
+   * Get path as string.
+   * @param {string} [separator] - Optional separator (uses default if not provided)
+   * @param {boolean} [includeNamespace=true]
    * @returns {string}
    */
   toString(separator, includeNamespace = true) {
     const sep = separator || this.separator;
     const isDefault = sep === this.separator && includeNamespace === true;
     if (isDefault) {
-      if (this._pathStringCache !== null && this._pathStringCache !== void 0) {
+      if (this._pathStringCache !== null) {
         return this._pathStringCache;
       }
       const result = this.path.map(
-        (n) => includeNamespace && n.namespace ? `${n.namespace}:${n.tag}` : n.tag
+        (n) => n.namespace ? `${n.namespace}:${n.tag}` : n.tag
       ).join(sep);
       this._pathStringCache = result;
       return result;
@@ -9459,14 +11198,14 @@ var Matcher = class {
     ).join(sep);
   }
   /**
-   * Get path as array of tag names
+   * Get path as array of tag names.
    * @returns {string[]}
    */
   toArray() {
     return this.path.map((n) => n.tag);
   }
   /**
-   * Reset the path to empty
+   * Reset the path to empty.
    */
   reset() {
     this._pathStringCache = null;
@@ -9474,9 +11213,9 @@ var Matcher = class {
     this.siblingStacks = [];
   }
   /**
-   * Match current path against an Expression
-   * @param {Expression} expression - The expression to match against
-   * @returns {boolean} True if current path matches the expression
+   * Match current path against an Expression.
+   * @param {Expression} expression
+   * @returns {boolean}
    */
   matches(expression) {
     const segments = expression.segments;
@@ -9489,7 +11228,6 @@ var Matcher = class {
     return this._matchSimple(segments);
   }
   /**
-   * Match simple path (no deep wildcards)
    * @private
    */
   _matchSimple(segments) {
@@ -9497,17 +11235,13 @@ var Matcher = class {
       return false;
     }
     for (let i = 0; i < segments.length; i++) {
-      const segment = segments[i];
-      const node = this.path[i];
-      const isCurrentNode = i === this.path.length - 1;
-      if (!this._matchSegment(segment, node, isCurrentNode)) {
+      if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) {
         return false;
       }
     }
     return true;
   }
   /**
-   * Match path with deep wildcards
    * @private
    */
   _matchWithDeepWildcard(segments) {
@@ -9523,8 +11257,7 @@ var Matcher = class {
         const nextSeg = segments[segIdx];
         let found = false;
         for (let i = pathIdx; i >= 0; i--) {
-          const isCurrentNode = i === this.path.length - 1;
-          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {
+          if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {
             pathIdx = i - 1;
             segIdx--;
             found = true;
@@ -9535,8 +11268,7 @@ var Matcher = class {
           return false;
         }
       } else {
-        const isCurrentNode = pathIdx === this.path.length - 1;
-        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {
+        if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) {
           return false;
         }
         pathIdx--;
@@ -9546,12 +11278,7 @@ var Matcher = class {
     return segIdx < 0;
   }
   /**
-   * Match a single segment against a node
    * @private
-   * @param {Object} segment - Segment from Expression
-   * @param {Object} node - Node from path
-   * @param {boolean} isCurrentNode - Whether this is the current (last) node
-   * @returns {boolean}
    */
   _matchSegment(segment, node, isCurrentNode) {
     if (segment.tag !== "*" && segment.tag !== node.tag) {
@@ -9570,8 +11297,7 @@ var Matcher = class {
         return false;
       }
       if (segment.attrValue !== void 0) {
-        const actualValue = node.values[segment.attrName];
-        if (String(actualValue) !== String(segment.attrValue)) {
+        if (String(node.values[segment.attrName]) !== String(segment.attrValue)) {
           return false;
         }
       }
@@ -9587,17 +11313,23 @@ var Matcher = class {
         return false;
       } else if (segment.position === "even" && counter % 2 !== 0) {
         return false;
-      } else if (segment.position === "nth") {
-        if (counter !== segment.positionValue) {
-          return false;
-        }
+      } else if (segment.position === "nth" && counter !== segment.positionValue) {
+        return false;
       }
     }
     return true;
   }
   /**
-   * Create a snapshot of current state
-   * @returns {Object} State snapshot
+   * Match any expression in the given set against the current path.
+   * @param {ExpressionSet} exprSet
+   * @returns {boolean}
+   */
+  matchesAny(exprSet) {
+    return exprSet.matchesAny(this);
+  }
+  /**
+   * Create a snapshot of current state.
+   * @returns {Object}
    */
   snapshot() {
     return {
@@ -9606,8 +11338,8 @@ var Matcher = class {
     };
   }
   /**
-   * Restore state from snapshot
-   * @param {Object} snapshot - State snapshot
+   * Restore state from snapshot.
+   * @param {Object} snapshot
    */
   restore(snapshot) {
     this._pathStringCache = null;
@@ -9615,68 +11347,27 @@ var Matcher = class {
     this.siblingStacks = snapshot.siblingStacks.map((map2) => new Map(map2));
   }
   /**
-   * Return a read-only view of this matcher.
+   * Return the read-only {@link MatcherView} for this matcher.
    *
-   * The returned object exposes all query/inspection methods but throws a
-   * TypeError if any state-mutating method is called (`push`, `pop`, `reset`,
-   * `updateCurrent`, `restore`).  Property reads (e.g. `.path`, `.separator`)
-   * are allowed but the returned arrays/objects are frozen so callers cannot
-   * mutate internal state through them either.
+   * The same instance is returned on every call — no allocation occurs.
+   * It always reflects the current parser state and is safe to pass to
+   * user callbacks without risk of accidental mutation.
    *
-   * @returns {ReadOnlyMatcher} A proxy that forwards read operations and blocks writes.
+   * @returns {MatcherView}
    *
    * @example
-   * const matcher = new Matcher();
-   * matcher.push("root", {});
-   *
-   * const ro = matcher.readOnly();
-   * ro.matches(expr);      // ✓ works
-   * ro.getCurrentTag();    // ✓ works
-   * ro.push("child", {}); // ✗ throws TypeError
-   * ro.reset();            // ✗ throws TypeError
+   * const view = matcher.readOnly();
+   * // pass view to callbacks — it stays in sync automatically
+   * view.matches(expr);       // ✓
+   * view.getCurrentTag();     // ✓
+   * // view.push(...)         // ✗ method does not exist — caught by TypeScript
    */
   readOnly() {
-    const self2 = this;
-    return new Proxy(self2, {
-      get(target, prop, receiver) {
-        if (MUTATING_METHODS.has(prop)) {
-          return () => {
-            throw new TypeError(
-              `Cannot call '${prop}' on a read-only Matcher. Obtain a writable instance to mutate state.`
-            );
-          };
-        }
-        const value = Reflect.get(target, prop, receiver);
-        if (prop === "path" || prop === "siblingStacks") {
-          return Object.freeze(
-            Array.isArray(value) ? value.map(
-              (item) => item instanceof Map ? Object.freeze(new Map(item)) : Object.freeze({ ...item })
-              // freeze a copy of each node
-            ) : value
-          );
-        }
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      },
-      // Prevent any property assignment on the read-only view
-      set(_target, prop) {
-        throw new TypeError(
-          `Cannot set property '${String(prop)}' on a read-only Matcher.`
-        );
-      },
-      // Prevent property deletion
-      deleteProperty(_target, prop) {
-        throw new TypeError(
-          `Cannot delete property '${String(prop)}' from a read-only Matcher.`
-        );
-      }
-    });
+    return this._view;
   }
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
 function extractRawAttributes(prefixedAttrs, options2) {
   if (!prefixedAttrs) return {};
   const attrs = options2.attributesGroupName ? prefixedAttrs[options2.attributesGroupName] : prefixedAttrs;
@@ -9704,36 +11395,10 @@ function extractNamespace(rawTagName) {
   return void 0;
 }
 var OrderedObjParser = class {
-  constructor(options2) {
+  constructor(options2, externalEntities) {
     this.options = options2;
     this.currentNode = null;
     this.tagsNodeStack = [];
-    this.docTypeEntities = {};
-    this.lastEntities = {
-      "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
-      "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
-      "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
-      "quot": { regex: /&(quot|#34|#x22);/g, val: '"' }
-    };
-    this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
-    this.htmlEntities = {
-      "space": { regex: /&(nbsp|#160);/g, val: " " },
-      // "lt" : { regex: /&(lt|#60);/g, val: "<" },
-      // "gt" : { regex: /&(gt|#62);/g, val: ">" },
-      // "amp" : { regex: /&(amp|#38);/g, val: "&" },
-      // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
-      // "apos" : { regex: /&(apos|#39);/g, val: "'" },
-      "cent": { regex: /&(cent|#162);/g, val: "\xA2" },
-      "pound": { regex: /&(pound|#163);/g, val: "\xA3" },
-      "yen": { regex: /&(yen|#165);/g, val: "\xA5" },
-      "euro": { regex: /&(euro|#8364);/g, val: "\u20AC" },
-      "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) => 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;
     this.parseTextData = parseTextData;
     this.resolveNameSpace = resolveNameSpace;
@@ -9746,52 +11411,61 @@ var OrderedObjParser = class {
     this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
     this.entityExpansionCount = 0;
     this.currentExpandedLength = 0;
+    let namedEntities = { ...XML };
+    if (this.options.entityDecoder) {
+      this.entityDecoder = this.options.entityDecoder;
+    } else {
+      if (typeof this.options.htmlEntities === "object") namedEntities = this.options.htmlEntities;
+      else if (this.options.htmlEntities === true) namedEntities = { ...COMMON_HTML, ...CURRENCY };
+      this.entityDecoder = new EntityDecoder({
+        namedEntities: { ...namedEntities, ...externalEntities },
+        numericAllowed: this.options.htmlEntities,
+        limit: {
+          maxTotalExpansions: this.options.processEntities.maxTotalExpansions,
+          maxExpandedLength: this.options.processEntities.maxExpandedLength,
+          applyLimitsTo: this.options.processEntities.appliesTo
+        }
+        //postCheck: resolved => resolved
+      });
+    }
     this.matcher = new Matcher();
     this.readonlyMatcher = this.matcher.readOnly();
     this.isCurrentNodeStopNode = false;
-    if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-      this.stopNodeExpressions = [];
-      for (let i = 0; i < this.options.stopNodes.length; i++) {
-        const stopNodeExp = this.options.stopNodes[i];
+    this.stopNodeExpressionsSet = new ExpressionSet();
+    const stopNodesOpts = this.options.stopNodes;
+    if (stopNodesOpts && stopNodesOpts.length > 0) {
+      for (let i = 0; i < stopNodesOpts.length; i++) {
+        const stopNodeExp = stopNodesOpts[i];
         if (typeof stopNodeExp === "string") {
-          this.stopNodeExpressions.push(new Expression(stopNodeExp));
+          this.stopNodeExpressionsSet.add(new Expression(stopNodeExp));
         } else if (stopNodeExp instanceof Expression) {
-          this.stopNodeExpressions.push(stopNodeExp);
+          this.stopNodeExpressionsSet.add(stopNodeExp);
         }
       }
+      this.stopNodeExpressionsSet.seal();
     }
   }
 };
-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("&" + escaped + ";", "g"),
-      val: externalEntities[ent]
-    };
-  }
-}
 function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+  const options2 = this.options;
   if (val !== void 0) {
-    if (this.options.trimValues && !dontTrim) {
+    if (options2.trimValues && !dontTrim) {
       val = val.trim();
     }
     if (val.length > 0) {
       if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
-      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
+      const jPathOrMatcher = options2.jPath ? jPath.toString() : jPath;
+      const newval = options2.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
       if (newval === null || newval === void 0) {
         return val;
       } else if (typeof newval !== typeof val || newval !== val) {
         return newval;
-      } else if (this.options.trimValues) {
-        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+      } else if (options2.trimValues) {
+        return parseValue(val, options2.parseTagValue, options2.numberParseOptions);
       } else {
         const trimmedVal = val.trim();
         if (trimmedVal === val) {
-          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+          return parseValue(val, options2.parseTagValue, options2.numberParseOptions);
         } else {
           return val;
         }
@@ -9813,8 +11487,9 @@ function resolveNameSpace(tagname) {
   return tagname;
 }
 var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
-function buildAttributesMap(attrStr, jPath, tagName) {
-  if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
+function buildAttributesMap(attrStr, jPath, tagName, force = false) {
+  const options2 = this.options;
+  if (force === true || options2.ignoreAttributes !== true && typeof attrStr === "string") {
     const matches = getAllMatches(attrStr, attrsRegx);
     const len = matches.length;
     const attrs = {};
@@ -9826,7 +11501,7 @@ function buildAttributesMap(attrStr, jPath, tagName) {
       const oldVal = matches[i][4];
       if (attrName.length && oldVal !== void 0) {
         let val = oldVal;
-        if (this.options.trimValues) val = val.trim();
+        if (options2.trimValues) val = val.trim();
         val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
         processedVals[i] = val;
         rawAttrsForMatcher[attrName] = val;
@@ -9836,38 +11511,38 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     if (hasRawAttrs && typeof jPath === "object" && jPath.updateCurrent) {
       jPath.updateCurrent(rawAttrsForMatcher);
     }
-    const jPathStr = this.options.jPath ? jPath.toString() : this.readonlyMatcher;
+    const jPathStr = options2.jPath ? jPath.toString() : this.readonlyMatcher;
     let hasAttrs = false;
     for (let i = 0; i < len; i++) {
       const attrName = this.resolveNameSpace(matches[i][1]);
       if (this.ignoreAttributesFn(attrName, jPathStr)) continue;
-      let aName = this.options.attributeNamePrefix + attrName;
+      let aName = options2.attributeNamePrefix + attrName;
       if (attrName.length) {
-        if (this.options.transformAttributeName) {
-          aName = this.options.transformAttributeName(aName);
+        if (options2.transformAttributeName) {
+          aName = options2.transformAttributeName(aName);
         }
-        aName = sanitizeName(aName, this.options);
+        aName = sanitizeName(aName, options2);
         if (matches[i][4] !== void 0) {
           const oldVal = processedVals[i];
-          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathStr);
+          const newVal = options2.attributeValueProcessor(attrName, oldVal, jPathStr);
           if (newVal === null || newVal === void 0) {
             attrs[aName] = oldVal;
           } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
             attrs[aName] = newVal;
           } else {
-            attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
+            attrs[aName] = parseValue(oldVal, options2.parseAttributeValue, options2.numberParseOptions);
           }
           hasAttrs = true;
-        } else if (this.options.allowBooleanAttributes) {
+        } else if (options2.allowBooleanAttributes) {
           attrs[aName] = true;
           hasAttrs = true;
         }
       }
     }
     if (!hasAttrs) return;
-    if (this.options.attributesGroupName) {
+    if (options2.attributesGroupName && !options2.preserveOrder) {
       const attrCollection = {};
-      attrCollection[this.options.attributesGroupName] = attrs;
+      attrCollection[options2.attributesGroupName] = attrs;
       return attrCollection;
     }
     return attrs;
@@ -9879,30 +11554,34 @@ var parseXml = function(xmlData) {
   let currentNode = xmlObj;
   let textData = "";
   this.matcher.reset();
+  this.entityDecoder.reset();
   this.entityExpansionCount = 0;
   this.currentExpandedLength = 0;
-  const docTypeReader = new DocTypeReader(this.options.processEntities);
-  for (let i = 0; i < xmlData.length; i++) {
+  const options2 = this.options;
+  const docTypeReader = new DocTypeReader(options2.processEntities);
+  const xmlLen = xmlData.length;
+  for (let i = 0; i < xmlLen; i++) {
     const ch = xmlData[i];
     if (ch === "<") {
-      if (xmlData[i + 1] === "/") {
+      const c1 = xmlData.charCodeAt(i + 1);
+      if (c1 === 47) {
         const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
         let tagName = xmlData.substring(i + 2, closeIndex).trim();
-        if (this.options.removeNSPrefix) {
+        if (options2.removeNSPrefix) {
           const colonIndex = tagName.indexOf(":");
           if (colonIndex !== -1) {
             tagName = tagName.substr(colonIndex + 1);
           }
         }
-        tagName = transformTagName(this.options.transformTagName, tagName, "", this.options).tagName;
+        tagName = transformTagName(options2.transformTagName, tagName, "", options2).tagName;
         if (currentNode) {
           textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
         }
         const lastTagName = this.matcher.getCurrentTag();
-        if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+        if (tagName && options2.unpairedTagsSet.has(tagName)) {
           throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
         }
-        if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
+        if (lastTagName && options2.unpairedTagsSet.has(lastTagName)) {
           this.matcher.pop();
           this.tagsNodeStack.pop();
         }
@@ -9911,48 +11590,53 @@ var parseXml = function(xmlData) {
         currentNode = this.tagsNodeStack.pop();
         textData = "";
         i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
+      } else if (c1 === 63) {
         let tagData = readTagExp(xmlData, i, false, "?>");
         if (!tagData) throw new Error("Pi Tag is not closed.");
         textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-        if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {
+        const attsMap = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName, true);
+        if (attsMap) {
+          const ver = attsMap[this.options.attributeNamePrefix + "version"];
+          this.entityDecoder.setXmlVersion(Number(ver) || 1);
+        }
+        if (options2.ignoreDeclaration && tagData.tagName === "?xml" || options2.ignorePiTags) {
         } else {
           const childNode = new XmlNode(tagData.tagName);
-          childNode.add(this.options.textNodeName, "");
-          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
-            childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
+          childNode.add(options2.textNodeName, "");
+          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent && options2.ignoreAttributes !== true) {
+            childNode[":@"] = attsMap;
           }
           this.addChild(currentNode, childNode, this.readonlyMatcher, i);
         }
         i = tagData.closeIndex + 1;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
+      } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) {
         const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
-        if (this.options.commentPropName) {
+        if (options2.commentPropName) {
           const comment = xmlData.substring(i + 4, endIndex - 2);
           textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-          currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
+          currentNode.add(options2.commentPropName, [{ [options2.textNodeName]: comment }]);
         }
         i = endIndex;
-      } else if (xmlData.substr(i + 1, 2) === "!D") {
+      } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 68) {
         const result = docTypeReader.readDocType(xmlData, i);
-        this.docTypeEntities = result.entities;
+        this.entityDecoder.addInputEntities(result.entities);
         i = result.i;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
+      } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
         const tagExp = xmlData.substring(i + 9, closeIndex);
         textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
         let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);
         if (val == void 0) val = "";
-        if (this.options.cdataPropName) {
-          currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
+        if (options2.cdataPropName) {
+          currentNode.add(options2.cdataPropName, [{ [options2.textNodeName]: tagExp }]);
         } else {
-          currentNode.add(this.options.textNodeName, val);
+          currentNode.add(options2.textNodeName, val);
         }
         i = closeIndex + 2;
       } else {
-        let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+        let result = readTagExp(xmlData, i, options2.removeNSPrefix);
         if (!result) {
-          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));
+          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlLen, i + 50));
           throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
         }
         let tagName = result.tagName;
@@ -9960,8 +11644,8 @@ var parseXml = function(xmlData) {
         let tagExp = result.tagExp;
         let attrExpPresent = result.attrExpPresent;
         let closeIndex = result.closeIndex;
-        ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
-        if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName || tagName === this.options.textNodeName || tagName === this.options.attributesGroupName)) {
+        ({ tagName, tagExp } = transformTagName(options2.transformTagName, tagName, tagExp, options2));
+        if (options2.strictReservedNames && (tagName === options2.commentPropName || tagName === options2.cdataPropName || tagName === options2.textNodeName || tagName === options2.attributesGroupName)) {
           throw new Error(`Invalid tag name: ${tagName}`);
         }
         if (currentNode && textData) {
@@ -9970,7 +11654,7 @@ var parseXml = function(xmlData) {
           }
         }
         const lastTag = currentNode;
-        if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
+        if (lastTag && options2.unpairedTagsSet.has(lastTag.tagname)) {
           currentNode = this.tagsNodeStack.pop();
           this.matcher.pop();
         }
@@ -9995,18 +11679,18 @@ var parseXml = function(xmlData) {
         if (tagName !== tagExp && attrExpPresent) {
           prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
           if (prefixedAttrs) {
-            rawAttrs = extractRawAttributes(prefixedAttrs, this.options);
+            rawAttrs = extractRawAttributes(prefixedAttrs, options2);
           }
         }
         if (tagName !== xmlObj.tagname) {
-          this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);
+          this.isCurrentNodeStopNode = this.isItStopNode();
         }
         const startIndex = i;
         if (this.isCurrentNodeStopNode) {
           let tagContent = "";
           if (isSelfClosing) {
             i = result.closeIndex;
-          } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+          } else if (options2.unpairedTagsSet.has(tagName)) {
             i = result.closeIndex;
           } else {
             const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
@@ -10018,13 +11702,13 @@ var parseXml = function(xmlData) {
           if (prefixedAttrs) {
             childNode[":@"] = prefixedAttrs;
           }
-          childNode.add(this.options.textNodeName, tagContent);
+          childNode.add(options2.textNodeName, tagContent);
           this.matcher.pop();
           this.isCurrentNodeStopNode = false;
           this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
         } else {
           if (isSelfClosing) {
-            ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
+            ({ tagName, tagExp } = transformTagName(options2.transformTagName, tagName, tagExp, options2));
             const childNode = new XmlNode(tagName);
             if (prefixedAttrs) {
               childNode[":@"] = prefixedAttrs;
@@ -10032,7 +11716,7 @@ var parseXml = function(xmlData) {
             this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
             this.matcher.pop();
             this.isCurrentNodeStopNode = false;
-          } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+          } else if (options2.unpairedTagsSet.has(tagName)) {
             const childNode = new XmlNode(tagName);
             if (prefixedAttrs) {
               childNode[":@"] = prefixedAttrs;
@@ -10044,7 +11728,7 @@ var parseXml = function(xmlData) {
             continue;
           } else {
             const childNode = new XmlNode(tagName);
-            if (this.tagsNodeStack.length > this.options.maxNestedTags) {
+            if (this.tagsNodeStack.length > options2.maxNestedTags) {
               throw new Error("Maximum nested tags exceeded");
             }
             this.tagsNodeStack.push(currentNode);
@@ -10094,60 +11778,7 @@ function replaceEntitiesValue(val, tagName, jPath) {
       return val;
     }
   }
-  for (const entityName of Object.keys(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 (const entityName of Object.keys(this.lastEntities)) {
-    const entity = this.lastEntities[entityName];
-    const matches = val.match(entity.regex);
-    if (matches) {
-      this.entityExpansionCount += matches.length;
-      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
-        throw new Error(
-          `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
-        );
-      }
-    }
-    val = val.replace(entity.regex, entity.val);
-  }
-  if (val.indexOf("&") === -1) return val;
-  if (this.options.htmlEntities) {
-    for (const entityName of Object.keys(this.htmlEntities)) {
-      const entity = this.htmlEntities[entityName];
-      const matches = val.match(entity.regex);
-      if (matches) {
-        this.entityExpansionCount += matches.length;
-        if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
-          throw new Error(
-            `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
-          );
-        }
-      }
-      val = val.replace(entity.regex, entity.val);
-    }
-  }
-  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
-  return val;
+  return this.entityDecoder.decode(val);
 }
 function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
   if (textData) {
@@ -10166,42 +11797,37 @@ function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
   }
   return textData;
 }
-function isItStopNode(stopNodeExpressions, matcher) {
-  if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;
-  for (let i = 0; i < stopNodeExpressions.length; i++) {
-    if (matcher.matches(stopNodeExpressions[i])) {
-      return true;
-    }
-  }
-  return false;
+function isItStopNode() {
+  if (this.stopNodeExpressionsSet.size === 0) return false;
+  return this.matcher.matchesAny(this.stopNodeExpressionsSet);
 }
 function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
-  let attrBoundary;
-  let tagExp = "";
-  for (let index = i; index < xmlData.length; index++) {
-    let ch = xmlData[index];
+  let attrBoundary = 0;
+  const len = xmlData.length;
+  const closeCode0 = closingChar.charCodeAt(0);
+  const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;
+  let result = "";
+  let segmentStart = i;
+  for (let index = i; index < len; index++) {
+    const code = xmlData.charCodeAt(index);
     if (attrBoundary) {
-      if (ch === attrBoundary) attrBoundary = "";
-    } else if (ch === '"' || ch === "'") {
-      attrBoundary = ch;
-    } else if (ch === closingChar[0]) {
-      if (closingChar[1]) {
-        if (xmlData[index + 1] === closingChar[1]) {
-          return {
-            data: tagExp,
-            index
-          };
+      if (code === attrBoundary) attrBoundary = 0;
+    } else if (code === 34 || code === 39) {
+      attrBoundary = code;
+    } else if (code === closeCode0) {
+      if (closeCode1 !== -1) {
+        if (xmlData.charCodeAt(index + 1) === closeCode1) {
+          result += xmlData.substring(segmentStart, index);
+          return { data: result, index };
         }
       } else {
-        return {
-          data: tagExp,
-          index
-        };
+        result += xmlData.substring(segmentStart, index);
+        return { data: result, index };
       }
-    } else if (ch === "	") {
-      ch = " ";
+    } else if (code === 9 && !attrBoundary) {
+      result += xmlData.substring(segmentStart, index) + " ";
+      segmentStart = index + 1;
     }
-    tagExp += ch;
   }
 }
 function findClosingIndex(xmlData, str, i, errMsg) {
@@ -10212,6 +11838,11 @@ function findClosingIndex(xmlData, str, i, errMsg) {
     return closingIndex + str.length - 1;
   }
 }
+function findClosingChar(xmlData, char, i, errMsg) {
+  const closingIndex = xmlData.indexOf(char, i);
+  if (closingIndex === -1) throw new Error(errMsg);
+  return closingIndex;
+}
 function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
   const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
   if (!result) return;
@@ -10243,10 +11874,12 @@ function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
 function readStopNodeData(xmlData, tagName, i) {
   const startIndex = i;
   let openTagCount = 1;
-  for (; i < xmlData.length; i++) {
+  const xmllen = xmlData.length;
+  for (; i < xmllen; i++) {
     if (xmlData[i] === "<") {
-      if (xmlData[i + 1] === "/") {
-        const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
+      const c1 = xmlData.charCodeAt(i + 1);
+      if (c1 === 47) {
+        const closeIndex = findClosingChar(xmlData, ">", i, `${tagName} is not closed`);
         let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
         if (closeTagName === tagName) {
           openTagCount--;
@@ -10258,13 +11891,13 @@ function readStopNodeData(xmlData, tagName, i) {
           }
         }
         i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
+      } else if (c1 === 63) {
         const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
         i = closeIndex;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
+      } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) {
         const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
         i = closeIndex;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
+      } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
         i = closeIndex;
       } else {
@@ -10294,14 +11927,6 @@ 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 + ";";
-  }
-}
 function transformTagName(fn, tagName, tagExp, options2) {
   if (fn) {
     const newTagName = fn(tagName);
@@ -10322,7 +11947,7 @@ function sanitizeName(name, options2) {
   return name;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/node2json.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/node2json.js
 var METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
 function stripAttributePrefix(attrs, prefix) {
   if (!attrs || typeof attrs !== "object") return {};
@@ -10431,7 +12056,7 @@ function isLeafTag(obj, options2) {
   return false;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.10-cb09c65a3d-ac48edff66.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.7.2-960de42682-7f32d77127.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
 var XMLParser = class {
   constructor(options2) {
     this.externalEntities = {};
@@ -10455,8 +12080,7 @@ var XMLParser = class {
         throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
       }
     }
-    const orderedObjParser = new OrderedObjParser(this.options);
-    orderedObjParser.addExternalEntities(this.externalEntities);
+    const orderedObjParser = new OrderedObjParser(this.options, this.externalEntities);
     const orderedResult = orderedObjParser.parseXml(xmlData);
     if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
     else return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
@@ -11113,13 +12737,22 @@ var DependencyManager = class _DependencyManager {
     return this.config.noNamespace ? `import type * as ${namespace} from '${importPath}'` : `import type ${namespace} from '${importPath}';`;
   }
   createPackageJsonImport(importPath, libraryVersion) {
+    const pinnedVersion = libraryVersion ? `${libraryVersion.toString()}-${APP_VERSION}` : APP_VERSION;
+    const format = this.config.depVersionFormat ?? (this.config.workspace ? "workspace" : "exact");
     let depVersion;
-    if (this.config.workspace) {
-      depVersion = "workspace:^";
-    } else if (libraryVersion) {
-      depVersion = `${libraryVersion.toString()}-${APP_VERSION}`;
-    } else {
-      depVersion = APP_VERSION;
+    switch (format) {
+      case "workspace":
+        depVersion = "workspace:^";
+        break;
+      case "caret":
+        depVersion = `^${pinnedVersion}`;
+        break;
+      case "any":
+        depVersion = "*";
+        break;
+      default:
+        depVersion = pinnedVersion;
+        break;
     }
     return `"${importPath}": "${depVersion}"`;
   }
@@ -15202,16 +16835,16 @@ function transformBacktickTypeRefs(text, ctx) {
   });
   return text;
 }
-function transformGirDocHighlights(description7) {
-  return description7.replace(/(?<!\{)(?<!\w)@([A-Za-z_][A-Za-z0-9_]*)/g, "`$1`");
+function transformGirDocHighlights(description8) {
+  return description8.replace(/(?<!\{)(?<!\w)@([A-Za-z_][A-Za-z0-9_]*)/g, "`$1`");
 }
-function transformGirDocCodeBlocks(description7) {
-  description7 = description7.replaceAll(/```\s*\{\s*\.(\w+)[^}]*\}/gm, "```$1").replaceAll(/\|\[<!-- language="([^"]+)" -->/gm, (_match, lang) => {
+function transformGirDocCodeBlocks(description8) {
+  description8 = description8.replaceAll(/```\s*\{\s*\.(\w+)[^}]*\}/gm, "```$1").replaceAll(/\|\[<!-- language="([^"]+)" -->/gm, (_match, lang) => {
     if (lang === "plain" || lang === "text") return "\n```";
     return `
 \`\`\`${lang.toLowerCase()}`;
   }).replaceAll(/\|\[/gm, "\n```").replaceAll(/\]\|/gm, "```\n");
-  return description7;
+  return description8;
 }
 
 // ../lib/src/utils/objects.ts
@@ -19505,6 +21138,11 @@ var options = {
     default: defaults.workspace,
     normalize: true
   },
+  depVersionFormat: {
+    type: "string",
+    description: "Dependency version spec format in generated package.json files. Defaults to 'workspace' when --workspace, else 'exact'",
+    choices: ["workspace", "caret", "any", "exact"]
+  },
   onlyVersionPrefix: {
     type: "boolean",
     description: "Only use the version prefix for the ambient module exports. This is useful if, for whatever reason, you want to use different library versions of the same library in your project.",
@@ -19557,6 +21195,7 @@ var generateOptions = {
   promisify: options.promisify,
   npmScope: options.npmScope,
   workspace: options.workspace,
+  depVersionFormat: options.depVersionFormat,
   onlyVersionPrefix: options.onlyVersionPrefix,
   noPrettyPrint: options.noPrettyPrint,
   noAdvancedVariants: options.noAdvancedVariants,
@@ -19612,6 +21251,25 @@ var docOptions = {
     description: "Directory containing pre-generated TypeDoc JSON files for merge mode (from 'ts-for-gir json')"
   }
 };
+var createOptions = {
+  template: {
+    type: "string",
+    alias: "t",
+    description: "Template to scaffold (types-locally, types-npm, types-workspace)",
+    choices: ["types-locally", "types-npm", "types-workspace"]
+  },
+  install: {
+    type: "boolean",
+    description: "Run npm install after scaffolding (use --no-install to skip)",
+    default: true
+  },
+  force: {
+    type: "boolean",
+    description: "Allow scaffolding into a non-empty target directory",
+    default: false
+  },
+  verbose: options.verbose
+};
 var analyzeOptions = {
   reportFile: {
     type: "string",
@@ -19778,6 +21436,7 @@ async function load(cliOptions) {
     const stringKeys = [
       ["npmScope", options.npmScope.default],
       ["reporterOutput", options.reporterOutput.default],
+      ["depVersionFormat", void 0],
       ["theme", docOptions.theme.default],
       ["sourceLinkTemplate", void 0],
       ["readme", void 0],
@@ -19816,13 +21475,13 @@ async function load(cliOptions) {
 }
 
 // src/commands/command-builder.ts
-function createBuilder(options2, examples7) {
+function createBuilder(options2, examples8) {
   return (yargs2) => {
     const optionNames = Object.keys(options2);
     for (const optionName of optionNames) {
       yargs2 = yargs2.option(optionName, options2[optionName]);
     }
-    return yargs2.example(examples7);
+    return yargs2.example(examples8);
   };
 }
 
@@ -20643,9 +22302,184 @@ var copy = {
   examples: examples2
 };
 
+// src/commands/create.ts
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname6, join as join9, resolve as resolve5 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { input, select as select2 } from "@inquirer/prompts";
+var command3 = "create [name]";
+var description3 = "Scaffold a new GJS TypeScript project from a template";
+var examples3 = [
+  [`${APP_NAME} create my-app --template types-npm`, "Scaffold using the @girs/* NPM types"],
+  [`${APP_NAME} create my-app --template types-locally`, "Scaffold and generate types into ./@types/ locally"],
+  [
+    `${APP_NAME} create my-app --template types-workspace`,
+    "Scaffold an npm workspace with types as workspace packages"
+  ],
+  [`${APP_NAME} create`, "Interactive: prompts for name and template"]
+];
+var TEMPLATE_CHOICES = [
+  {
+    value: "types-locally",
+    name: "types-locally",
+    description: "Generate GIR types directly into ./@types/ (no package format, no @girs/* deps)"
+  },
+  {
+    value: "types-npm",
+    name: "types-npm",
+    description: "Use pre-generated types from the @girs/* NPM packages"
+  },
+  {
+    value: "types-workspace",
+    name: "types-workspace",
+    description: "npm workspace; generate @girs/* as workspace packages under ./@girs/"
+  }
+];
+var PROJECT_NAME_PLACEHOLDER = "__PROJECT_NAME__";
+var TEXT_FILE_EXT = /* @__PURE__ */ new Set([".json", ".md", ".ts", ".tsx", ".js", ".mjs", ".cjs"]);
+var builder3 = createBuilder(createOptions, examples3);
+function findTemplatesRoot() {
+  const __filename2 = fileURLToPath4(import.meta.url);
+  const __dirname3 = dirname6(__filename2);
+  const candidates = [
+    // Bundled production binary (bin/ts-for-gir): ../dist-templates
+    resolve5(__dirname3, "..", "dist-templates"),
+    // Source layout (src/commands/create.ts): ../../dist-templates then ../../templates
+    resolve5(__dirname3, "..", "..", "dist-templates"),
+    resolve5(__dirname3, "..", "..", "templates")
+  ];
+  for (const path of candidates) {
+    if (existsSync3(path)) return path;
+  }
+  throw new Error(
+    `Could not locate templates directory. Looked in:
+  ${candidates.join("\n  ")}
+If you are running from source, make sure packages/cli/templates/ exists. If you are running the published CLI, make sure dist-templates/ was packed.`
+  );
+}
+function listTemplates(templatesRoot) {
+  const knownIds = TEMPLATE_CHOICES.map((c) => c.value);
+  return readdirSync(templatesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => knownIds.includes(name));
+}
+function sanitizeProjectName(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) throw new Error("Project name cannot be empty");
+  const cleaned = trimmed.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+/, "").replace(/[._-]+$/, "");
+  if (!cleaned) throw new Error(`"${raw}" is not a valid npm package name`);
+  return cleaned;
+}
+function isDirEmpty(path) {
+  if (!existsSync3(path)) return true;
+  return readdirSync(path).length === 0;
+}
+function substituteInFile(filePath, projectName) {
+  const content = readFileSync4(filePath, "utf8");
+  if (!content.includes(PROJECT_NAME_PLACEHOLDER)) return;
+  writeFileSync2(filePath, content.replaceAll(PROJECT_NAME_PLACEHOLDER, projectName));
+}
+function walkAndSubstitute(rootDir, projectName) {
+  for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
+    const full = join9(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules") continue;
+      walkAndSubstitute(full, projectName);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const ext = entry.name.slice(entry.name.lastIndexOf("."));
+    if (!TEXT_FILE_EXT.has(ext)) continue;
+    substituteInFile(full, projectName);
+  }
+}
+var handler3 = async (args) => {
+  const opts = args;
+  const log3 = new Logger(opts.verbose ?? false, "CreateCommand");
+  const templatesRoot = findTemplatesRoot();
+  const available = listTemplates(templatesRoot);
+  if (available.length === 0) {
+    throw new Error(`No templates found in ${templatesRoot}`);
+  }
+  let template2 = opts.template;
+  if (template2 && !available.includes(template2)) {
+    throw new Error(`Unknown template "${template2}". Available: ${available.join(", ")}`);
+  }
+  if (!template2) {
+    if (!process.stdin.isTTY) {
+      throw new Error(`--template is required (non-TTY). Available: ${available.join(", ")}`);
+    }
+    template2 = await select2({
+      message: "Choose a template:",
+      choices: TEMPLATE_CHOICES.filter((c) => available.includes(c.value)).map((c) => ({
+        value: c.value,
+        name: c.name,
+        description: c.description
+      }))
+    });
+  }
+  let nameRaw = opts.name;
+  if (!nameRaw) {
+    if (!process.stdin.isTTY) {
+      throw new Error("Project name is required (non-TTY). Pass it as the first positional argument.");
+    }
+    nameRaw = await input({
+      message: "Project name:",
+      default: "my-gjs-app",
+      validate: (v) => v.trim().length > 0 ? true : "Project name cannot be empty"
+    });
+  }
+  const projectName = sanitizeProjectName(nameRaw);
+  const targetDir = resolve5(process.cwd(), projectName);
+  if (existsSync3(targetDir) && !isDirEmpty(targetDir) && !opts.force) {
+    throw new Error(
+      `Target directory ${targetDir} exists and is not empty. Use --force to scaffold into a non-empty directory.`
+    );
+  }
+  mkdirSync(targetDir, { recursive: true });
+  const templateDir = join9(templatesRoot, template2);
+  cpSync(templateDir, targetDir, { recursive: true });
+  walkAndSubstitute(targetDir, projectName);
+  log3.success(`Scaffolded ${template2} into ${targetDir}`);
+  if (opts.install) {
+    log3.info("Running npm install...");
+    const result = spawnSync("npm", ["install", "--no-audit", "--no-fund"], {
+      cwd: targetDir,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      log3.warn("npm install failed; you can re-run it manually in the project directory.");
+    }
+  }
+  log3.info("\nNext steps:");
+  log3.white(`  cd ${projectName}`);
+  if (!opts.install) log3.white("  npm install");
+  switch (template2) {
+    case "types-locally":
+      log3.white("  npm run generate");
+      log3.white("  npm run check:types");
+      log3.white("  npm run build && npm start");
+      break;
+    case "types-npm":
+      log3.white("  npm run check");
+      log3.white("  npm run build && npm start");
+      break;
+    case "types-workspace":
+      log3.white("  npm run build:types && npm install");
+      log3.white("  npm run build:app && npm start");
+      break;
+  }
+};
+var create = {
+  command: command3,
+  description: description3,
+  builder: builder3,
+  handler: handler3,
+  examples: examples3
+};
+
 // ../generator-html-doc/src/html-doc-generator.ts
 import { mkdir as mkdir4 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // ../generator-json/src/gir-metadata-deserializer.ts
 import { DeclarationReflection } from "typedoc";
@@ -20671,16 +22505,16 @@ var GirMetadataDeserializer = class {
 
 // ../generator-json/src/json-definition-generator.ts
 import { mkdir as mkdir3, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // ../generator-json/src/typedoc-pipeline.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // ../generator-typescript/src/template-processor.ts
-import { dirname as dirname6, join as join9, relative } from "node:path";
+import { dirname as dirname7, join as join10, relative } from "node:path";
 var TemplateProcessor = class extends TemplateEngine {
   data;
   packageName;
@@ -20710,8 +22544,8 @@ var TemplateProcessor = class extends TemplateEngine {
       dep,
       deps,
       typeDir,
-      join: join9,
-      dirname: dirname6,
+      join: join10,
+      dirname: dirname7,
       ...this.config,
       packageName: this.packageName
     };
@@ -20781,10 +22615,10 @@ ${append}`;
     const rendered = await this.loadAll(templateDirname, fileExtension, ejsOptions, overrideTemplateData);
     const result = {};
     for (const filename of Object.keys(rendered)) {
-      const destPath = join9(baseOutputPath, outputDirname, filename);
+      const destPath = join10(baseOutputPath, outputDirname, filename);
       result[destPath] = `${rendered[filename]}
 ${append}`;
-      await this.write(result[destPath], baseOutputPath, join9(outputDirname, filename));
+      await this.write(result[destPath], baseOutputPath, join10(outputDirname, filename));
     }
     return result;
   }
@@ -20793,8 +22627,8 @@ ${append}`;
    * This is TypeScript-specific logic for handling package.json mode
    */
   getOutputPath(baseOutputPath, outputFilename) {
-    const filePath = this.config.package ? join9(this.data?.importName || this.packageName, outputFilename) : outputFilename;
-    const outputPath = join9(baseOutputPath, filePath);
+    const filePath = this.config.package ? join10(this.data?.importName || this.packageName, outputFilename) : outputFilename;
+    const outputPath = join10(baseOutputPath, filePath);
     return outputPath;
   }
   /**
@@ -24053,9 +25887,9 @@ var GirMetadataSerializer = class _GirMetadataSerializer {
     [IntrospectedAlias, (s, o) => s.buildBaseMetadata(o, "alias")]
   ];
   buildMetadata(girObj) {
-    for (const [ctor, handler7] of _GirMetadataSerializer.METADATA_DISPATCH) {
+    for (const [ctor, handler8] of _GirMetadataSerializer.METADATA_DISPATCH) {
       if (girObj instanceof ctor) {
-        return handler7(this, girObj);
+        return handler8(this, girObj);
       }
     }
     return null;
@@ -24180,7 +26014,7 @@ var TypeDocPipeline = class {
     return this._modules;
   }
   async start() {
-    this.tempDir = await mkdtemp(join10(tmpdir(), "ts-for-gir-typedoc-"));
+    this.tempDir = await mkdtemp(join11(tmpdir(), "ts-for-gir-typedoc-"));
     const tempConfig = {
       ...this.config,
       outdir: this.tempDir,
@@ -24207,10 +26041,10 @@ var TypeDocPipeline = class {
    * convert to ProjectReflection, and enrich with GIR metadata.
    */
   async createTypeDocApp(module) {
-    const moduleDir = join10(this.tempDir, module.importName);
-    const entryPoint = join10(moduleDir, `${module.importName}.d.ts`);
-    const tsconfigPath = join10(moduleDir, "tsconfig.json");
-    const readmePath = join10(moduleDir, "README.md");
+    const moduleDir = join11(this.tempDir, module.importName);
+    const entryPoint = join11(moduleDir, `${module.importName}.d.ts`);
+    const tsconfigPath = join11(moduleDir, "tsconfig.json");
+    const readmePath = join11(moduleDir, "README.md");
     const result = await this.bootstrapAndConvert(
       {
         entryPoints: [entryPoint],
@@ -24236,13 +26070,13 @@ var TypeDocPipeline = class {
    * Useful for TypeDoc's `projectToObject()` base path.
    */
   getModuleDir(module) {
-    return normalizePath(join10(this.tempDir, module.importName));
+    return normalizePath(join11(this.tempDir, module.importName));
   }
   /**
    * Get the normalized path to the GJS package temporary directory.
    */
   getGjsDir() {
-    return normalizePath(join10(this.tempDir, "gjs"));
+    return normalizePath(join11(this.tempDir, "gjs"));
   }
   /**
    * Bootstrap a TypeDoc Application for the GJS core types package.
@@ -24255,16 +26089,16 @@ var TypeDocPipeline = class {
    * Returns null if the GJS package was not generated (e.g. temp dir missing).
    */
   async createGjsTypeDocApp() {
-    const gjsDir = join10(this.tempDir, "gjs");
-    const tsconfigPath = join10(gjsDir, "tsconfig.json");
-    const readmePath = join10(gjsDir, "README.md");
+    const gjsDir = join11(this.tempDir, "gjs");
+    const tsconfigPath = join11(gjsDir, "tsconfig.json");
+    const readmePath = join11(gjsDir, "README.md");
     const entryPoints = [
-      join10(gjsDir, "gjs.d.ts"),
-      join10(gjsDir, "cairo.d.ts"),
-      join10(gjsDir, "gettext.d.ts"),
-      join10(gjsDir, "system.d.ts"),
-      join10(gjsDir, "dom.d.ts"),
-      join10(gjsDir, "console.d.ts")
+      join11(gjsDir, "gjs.d.ts"),
+      join11(gjsDir, "cairo.d.ts"),
+      join11(gjsDir, "gettext.d.ts"),
+      join11(gjsDir, "system.d.ts"),
+      join11(gjsDir, "dom.d.ts"),
+      join11(gjsDir, "console.d.ts")
     ];
     try {
       const result = await this.bootstrapAndConvert(
@@ -24293,7 +26127,7 @@ var TypeDocPipeline = class {
   async createCombinedTypeDocApp() {
     const result = await this.bootstrapAndConvert(
       {
-        entryPoints: [join10(this.tempDir, "*")],
+        entryPoints: [join11(this.tempDir, "*")],
         entryPointStrategy: "packages",
         name: "TypeScript API Documentation for GJS",
         ...this.sourceLinkOptions,
@@ -24319,7 +26153,7 @@ var TypeDocPipeline = class {
   async createMergedTypeDocApp(jsonDir) {
     const app = await this.bootstrapApp(
       {
-        entryPoints: [join10(jsonDir, "*.json")],
+        entryPoints: [join11(jsonDir, "*.json")],
         entryPointStrategy: "merge",
         name: "TypeScript API Documentation for GJS"
       },
@@ -24688,7 +26522,7 @@ var TypeDocPipeline = class {
   /** Try to read the generated package.json for a module from the temp directory. */
   readPackageJson(importName) {
     try {
-      const content = readFileSync4(join10(this.tempDir, importName, "package.json"), "utf8");
+      const content = readFileSync5(join11(this.tempDir, importName, "package.json"), "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -24755,7 +26589,7 @@ var JsonDefinitionGenerator = class _JsonDefinitionGenerator {
     const jsonStr = `${JSON.stringify(jsonOutput, null, pretty ? "	" : "")}
 `;
     if (this.config.outdir) {
-      const filepath = join11(this.config.outdir, "Gjs.json");
+      const filepath = join12(this.config.outdir, "Gjs.json");
       await writeFile5(filepath, jsonStr, "utf8");
       this.log.info(`Generated ${filepath}`);
     } else {
@@ -24770,7 +26604,7 @@ var JsonDefinitionGenerator = class _JsonDefinitionGenerator {
     const jsonStr = `${JSON.stringify(jsonOutput, null, pretty ? "	" : "")}
 `;
     if (this.config.outdir) {
-      const filepath = join11(this.config.outdir, `${module.packageName}.json`);
+      const filepath = join12(this.config.outdir, `${module.packageName}.json`);
       await writeFile5(filepath, jsonStr, "utf8");
       this.log.info(`Generated ${filepath}`);
     } else {
@@ -24780,9 +26614,9 @@ var JsonDefinitionGenerator = class _JsonDefinitionGenerator {
 };
 
 // ../typedoc-theme/src/theme.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync, readdirSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname9, join as join15 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { DefaultTheme, RendererEvent } from "typedoc";
 
 // ../typedoc-theme/src/context.ts
@@ -25055,8 +26889,8 @@ import { JSX as JSX3 } from "typedoc";
 
 // ../typedoc-theme/src/search-splitter.ts
 var import_lunr = __toESM(require_lunr(), 1);
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join13 } from "node:path";
 import { deflateSync, inflateSync } from "node:zlib";
 var KIND_MODULE = 2;
 function sanitizeModuleName(name) {
@@ -25073,20 +26907,20 @@ function getModuleName(row, moduleNames) {
   return void 0;
 }
 function buildChunk(rows) {
-  const builder7 = new import_lunr.default.Builder();
-  builder7.pipeline.add(import_lunr.default.trimmer);
-  builder7.ref("id");
-  builder7.field("name", { boost: 10 });
+  const builder8 = new import_lunr.default.Builder();
+  builder8.pipeline.add(import_lunr.default.trimmer);
+  builder8.ref("id");
+  builder8.field("name", { boost: 10 });
   for (let i = 0; i < rows.length; i++) {
-    builder7.add({ id: i, name: rows[i].name });
+    builder8.add({ id: i, name: rows[i].name });
   }
-  const index = builder7.build();
+  const index = builder8.build();
   const data = { rows, index };
   const compressed = deflateSync(Buffer.from(JSON.stringify(data)));
   return compressed.toString("base64");
 }
 function readSearchData(assetsDir) {
-  const raw = readFileSync5(join12(assetsDir, "search.js"), "utf-8");
+  const raw = readFileSync6(join13(assetsDir, "search.js"), "utf-8");
   const match = raw.match(/window\.searchData\s*=\s*"([^"]+)"/);
   if (!match?.[1]) {
     throw new Error("Could not extract searchData from search.js");
@@ -25096,7 +26930,7 @@ function readSearchData(assetsDir) {
   return JSON.parse(decompressed.toString("utf-8"));
 }
 async function splitSearchIndex(outputDir) {
-  const assetsDir = join12(outputDir, "assets");
+  const assetsDir = join13(outputDir, "assets");
   let searchData;
   try {
     searchData = readSearchData(assetsDir);
@@ -25128,11 +26962,11 @@ async function splitSearchIndex(outputDir) {
   for (const [moduleName, moduleRows] of moduleMap) {
     const chunk = buildChunk(moduleRows);
     const filename = `search-${sanitizeModuleName(moduleName)}.js`;
-    writeFileSync2(join12(assetsDir, filename), `window.searchData = "${chunk}";`);
+    writeFileSync3(join13(assetsDir, filename), `window.searchData = "${chunk}";`);
   }
   const modulesChunk = buildChunk(moduleEntries);
-  writeFileSync2(join12(assetsDir, "search-modules.js"), `window.searchData = "${modulesChunk}";`);
-  writeFileSync2(join12(assetsDir, "search.js"), "window.searchData = null;");
+  writeFileSync3(join13(assetsDir, "search-modules.js"), `window.searchData = "${modulesChunk}";`);
+  writeFileSync3(join13(assetsDir, "search.js"), "window.searchData = null;");
   const totalChunks = moduleMap.size + 1;
   console.log(`[search-splitter] Split ${rows.length} entries into ${totalChunks} chunks (${moduleMap.size} modules)`);
 }
@@ -25537,7 +27371,7 @@ function giDocgenModuleMemberSummary(context, member) {
   }
   const nsMeta = member.girNamespaceMetadata;
   const commentSummary = context.commentShortSummary(member);
-  const description7 = commentSummary || (nsMeta?.description ? JSX4.createElement("p", null, nsMeta.description) : null);
+  const description8 = commentSummary || (nsMeta?.description ? JSX4.createElement("p", null, nsMeta.description) : null);
   return JSX4.createElement(
     JSX4.Fragment,
     null,
@@ -25549,7 +27383,7 @@ function giDocgenModuleMemberSummary(context, member) {
     JSX4.createElement(
       "dd",
       { class: classNames({ "tsd-member-summary": true }, context.getReflectionClasses(member)) },
-      description7
+      description8
     )
   );
 }
@@ -25658,16 +27492,16 @@ import { JSX as JSX7 } from "typedoc";
 var giDocgenPageSidebar = (context, props) => JSX7.createElement(JSX7.Fragment, null, context.pageNavigation(props));
 
 // ../typedoc-theme/src/partials/sidebar.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { i18n, JSX as JSX8, ReflectionKind as ReflectionKind4 } from "typedoc";
 function getTsForGirVersion() {
   if (true) {
-    return "4.0.0-rc.3";
+    return "4.0.0-rc.5";
   }
-  const __dirname3 = dirname7(fileURLToPath4(import.meta.url));
-  return JSON.parse(readFileSync6(join13(__dirname3, "..", "..", "package.json"), "utf8")).version;
+  const __dirname3 = dirname8(fileURLToPath5(import.meta.url));
+  return JSON.parse(readFileSync7(join14(__dirname3, "..", "..", "package.json"), "utf8")).version;
 }
 var TSFOR_GIR_VERSION = getTsForGirVersion();
 function giDocgenModuleInfo(context, mod, nsMeta) {
@@ -26100,7 +27934,7 @@ var GiDocgenThemeRenderContext = class extends DefaultThemeRenderContext {
 };
 
 // ../typedoc-theme/src/theme.ts
-var __dirname2 = dirname8(fileURLToPath5(import.meta.url));
+var __dirname2 = dirname9(fileURLToPath6(import.meta.url));
 var FAVICON_FILES = [
   "favicon.ico",
   "favicon-96x96.png",
@@ -26123,21 +27957,21 @@ var GiDocgenTheme = class extends DefaultTheme {
   constructor(renderer) {
     super(renderer);
     this.owner.on(RendererEvent.END, (event) => {
-      const assetsDir = join14(event.outputDirectory, "assets");
-      copyFileSync(join14(__dirname2, "static", "style.css"), join14(assetsDir, "gi-docgen.css"));
-      copyFileSync(join14(__dirname2, "static", "gi-docgen-inherited.js"), join14(assetsDir, "gi-docgen-inherited.js"));
-      copyFileSync(join14(__dirname2, "static", "logo_x4.png"), join14(assetsDir, "logo_x4.png"));
-      const faviconDir = join14(__dirname2, "static", "favicon");
+      const assetsDir = join15(event.outputDirectory, "assets");
+      copyFileSync(join15(__dirname2, "static", "style.css"), join15(assetsDir, "gi-docgen.css"));
+      copyFileSync(join15(__dirname2, "static", "gi-docgen-inherited.js"), join15(assetsDir, "gi-docgen-inherited.js"));
+      copyFileSync(join15(__dirname2, "static", "logo_x4.png"), join15(assetsDir, "logo_x4.png"));
+      const faviconDir = join15(__dirname2, "static", "favicon");
       for (const file of FAVICON_FILES) {
-        copyFileSync(join14(faviconDir, file), join14(assetsDir, file));
+        copyFileSync(join15(faviconDir, file), join15(assetsDir, file));
       }
-      const iconsSourceDir = join14(__dirname2, "..", "..", "..", "refs", "library-icons", "library-icons");
-      const iconsOutputDir = join14(assetsDir, "library-icons");
-      if (existsSync3(iconsSourceDir)) {
-        mkdirSync(iconsOutputDir, { recursive: true });
-        for (const file of readdirSync(iconsSourceDir)) {
+      const iconsSourceDir = join15(__dirname2, "..", "..", "..", "refs", "library-icons", "library-icons");
+      const iconsOutputDir = join15(assetsDir, "library-icons");
+      if (existsSync4(iconsSourceDir)) {
+        mkdirSync2(iconsOutputDir, { recursive: true });
+        for (const file of readdirSync2(iconsSourceDir)) {
           if (file.endsWith("-r.svg")) {
-            copyFileSync(join14(iconsSourceDir, file), join14(iconsOutputDir, file));
+            copyFileSync(join15(iconsSourceDir, file), join15(iconsOutputDir, file));
           }
         }
       }
@@ -26153,7 +27987,7 @@ var GiDocgenTheme = class extends DefaultTheme {
         background_color: "#1e1e1e",
         display: "standalone"
       };
-      writeFileSync3(join14(assetsDir, "site.webmanifest"), JSON.stringify(manifest, null, 2));
+      writeFileSync4(join15(assetsDir, "site.webmanifest"), JSON.stringify(manifest, null, 2));
     });
   }
   getNavigation(project) {
@@ -26207,7 +28041,7 @@ var HtmlDocGenerator = class _HtmlDocGenerator {
       } else {
         for (const module of this.pipeline.modules) {
           const result = await this.pipeline.createTypeDocApp(module);
-          await this.generateDocsWithTheme(result, join15(outdir, module.packageName));
+          await this.generateDocsWithTheme(result, join16(outdir, module.packageName));
         }
       }
       this.log.success(`HTML documentation generated for ${this.pipeline.modules.length} modules in ${outdir}`);
@@ -26252,9 +28086,9 @@ var HtmlDocGenerator = class _HtmlDocGenerator {
 import prettier from "prettier";
 var logger4 = new Logger(false, "TypeScriptFormatter");
 var TypeScriptFormatter = class extends Formatter {
-  format(input) {
+  format(input2) {
     try {
-      return prettier.format(input, {
+      return prettier.format(input2, {
         singleQuote: true,
         parser: "typescript",
         printWidth: 120,
@@ -26262,7 +28096,7 @@ var TypeScriptFormatter = class extends Formatter {
       });
     } catch (error) {
       logger4.warn("Failed to format with prettier, returning original input", error);
-      return Promise.resolve(input);
+      return Promise.resolve(input2);
     }
   }
 };
@@ -26391,9 +28225,9 @@ async function runGenerationCommand(args, options2) {
 }
 
 // src/commands/doc.ts
-var command3 = "doc [modules..]";
-var description3 = "Generates HTML documentation from GIR files using TypeDoc";
-var examples3 = [
+var command4 = "doc [modules..]";
+var description4 = "Generates HTML documentation from GIR files using TypeDoc";
+var examples4 = [
   [`${APP_NAME} doc Gtk-4.0 --outdir ./docs`, "Generate HTML documentation for Gtk-4.0"],
   [`${APP_NAME} doc '*' --outdir ./docs`, "Generate documentation for all locally installed GIR modules"],
   [
@@ -26401,8 +28235,8 @@ var examples3 = [
     "Generate HTML from pre-generated JSON files (low memory)"
   ]
 ];
-var builder3 = createBuilder(docOptions, examples3);
-var handler3 = async (args) => {
+var builder4 = createBuilder(docOptions, examples4);
+var handler4 = async (args) => {
   const config = getOptionsGeneration(await load(args));
   if (config.merge) {
     if (!config.jsonDir) {
@@ -26421,17 +28255,17 @@ var handler3 = async (args) => {
   });
 };
 var doc = {
-  command: command3,
-  description: description3,
-  builder: builder3,
-  handler: handler3,
-  examples: examples3
+  command: command4,
+  description: description4,
+  builder: builder4,
+  handler: handler4,
+  examples: examples4
 };
 
 // src/commands/generate.ts
-var command4 = "generate [modules..]";
-var description4 = "Generates Typescript type definition .d.ts files from GIR for GJS";
-var examples4 = [
+var command5 = "generate [modules..]";
+var description5 = "Generates Typescript type definition .d.ts files from GIR for GJS";
+var examples5 = [
   [
     `${APP_NAME} generate`,
     `Run '${APP_NAME} generate' in your gjs project to generate typings for your project, pass the gir modules you need for your project`
@@ -26441,8 +28275,8 @@ var examples4 = [
   [`${APP_NAME} generate --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
   [`${APP_NAME} generate --ignore=Gtk-4.0 xrandr-1.3`, "Generate .d.ts. files but not for Gtk-4.0 and xrandr-1.3"]
 ];
-var builder4 = createBuilder(generateOptions, examples4);
-var handler4 = async (args) => {
+var builder5 = createBuilder(generateOptions, examples5);
+var handler5 = async (args) => {
   await runGenerationCommand(args, {
     generatorType: 0 /* TYPES */,
     loggerName: "GenerateCommand",
@@ -26452,25 +28286,25 @@ var handler4 = async (args) => {
   });
 };
 var generate = {
-  command: command4,
-  description: description4,
-  builder: builder4,
-  handler: handler4,
-  examples: examples4
+  command: command5,
+  description: description5,
+  builder: builder5,
+  handler: handler5,
+  examples: examples5
 };
 
 // src/commands/json.ts
-var command5 = "json [modules..]";
-var description5 = "Generates JSON representation from GIR files for analysis and tooling";
-var examples5 = [
+var command6 = "json [modules..]";
+var description6 = "Generates JSON representation from GIR files for analysis and tooling";
+var examples6 = [
   [`${APP_NAME} json`, `Run '${APP_NAME} json' in your gjs project to generate JSON files for your project`],
   [`${APP_NAME} json 'Gtk*'`, "You can also use wild cards"],
   [`${APP_NAME} json '*'`, "If you want to parse all of your locally installed gir modules run"],
   [`${APP_NAME} json --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
   [`${APP_NAME} json --ignore=Gtk-4.0 xrandr-1.3`, "Generate JSON files but not for Gtk-4.0 and xrandr-1.3"]
 ];
-var builder5 = createBuilder(generateOptions, examples5);
-var handler5 = async (args) => {
+var builder6 = createBuilder(generateOptions, examples6);
+var handler6 = async (args) => {
   await runGenerationCommand(args, {
     generatorType: 2 /* JSON */,
     loggerName: "JsonCommand",
@@ -26480,26 +28314,26 @@ var handler5 = async (args) => {
   });
 };
 var json2 = {
-  command: command5,
-  description: description5,
-  builder: builder5,
-  handler: handler5,
-  examples: examples5
+  command: command6,
+  description: description6,
+  builder: builder6,
+  handler: handler6,
+  examples: examples6
 };
 
 // src/commands/list.ts
-var command6 = "list [modules..]";
-var description6 = "Lists all available GIR modules";
+var command7 = "list [modules..]";
+var description7 = "Lists all available GIR modules";
 var logger5 = new Logger(true, "ListCommand");
-var examples6 = [
+var examples7 = [
   [`${APP_NAME} list -g ./vala-girs/gir-1.0`, "Lists all available GIR modules in ./vala-girs/gir-1.0"],
   [
     `${APP_NAME} list --ignore=Gtk-3.0 xrandr-1.3`,
     "Lists all available GIR modules in /usr/share/gir-1.0 but not Gtk-3.0 and xrandr-1.3"
   ]
 ];
-var builder6 = createBuilder(listOptions, examples6);
-var handler6 = async (args) => {
+var builder7 = createBuilder(listOptions, examples7);
+var handler7 = async (args) => {
   const config = await load(args);
   const generateConfig = getOptionsGeneration(config);
   const registry = new NSRegistry();
@@ -26540,15 +28374,15 @@ var handler6 = async (args) => {
   }
 };
 var list = {
-  command: command6,
-  description: description6,
-  builder: builder6,
-  handler: handler6,
-  examples: examples6
+  command: command7,
+  description: description7,
+  builder: builder7,
+  handler: handler7,
+  examples: examples7
 };
 
 // src/start.ts
-void yargs(hideBin(process.argv)).scriptName(APP_NAME).strict().usage(APP_USAGE).version(APP_VERSION).command(analyze).command(generate).command(json2).command(list).command(copy).command(doc).demandCommand(1).help().argv;
+void yargs(hideBin(process.argv)).scriptName(APP_NAME).strict().usage(APP_USAGE).version(APP_VERSION).command(analyze).command(create).command(generate).command(json2).command(list).command(copy).command(doc).demandCommand(1).help().argv;
 /*! Bundled license information:
 
 lodash/lodash.js: