@ts-for-gir/cli 4.0.0-beta.41 → 4.0.0-beta.42

package/bin/ts-for-gir

@@ -3353,7 +3353,7 @@ var require_lodash = __commonJS({
           }
           return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
         });
-        function join15(array, separator) {
+        function join16(array, separator) {
           return array == null ? "" : nativeJoin.call(array, separator);
         }
         function last(array) {
@@ -4178,7 +4178,7 @@ var require_lodash = __commonJS({
           customizer = typeof customizer == "function" ? customizer : undefined2;
           return baseIsMatch(object, source, getMatchData(source), customizer);
         }
-        function isNaN(value) {
+        function isNaN2(value) {
           return isNumber(value) && value != +value;
         }
         function isNative(value) {
@@ -5255,7 +5255,7 @@ var require_lodash = __commonJS({
         lodash2.isMap = isMap;
         lodash2.isMatch = isMatch;
         lodash2.isMatchWith = isMatchWith;
-        lodash2.isNaN = isNaN;
+        lodash2.isNaN = isNaN2;
         lodash2.isNative = isNative;
         lodash2.isNil = isNil;
         lodash2.isNull = isNull;
@@ -5272,7 +5272,7 @@ var require_lodash = __commonJS({
         lodash2.isUndefined = isUndefined;
         lodash2.isWeakMap = isWeakMap;
         lodash2.isWeakSet = isWeakSet;
-        lodash2.join = join15;
+        lodash2.join = join16;
         lodash2.kebabCase = kebabCase;
         lodash2.last = last;
         lodash2.lastIndexOf = lastIndexOf;
@@ -5529,6 +5529,1737 @@ var require_lodash = __commonJS({
   }
 });
 
+// ../../.yarn/cache/lunr-npm-2.3.9-fa3aa9c2d6-f2f6db34c0.zip/node_modules/lunr/lunr.js
+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(
+          lunr2.trimmer,
+          lunr2.stopWordFilter,
+          lunr2.stemmer
+        );
+        builder7.searchPipeline.add(
+          lunr2.stemmer
+        );
+        config.call(builder7, builder7);
+        return builder7.build();
+      };
+      lunr2.version = "2.3.9";
+      lunr2.utils = {};
+      lunr2.utils.warn = /* @__PURE__ */ (function(global2) {
+        return function(message) {
+          if (global2.console && console.warn) {
+            console.warn(message);
+          }
+        };
+      })(this);
+      lunr2.utils.asString = function(obj) {
+        if (obj === void 0 || obj === null) {
+          return "";
+        } else {
+          return obj.toString();
+        }
+      };
+      lunr2.utils.clone = function(obj) {
+        if (obj === null || obj === void 0) {
+          return obj;
+        }
+        var clone2 = /* @__PURE__ */ Object.create(null), keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i], val = obj[key];
+          if (Array.isArray(val)) {
+            clone2[key] = val.slice();
+            continue;
+          }
+          if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+            clone2[key] = val;
+            continue;
+          }
+          throw new TypeError("clone is not deep and does not support nested objects");
+        }
+        return clone2;
+      };
+      lunr2.FieldRef = function(docRef, fieldName, stringValue) {
+        this.docRef = docRef;
+        this.fieldName = fieldName;
+        this._stringValue = stringValue;
+      };
+      lunr2.FieldRef.joiner = "/";
+      lunr2.FieldRef.fromString = function(s) {
+        var n = s.indexOf(lunr2.FieldRef.joiner);
+        if (n === -1) {
+          throw "malformed field ref string";
+        }
+        var fieldRef = s.slice(0, n), docRef = s.slice(n + 1);
+        return new lunr2.FieldRef(docRef, fieldRef, s);
+      };
+      lunr2.FieldRef.prototype.toString = function() {
+        if (this._stringValue == void 0) {
+          this._stringValue = this.fieldName + lunr2.FieldRef.joiner + this.docRef;
+        }
+        return this._stringValue;
+      };
+      lunr2.Set = function(elements) {
+        this.elements = /* @__PURE__ */ Object.create(null);
+        if (elements) {
+          this.length = elements.length;
+          for (var i = 0; i < this.length; i++) {
+            this.elements[elements[i]] = true;
+          }
+        } else {
+          this.length = 0;
+        }
+      };
+      lunr2.Set.complete = {
+        intersect: function(other) {
+          return other;
+        },
+        union: function() {
+          return this;
+        },
+        contains: function() {
+          return true;
+        }
+      };
+      lunr2.Set.empty = {
+        intersect: function() {
+          return this;
+        },
+        union: function(other) {
+          return other;
+        },
+        contains: function() {
+          return false;
+        }
+      };
+      lunr2.Set.prototype.contains = function(object) {
+        return !!this.elements[object];
+      };
+      lunr2.Set.prototype.intersect = function(other) {
+        var a, b, elements, intersection = [];
+        if (other === lunr2.Set.complete) {
+          return this;
+        }
+        if (other === lunr2.Set.empty) {
+          return other;
+        }
+        if (this.length < other.length) {
+          a = this;
+          b = other;
+        } else {
+          a = other;
+          b = this;
+        }
+        elements = Object.keys(a.elements);
+        for (var i = 0; i < elements.length; i++) {
+          var element = elements[i];
+          if (element in b.elements) {
+            intersection.push(element);
+          }
+        }
+        return new lunr2.Set(intersection);
+      };
+      lunr2.Set.prototype.union = function(other) {
+        if (other === lunr2.Set.complete) {
+          return lunr2.Set.complete;
+        }
+        if (other === lunr2.Set.empty) {
+          return this;
+        }
+        return new lunr2.Set(Object.keys(this.elements).concat(Object.keys(other.elements)));
+      };
+      lunr2.idf = function(posting, documentCount) {
+        var documentsWithTerm = 0;
+        for (var fieldName in posting) {
+          if (fieldName == "_index") continue;
+          documentsWithTerm += Object.keys(posting[fieldName]).length;
+        }
+        var x = (documentCount - documentsWithTerm + 0.5) / (documentsWithTerm + 0.5);
+        return Math.log(1 + Math.abs(x));
+      };
+      lunr2.Token = function(str, metadata) {
+        this.str = str || "";
+        this.metadata = metadata || {};
+      };
+      lunr2.Token.prototype.toString = function() {
+        return this.str;
+      };
+      lunr2.Token.prototype.update = function(fn) {
+        this.str = fn(this.str, this.metadata);
+        return this;
+      };
+      lunr2.Token.prototype.clone = function(fn) {
+        fn = fn || function(s) {
+          return s;
+        };
+        return new lunr2.Token(fn(this.str, this.metadata), this.metadata);
+      };
+      lunr2.tokenizer = function(obj, metadata) {
+        if (obj == null || obj == void 0) {
+          return [];
+        }
+        if (Array.isArray(obj)) {
+          return obj.map(function(t) {
+            return new lunr2.Token(
+              lunr2.utils.asString(t).toLowerCase(),
+              lunr2.utils.clone(metadata)
+            );
+          });
+        }
+        var str = obj.toString().toLowerCase(), len = str.length, tokens = [];
+        for (var sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {
+          var char = str.charAt(sliceEnd), sliceLength = sliceEnd - sliceStart;
+          if (char.match(lunr2.tokenizer.separator) || sliceEnd == len) {
+            if (sliceLength > 0) {
+              var tokenMetadata = lunr2.utils.clone(metadata) || {};
+              tokenMetadata["position"] = [sliceStart, sliceLength];
+              tokenMetadata["index"] = tokens.length;
+              tokens.push(
+                new lunr2.Token(
+                  str.slice(sliceStart, sliceEnd),
+                  tokenMetadata
+                )
+              );
+            }
+            sliceStart = sliceEnd + 1;
+          }
+        }
+        return tokens;
+      };
+      lunr2.tokenizer.separator = /[\s\-]+/;
+      lunr2.Pipeline = function() {
+        this._stack = [];
+      };
+      lunr2.Pipeline.registeredFunctions = /* @__PURE__ */ Object.create(null);
+      lunr2.Pipeline.registerFunction = function(fn, label) {
+        if (label in this.registeredFunctions) {
+          lunr2.utils.warn("Overwriting existing registered function: " + label);
+        }
+        fn.label = label;
+        lunr2.Pipeline.registeredFunctions[fn.label] = fn;
+      };
+      lunr2.Pipeline.warnIfFunctionNotRegistered = function(fn) {
+        var isRegistered = fn.label && fn.label in this.registeredFunctions;
+        if (!isRegistered) {
+          lunr2.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n", fn);
+        }
+      };
+      lunr2.Pipeline.load = function(serialised) {
+        var pipeline = new lunr2.Pipeline();
+        serialised.forEach(function(fnName) {
+          var fn = lunr2.Pipeline.registeredFunctions[fnName];
+          if (fn) {
+            pipeline.add(fn);
+          } else {
+            throw new Error("Cannot load unregistered function: " + fnName);
+          }
+        });
+        return pipeline;
+      };
+      lunr2.Pipeline.prototype.add = function() {
+        var fns = Array.prototype.slice.call(arguments);
+        fns.forEach(function(fn) {
+          lunr2.Pipeline.warnIfFunctionNotRegistered(fn);
+          this._stack.push(fn);
+        }, this);
+      };
+      lunr2.Pipeline.prototype.after = function(existingFn, newFn) {
+        lunr2.Pipeline.warnIfFunctionNotRegistered(newFn);
+        var pos = this._stack.indexOf(existingFn);
+        if (pos == -1) {
+          throw new Error("Cannot find existingFn");
+        }
+        pos = pos + 1;
+        this._stack.splice(pos, 0, newFn);
+      };
+      lunr2.Pipeline.prototype.before = function(existingFn, newFn) {
+        lunr2.Pipeline.warnIfFunctionNotRegistered(newFn);
+        var pos = this._stack.indexOf(existingFn);
+        if (pos == -1) {
+          throw new Error("Cannot find existingFn");
+        }
+        this._stack.splice(pos, 0, newFn);
+      };
+      lunr2.Pipeline.prototype.remove = function(fn) {
+        var pos = this._stack.indexOf(fn);
+        if (pos == -1) {
+          return;
+        }
+        this._stack.splice(pos, 1);
+      };
+      lunr2.Pipeline.prototype.run = function(tokens) {
+        var stackLength = this._stack.length;
+        for (var i = 0; i < stackLength; i++) {
+          var fn = this._stack[i];
+          var memo = [];
+          for (var j = 0; j < tokens.length; j++) {
+            var result = fn(tokens[j], j, tokens);
+            if (result === null || result === void 0 || result === "") continue;
+            if (Array.isArray(result)) {
+              for (var k = 0; k < result.length; k++) {
+                memo.push(result[k]);
+              }
+            } else {
+              memo.push(result);
+            }
+          }
+          tokens = memo;
+        }
+        return tokens;
+      };
+      lunr2.Pipeline.prototype.runString = function(str, metadata) {
+        var token = new lunr2.Token(str, metadata);
+        return this.run([token]).map(function(t) {
+          return t.toString();
+        });
+      };
+      lunr2.Pipeline.prototype.reset = function() {
+        this._stack = [];
+      };
+      lunr2.Pipeline.prototype.toJSON = function() {
+        return this._stack.map(function(fn) {
+          lunr2.Pipeline.warnIfFunctionNotRegistered(fn);
+          return fn.label;
+        });
+      };
+      lunr2.Vector = function(elements) {
+        this._magnitude = 0;
+        this.elements = elements || [];
+      };
+      lunr2.Vector.prototype.positionForIndex = function(index) {
+        if (this.elements.length == 0) {
+          return 0;
+        }
+        var start = 0, end = this.elements.length / 2, sliceLength = end - start, pivotPoint = Math.floor(sliceLength / 2), pivotIndex = this.elements[pivotPoint * 2];
+        while (sliceLength > 1) {
+          if (pivotIndex < index) {
+            start = pivotPoint;
+          }
+          if (pivotIndex > index) {
+            end = pivotPoint;
+          }
+          if (pivotIndex == index) {
+            break;
+          }
+          sliceLength = end - start;
+          pivotPoint = start + Math.floor(sliceLength / 2);
+          pivotIndex = this.elements[pivotPoint * 2];
+        }
+        if (pivotIndex == index) {
+          return pivotPoint * 2;
+        }
+        if (pivotIndex > index) {
+          return pivotPoint * 2;
+        }
+        if (pivotIndex < index) {
+          return (pivotPoint + 1) * 2;
+        }
+      };
+      lunr2.Vector.prototype.insert = function(insertIdx, val) {
+        this.upsert(insertIdx, val, function() {
+          throw "duplicate index";
+        });
+      };
+      lunr2.Vector.prototype.upsert = function(insertIdx, val, fn) {
+        this._magnitude = 0;
+        var position = this.positionForIndex(insertIdx);
+        if (this.elements[position] == insertIdx) {
+          this.elements[position + 1] = fn(this.elements[position + 1], val);
+        } else {
+          this.elements.splice(position, 0, insertIdx, val);
+        }
+      };
+      lunr2.Vector.prototype.magnitude = function() {
+        if (this._magnitude) return this._magnitude;
+        var sumOfSquares = 0, elementsLength = this.elements.length;
+        for (var i = 1; i < elementsLength; i += 2) {
+          var val = this.elements[i];
+          sumOfSquares += val * val;
+        }
+        return this._magnitude = Math.sqrt(sumOfSquares);
+      };
+      lunr2.Vector.prototype.dot = function(otherVector) {
+        var dotProduct = 0, a = this.elements, b = otherVector.elements, aLen = a.length, bLen = b.length, aVal = 0, bVal = 0, i = 0, j = 0;
+        while (i < aLen && j < bLen) {
+          aVal = a[i], bVal = b[j];
+          if (aVal < bVal) {
+            i += 2;
+          } else if (aVal > bVal) {
+            j += 2;
+          } else if (aVal == bVal) {
+            dotProduct += a[i + 1] * b[j + 1];
+            i += 2;
+            j += 2;
+          }
+        }
+        return dotProduct;
+      };
+      lunr2.Vector.prototype.similarity = function(otherVector) {
+        return this.dot(otherVector) / this.magnitude() || 0;
+      };
+      lunr2.Vector.prototype.toArray = function() {
+        var output = new Array(this.elements.length / 2);
+        for (var i = 1, j = 0; i < this.elements.length; i += 2, j++) {
+          output[j] = this.elements[i];
+        }
+        return output;
+      };
+      lunr2.Vector.prototype.toJSON = function() {
+        return this.elements;
+      };
+      lunr2.stemmer = (function() {
+        var step2list = {
+          "ational": "ate",
+          "tional": "tion",
+          "enci": "ence",
+          "anci": "ance",
+          "izer": "ize",
+          "bli": "ble",
+          "alli": "al",
+          "entli": "ent",
+          "eli": "e",
+          "ousli": "ous",
+          "ization": "ize",
+          "ation": "ate",
+          "ator": "ate",
+          "alism": "al",
+          "iveness": "ive",
+          "fulness": "ful",
+          "ousness": "ous",
+          "aliti": "al",
+          "iviti": "ive",
+          "biliti": "ble",
+          "logi": "log"
+        }, step3list = {
+          "icate": "ic",
+          "ative": "",
+          "alize": "al",
+          "iciti": "ic",
+          "ical": "ic",
+          "ful": "",
+          "ness": ""
+        }, c = "[^aeiou]", v = "[aeiouy]", C = c + "[^aeiouy]*", V = v + "[aeiou]*", mgr0 = "^(" + C + ")?" + V + C, meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$", mgr1 = "^(" + C + ")?" + V + C + V + C, s_v = "^(" + C + ")?" + v;
+        var re_mgr0 = new RegExp(mgr0);
+        var re_mgr1 = new RegExp(mgr1);
+        var re_meq1 = new RegExp(meq1);
+        var re_s_v = new RegExp(s_v);
+        var re_1a = /^(.+?)(ss|i)es$/;
+        var re2_1a = /^(.+?)([^s])s$/;
+        var re_1b = /^(.+?)eed$/;
+        var re2_1b = /^(.+?)(ed|ing)$/;
+        var re_1b_2 = /.$/;
+        var re2_1b_2 = /(at|bl|iz)$/;
+        var re3_1b_2 = new RegExp("([^aeiouylsz])\\1$");
+        var re4_1b_2 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+        var re_1c = /^(.+?[^aeiou])y$/;
+        var re_2 = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+        var re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+        var re_4 = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+        var re2_4 = /^(.+?)(s|t)(ion)$/;
+        var re_5 = /^(.+?)e$/;
+        var re_5_1 = /ll$/;
+        var re3_5 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+        var porterStemmer = function porterStemmer2(w) {
+          var stem, suffix, firstch, re, re2, re3, re4;
+          if (w.length < 3) {
+            return w;
+          }
+          firstch = w.substr(0, 1);
+          if (firstch == "y") {
+            w = firstch.toUpperCase() + w.substr(1);
+          }
+          re = re_1a;
+          re2 = re2_1a;
+          if (re.test(w)) {
+            w = w.replace(re, "$1$2");
+          } else if (re2.test(w)) {
+            w = w.replace(re2, "$1$2");
+          }
+          re = re_1b;
+          re2 = re2_1b;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            re = re_mgr0;
+            if (re.test(fp[1])) {
+              re = re_1b_2;
+              w = w.replace(re, "");
+            }
+          } else if (re2.test(w)) {
+            var fp = re2.exec(w);
+            stem = fp[1];
+            re2 = re_s_v;
+            if (re2.test(stem)) {
+              w = stem;
+              re2 = re2_1b_2;
+              re3 = re3_1b_2;
+              re4 = re4_1b_2;
+              if (re2.test(w)) {
+                w = w + "e";
+              } else if (re3.test(w)) {
+                re = re_1b_2;
+                w = w.replace(re, "");
+              } else if (re4.test(w)) {
+                w = w + "e";
+              }
+            }
+          }
+          re = re_1c;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            stem = fp[1];
+            w = stem + "i";
+          }
+          re = re_2;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            stem = fp[1];
+            suffix = fp[2];
+            re = re_mgr0;
+            if (re.test(stem)) {
+              w = stem + step2list[suffix];
+            }
+          }
+          re = re_3;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            stem = fp[1];
+            suffix = fp[2];
+            re = re_mgr0;
+            if (re.test(stem)) {
+              w = stem + step3list[suffix];
+            }
+          }
+          re = re_4;
+          re2 = re2_4;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            stem = fp[1];
+            re = re_mgr1;
+            if (re.test(stem)) {
+              w = stem;
+            }
+          } else if (re2.test(w)) {
+            var fp = re2.exec(w);
+            stem = fp[1] + fp[2];
+            re2 = re_mgr1;
+            if (re2.test(stem)) {
+              w = stem;
+            }
+          }
+          re = re_5;
+          if (re.test(w)) {
+            var fp = re.exec(w);
+            stem = fp[1];
+            re = re_mgr1;
+            re2 = re_meq1;
+            re3 = re3_5;
+            if (re.test(stem) || re2.test(stem) && !re3.test(stem)) {
+              w = stem;
+            }
+          }
+          re = re_5_1;
+          re2 = re_mgr1;
+          if (re.test(w) && re2.test(w)) {
+            re = re_1b_2;
+            w = w.replace(re, "");
+          }
+          if (firstch == "y") {
+            w = firstch.toLowerCase() + w.substr(1);
+          }
+          return w;
+        };
+        return function(token) {
+          return token.update(porterStemmer);
+        };
+      })();
+      lunr2.Pipeline.registerFunction(lunr2.stemmer, "stemmer");
+      lunr2.generateStopWordFilter = function(stopWords) {
+        var words = stopWords.reduce(function(memo, stopWord) {
+          memo[stopWord] = stopWord;
+          return memo;
+        }, {});
+        return function(token) {
+          if (token && words[token.toString()] !== token.toString()) return token;
+        };
+      };
+      lunr2.stopWordFilter = lunr2.generateStopWordFilter([
+        "a",
+        "able",
+        "about",
+        "across",
+        "after",
+        "all",
+        "almost",
+        "also",
+        "am",
+        "among",
+        "an",
+        "and",
+        "any",
+        "are",
+        "as",
+        "at",
+        "be",
+        "because",
+        "been",
+        "but",
+        "by",
+        "can",
+        "cannot",
+        "could",
+        "dear",
+        "did",
+        "do",
+        "does",
+        "either",
+        "else",
+        "ever",
+        "every",
+        "for",
+        "from",
+        "get",
+        "got",
+        "had",
+        "has",
+        "have",
+        "he",
+        "her",
+        "hers",
+        "him",
+        "his",
+        "how",
+        "however",
+        "i",
+        "if",
+        "in",
+        "into",
+        "is",
+        "it",
+        "its",
+        "just",
+        "least",
+        "let",
+        "like",
+        "likely",
+        "may",
+        "me",
+        "might",
+        "most",
+        "must",
+        "my",
+        "neither",
+        "no",
+        "nor",
+        "not",
+        "of",
+        "off",
+        "often",
+        "on",
+        "only",
+        "or",
+        "other",
+        "our",
+        "own",
+        "rather",
+        "said",
+        "say",
+        "says",
+        "she",
+        "should",
+        "since",
+        "so",
+        "some",
+        "than",
+        "that",
+        "the",
+        "their",
+        "them",
+        "then",
+        "there",
+        "these",
+        "they",
+        "this",
+        "tis",
+        "to",
+        "too",
+        "twas",
+        "us",
+        "wants",
+        "was",
+        "we",
+        "were",
+        "what",
+        "when",
+        "where",
+        "which",
+        "while",
+        "who",
+        "whom",
+        "why",
+        "will",
+        "with",
+        "would",
+        "yet",
+        "you",
+        "your"
+      ]);
+      lunr2.Pipeline.registerFunction(lunr2.stopWordFilter, "stopWordFilter");
+      lunr2.trimmer = function(token) {
+        return token.update(function(s) {
+          return s.replace(/^\W+/, "").replace(/\W+$/, "");
+        });
+      };
+      lunr2.Pipeline.registerFunction(lunr2.trimmer, "trimmer");
+      lunr2.TokenSet = function() {
+        this.final = false;
+        this.edges = {};
+        this.id = lunr2.TokenSet._nextId;
+        lunr2.TokenSet._nextId += 1;
+      };
+      lunr2.TokenSet._nextId = 1;
+      lunr2.TokenSet.fromArray = function(arr) {
+        var builder7 = new lunr2.TokenSet.Builder();
+        for (var i = 0, len = arr.length; i < len; i++) {
+          builder7.insert(arr[i]);
+        }
+        builder7.finish();
+        return builder7.root;
+      };
+      lunr2.TokenSet.fromClause = function(clause) {
+        if ("editDistance" in clause) {
+          return lunr2.TokenSet.fromFuzzyString(clause.term, clause.editDistance);
+        } else {
+          return lunr2.TokenSet.fromString(clause.term);
+        }
+      };
+      lunr2.TokenSet.fromFuzzyString = function(str, editDistance) {
+        var root = new lunr2.TokenSet();
+        var stack = [{
+          node: root,
+          editsRemaining: editDistance,
+          str
+        }];
+        while (stack.length) {
+          var frame = stack.pop();
+          if (frame.str.length > 0) {
+            var char = frame.str.charAt(0), noEditNode;
+            if (char in frame.node.edges) {
+              noEditNode = frame.node.edges[char];
+            } else {
+              noEditNode = new lunr2.TokenSet();
+              frame.node.edges[char] = noEditNode;
+            }
+            if (frame.str.length == 1) {
+              noEditNode.final = true;
+            }
+            stack.push({
+              node: noEditNode,
+              editsRemaining: frame.editsRemaining,
+              str: frame.str.slice(1)
+            });
+          }
+          if (frame.editsRemaining == 0) {
+            continue;
+          }
+          if ("*" in frame.node.edges) {
+            var insertionNode = frame.node.edges["*"];
+          } else {
+            var insertionNode = new lunr2.TokenSet();
+            frame.node.edges["*"] = insertionNode;
+          }
+          if (frame.str.length == 0) {
+            insertionNode.final = true;
+          }
+          stack.push({
+            node: insertionNode,
+            editsRemaining: frame.editsRemaining - 1,
+            str: frame.str
+          });
+          if (frame.str.length > 1) {
+            stack.push({
+              node: frame.node,
+              editsRemaining: frame.editsRemaining - 1,
+              str: frame.str.slice(1)
+            });
+          }
+          if (frame.str.length == 1) {
+            frame.node.final = true;
+          }
+          if (frame.str.length >= 1) {
+            if ("*" in frame.node.edges) {
+              var substitutionNode = frame.node.edges["*"];
+            } else {
+              var substitutionNode = new lunr2.TokenSet();
+              frame.node.edges["*"] = substitutionNode;
+            }
+            if (frame.str.length == 1) {
+              substitutionNode.final = true;
+            }
+            stack.push({
+              node: substitutionNode,
+              editsRemaining: frame.editsRemaining - 1,
+              str: frame.str.slice(1)
+            });
+          }
+          if (frame.str.length > 1) {
+            var charA = frame.str.charAt(0), charB = frame.str.charAt(1), transposeNode;
+            if (charB in frame.node.edges) {
+              transposeNode = frame.node.edges[charB];
+            } else {
+              transposeNode = new lunr2.TokenSet();
+              frame.node.edges[charB] = transposeNode;
+            }
+            if (frame.str.length == 1) {
+              transposeNode.final = true;
+            }
+            stack.push({
+              node: transposeNode,
+              editsRemaining: frame.editsRemaining - 1,
+              str: charA + frame.str.slice(2)
+            });
+          }
+        }
+        return root;
+      };
+      lunr2.TokenSet.fromString = function(str) {
+        var node = new lunr2.TokenSet(), root = node;
+        for (var i = 0, len = str.length; i < len; i++) {
+          var char = str[i], final = i == len - 1;
+          if (char == "*") {
+            node.edges[char] = node;
+            node.final = final;
+          } else {
+            var next = new lunr2.TokenSet();
+            next.final = final;
+            node.edges[char] = next;
+            node = next;
+          }
+        }
+        return root;
+      };
+      lunr2.TokenSet.prototype.toArray = function() {
+        var words = [];
+        var stack = [{
+          prefix: "",
+          node: this
+        }];
+        while (stack.length) {
+          var frame = stack.pop(), edges = Object.keys(frame.node.edges), len = edges.length;
+          if (frame.node.final) {
+            frame.prefix.charAt(0);
+            words.push(frame.prefix);
+          }
+          for (var i = 0; i < len; i++) {
+            var edge = edges[i];
+            stack.push({
+              prefix: frame.prefix.concat(edge),
+              node: frame.node.edges[edge]
+            });
+          }
+        }
+        return words;
+      };
+      lunr2.TokenSet.prototype.toString = function() {
+        if (this._str) {
+          return this._str;
+        }
+        var str = this.final ? "1" : "0", labels = Object.keys(this.edges).sort(), len = labels.length;
+        for (var i = 0; i < len; i++) {
+          var label = labels[i], node = this.edges[label];
+          str = str + label + node.id;
+        }
+        return str;
+      };
+      lunr2.TokenSet.prototype.intersect = function(b) {
+        var output = new lunr2.TokenSet(), frame = void 0;
+        var stack = [{
+          qNode: b,
+          output,
+          node: this
+        }];
+        while (stack.length) {
+          frame = stack.pop();
+          var qEdges = Object.keys(frame.qNode.edges), qLen = qEdges.length, nEdges = Object.keys(frame.node.edges), nLen = nEdges.length;
+          for (var q = 0; q < qLen; q++) {
+            var qEdge = qEdges[q];
+            for (var n = 0; n < nLen; n++) {
+              var nEdge = nEdges[n];
+              if (nEdge == qEdge || qEdge == "*") {
+                var node = frame.node.edges[nEdge], qNode = frame.qNode.edges[qEdge], final = node.final && qNode.final, next = void 0;
+                if (nEdge in frame.output.edges) {
+                  next = frame.output.edges[nEdge];
+                  next.final = next.final || final;
+                } else {
+                  next = new lunr2.TokenSet();
+                  next.final = final;
+                  frame.output.edges[nEdge] = next;
+                }
+                stack.push({
+                  qNode,
+                  output: next,
+                  node
+                });
+              }
+            }
+          }
+        }
+        return output;
+      };
+      lunr2.TokenSet.Builder = function() {
+        this.previousWord = "";
+        this.root = new lunr2.TokenSet();
+        this.uncheckedNodes = [];
+        this.minimizedNodes = {};
+      };
+      lunr2.TokenSet.Builder.prototype.insert = function(word) {
+        var node, commonPrefix = 0;
+        if (word < this.previousWord) {
+          throw new Error("Out of order word insertion");
+        }
+        for (var i = 0; i < word.length && i < this.previousWord.length; i++) {
+          if (word[i] != this.previousWord[i]) break;
+          commonPrefix++;
+        }
+        this.minimize(commonPrefix);
+        if (this.uncheckedNodes.length == 0) {
+          node = this.root;
+        } else {
+          node = this.uncheckedNodes[this.uncheckedNodes.length - 1].child;
+        }
+        for (var i = commonPrefix; i < word.length; i++) {
+          var nextNode = new lunr2.TokenSet(), char = word[i];
+          node.edges[char] = nextNode;
+          this.uncheckedNodes.push({
+            parent: node,
+            char,
+            child: nextNode
+          });
+          node = nextNode;
+        }
+        node.final = true;
+        this.previousWord = word;
+      };
+      lunr2.TokenSet.Builder.prototype.finish = function() {
+        this.minimize(0);
+      };
+      lunr2.TokenSet.Builder.prototype.minimize = function(downTo) {
+        for (var i = this.uncheckedNodes.length - 1; i >= downTo; i--) {
+          var node = this.uncheckedNodes[i], childKey = node.child.toString();
+          if (childKey in this.minimizedNodes) {
+            node.parent.edges[node.char] = this.minimizedNodes[childKey];
+          } else {
+            node.child._str = childKey;
+            this.minimizedNodes[childKey] = node.child;
+          }
+          this.uncheckedNodes.pop();
+        }
+      };
+      lunr2.Index = function(attrs) {
+        this.invertedIndex = attrs.invertedIndex;
+        this.fieldVectors = attrs.fieldVectors;
+        this.tokenSet = attrs.tokenSet;
+        this.fields = attrs.fields;
+        this.pipeline = attrs.pipeline;
+      };
+      lunr2.Index.prototype.search = function(queryString) {
+        return this.query(function(query) {
+          var parser2 = new lunr2.QueryParser(queryString, query);
+          parser2.parse();
+        });
+      };
+      lunr2.Index.prototype.query = function(fn) {
+        var query = new lunr2.Query(this.fields), matchingFields = /* @__PURE__ */ Object.create(null), queryVectors = /* @__PURE__ */ Object.create(null), termFieldCache = /* @__PURE__ */ Object.create(null), requiredMatches = /* @__PURE__ */ Object.create(null), prohibitedMatches = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < this.fields.length; i++) {
+          queryVectors[this.fields[i]] = new lunr2.Vector();
+        }
+        fn.call(query, query);
+        for (var i = 0; i < query.clauses.length; i++) {
+          var clause = query.clauses[i], terms = null, clauseMatches = lunr2.Set.empty;
+          if (clause.usePipeline) {
+            terms = this.pipeline.runString(clause.term, {
+              fields: clause.fields
+            });
+          } else {
+            terms = [clause.term];
+          }
+          for (var m = 0; m < terms.length; m++) {
+            var term = terms[m];
+            clause.term = term;
+            var termTokenSet = lunr2.TokenSet.fromClause(clause), expandedTerms = this.tokenSet.intersect(termTokenSet).toArray();
+            if (expandedTerms.length === 0 && clause.presence === lunr2.Query.presence.REQUIRED) {
+              for (var k = 0; k < clause.fields.length; k++) {
+                var field = clause.fields[k];
+                requiredMatches[field] = lunr2.Set.empty;
+              }
+              break;
+            }
+            for (var j = 0; j < expandedTerms.length; j++) {
+              var expandedTerm = expandedTerms[j], posting = this.invertedIndex[expandedTerm], termIndex = posting._index;
+              for (var k = 0; k < clause.fields.length; k++) {
+                var field = clause.fields[k], fieldPosting = posting[field], matchingDocumentRefs = Object.keys(fieldPosting), termField = expandedTerm + "/" + field, matchingDocumentsSet = new lunr2.Set(matchingDocumentRefs);
+                if (clause.presence == lunr2.Query.presence.REQUIRED) {
+                  clauseMatches = clauseMatches.union(matchingDocumentsSet);
+                  if (requiredMatches[field] === void 0) {
+                    requiredMatches[field] = lunr2.Set.complete;
+                  }
+                }
+                if (clause.presence == lunr2.Query.presence.PROHIBITED) {
+                  if (prohibitedMatches[field] === void 0) {
+                    prohibitedMatches[field] = lunr2.Set.empty;
+                  }
+                  prohibitedMatches[field] = prohibitedMatches[field].union(matchingDocumentsSet);
+                  continue;
+                }
+                queryVectors[field].upsert(termIndex, clause.boost, function(a, b) {
+                  return a + b;
+                });
+                if (termFieldCache[termField]) {
+                  continue;
+                }
+                for (var l = 0; l < matchingDocumentRefs.length; l++) {
+                  var matchingDocumentRef = matchingDocumentRefs[l], matchingFieldRef = new lunr2.FieldRef(matchingDocumentRef, field), metadata = fieldPosting[matchingDocumentRef], fieldMatch;
+                  if ((fieldMatch = matchingFields[matchingFieldRef]) === void 0) {
+                    matchingFields[matchingFieldRef] = new lunr2.MatchData(expandedTerm, field, metadata);
+                  } else {
+                    fieldMatch.add(expandedTerm, field, metadata);
+                  }
+                }
+                termFieldCache[termField] = true;
+              }
+            }
+          }
+          if (clause.presence === lunr2.Query.presence.REQUIRED) {
+            for (var k = 0; k < clause.fields.length; k++) {
+              var field = clause.fields[k];
+              requiredMatches[field] = requiredMatches[field].intersect(clauseMatches);
+            }
+          }
+        }
+        var allRequiredMatches = lunr2.Set.complete, allProhibitedMatches = lunr2.Set.empty;
+        for (var i = 0; i < this.fields.length; i++) {
+          var field = this.fields[i];
+          if (requiredMatches[field]) {
+            allRequiredMatches = allRequiredMatches.intersect(requiredMatches[field]);
+          }
+          if (prohibitedMatches[field]) {
+            allProhibitedMatches = allProhibitedMatches.union(prohibitedMatches[field]);
+          }
+        }
+        var matchingFieldRefs = Object.keys(matchingFields), results = [], matches = /* @__PURE__ */ Object.create(null);
+        if (query.isNegated()) {
+          matchingFieldRefs = Object.keys(this.fieldVectors);
+          for (var i = 0; i < matchingFieldRefs.length; i++) {
+            var matchingFieldRef = matchingFieldRefs[i];
+            var fieldRef = lunr2.FieldRef.fromString(matchingFieldRef);
+            matchingFields[matchingFieldRef] = new lunr2.MatchData();
+          }
+        }
+        for (var i = 0; i < matchingFieldRefs.length; i++) {
+          var fieldRef = lunr2.FieldRef.fromString(matchingFieldRefs[i]), docRef = fieldRef.docRef;
+          if (!allRequiredMatches.contains(docRef)) {
+            continue;
+          }
+          if (allProhibitedMatches.contains(docRef)) {
+            continue;
+          }
+          var fieldVector = this.fieldVectors[fieldRef], score = queryVectors[fieldRef.fieldName].similarity(fieldVector), docMatch;
+          if ((docMatch = matches[docRef]) !== void 0) {
+            docMatch.score += score;
+            docMatch.matchData.combine(matchingFields[fieldRef]);
+          } else {
+            var match = {
+              ref: docRef,
+              score,
+              matchData: matchingFields[fieldRef]
+            };
+            matches[docRef] = match;
+            results.push(match);
+          }
+        }
+        return results.sort(function(a, b) {
+          return b.score - a.score;
+        });
+      };
+      lunr2.Index.prototype.toJSON = function() {
+        var invertedIndex = Object.keys(this.invertedIndex).sort().map(function(term) {
+          return [term, this.invertedIndex[term]];
+        }, this);
+        var fieldVectors = Object.keys(this.fieldVectors).map(function(ref) {
+          return [ref, this.fieldVectors[ref].toJSON()];
+        }, this);
+        return {
+          version: lunr2.version,
+          fields: this.fields,
+          fieldVectors,
+          invertedIndex,
+          pipeline: this.pipeline.toJSON()
+        };
+      };
+      lunr2.Index.load = function(serializedIndex) {
+        var attrs = {}, fieldVectors = {}, serializedVectors = serializedIndex.fieldVectors, invertedIndex = /* @__PURE__ */ Object.create(null), serializedInvertedIndex = serializedIndex.invertedIndex, tokenSetBuilder = new lunr2.TokenSet.Builder(), pipeline = lunr2.Pipeline.load(serializedIndex.pipeline);
+        if (serializedIndex.version != lunr2.version) {
+          lunr2.utils.warn("Version mismatch when loading serialised index. Current version of lunr '" + lunr2.version + "' does not match serialized index '" + serializedIndex.version + "'");
+        }
+        for (var i = 0; i < serializedVectors.length; i++) {
+          var tuple = serializedVectors[i], ref = tuple[0], elements = tuple[1];
+          fieldVectors[ref] = new lunr2.Vector(elements);
+        }
+        for (var i = 0; i < serializedInvertedIndex.length; i++) {
+          var tuple = serializedInvertedIndex[i], term = tuple[0], posting = tuple[1];
+          tokenSetBuilder.insert(term);
+          invertedIndex[term] = posting;
+        }
+        tokenSetBuilder.finish();
+        attrs.fields = serializedIndex.fields;
+        attrs.fieldVectors = fieldVectors;
+        attrs.invertedIndex = invertedIndex;
+        attrs.tokenSet = tokenSetBuilder.root;
+        attrs.pipeline = pipeline;
+        return new lunr2.Index(attrs);
+      };
+      lunr2.Builder = function() {
+        this._ref = "id";
+        this._fields = /* @__PURE__ */ Object.create(null);
+        this._documents = /* @__PURE__ */ Object.create(null);
+        this.invertedIndex = /* @__PURE__ */ Object.create(null);
+        this.fieldTermFrequencies = {};
+        this.fieldLengths = {};
+        this.tokenizer = lunr2.tokenizer;
+        this.pipeline = new lunr2.Pipeline();
+        this.searchPipeline = new lunr2.Pipeline();
+        this.documentCount = 0;
+        this._b = 0.75;
+        this._k1 = 1.2;
+        this.termIndex = 0;
+        this.metadataWhitelist = [];
+      };
+      lunr2.Builder.prototype.ref = function(ref) {
+        this._ref = ref;
+      };
+      lunr2.Builder.prototype.field = function(fieldName, attributes) {
+        if (/\//.test(fieldName)) {
+          throw new RangeError("Field '" + fieldName + "' contains illegal character '/'");
+        }
+        this._fields[fieldName] = attributes || {};
+      };
+      lunr2.Builder.prototype.b = function(number) {
+        if (number < 0) {
+          this._b = 0;
+        } else if (number > 1) {
+          this._b = 1;
+        } else {
+          this._b = number;
+        }
+      };
+      lunr2.Builder.prototype.k1 = function(number) {
+        this._k1 = number;
+      };
+      lunr2.Builder.prototype.add = function(doc2, attributes) {
+        var docRef = doc2[this._ref], fields = Object.keys(this._fields);
+        this._documents[docRef] = attributes || {};
+        this.documentCount += 1;
+        for (var i = 0; i < fields.length; i++) {
+          var fieldName = fields[i], extractor = this._fields[fieldName].extractor, field = extractor ? extractor(doc2) : doc2[fieldName], tokens = this.tokenizer(field, {
+            fields: [fieldName]
+          }), terms = this.pipeline.run(tokens), fieldRef = new lunr2.FieldRef(docRef, fieldName), fieldTerms = /* @__PURE__ */ Object.create(null);
+          this.fieldTermFrequencies[fieldRef] = fieldTerms;
+          this.fieldLengths[fieldRef] = 0;
+          this.fieldLengths[fieldRef] += terms.length;
+          for (var j = 0; j < terms.length; j++) {
+            var term = terms[j];
+            if (fieldTerms[term] == void 0) {
+              fieldTerms[term] = 0;
+            }
+            fieldTerms[term] += 1;
+            if (this.invertedIndex[term] == void 0) {
+              var posting = /* @__PURE__ */ Object.create(null);
+              posting["_index"] = this.termIndex;
+              this.termIndex += 1;
+              for (var k = 0; k < fields.length; k++) {
+                posting[fields[k]] = /* @__PURE__ */ Object.create(null);
+              }
+              this.invertedIndex[term] = posting;
+            }
+            if (this.invertedIndex[term][fieldName][docRef] == void 0) {
+              this.invertedIndex[term][fieldName][docRef] = /* @__PURE__ */ Object.create(null);
+            }
+            for (var l = 0; l < this.metadataWhitelist.length; l++) {
+              var metadataKey = this.metadataWhitelist[l], metadata = term.metadata[metadataKey];
+              if (this.invertedIndex[term][fieldName][docRef][metadataKey] == void 0) {
+                this.invertedIndex[term][fieldName][docRef][metadataKey] = [];
+              }
+              this.invertedIndex[term][fieldName][docRef][metadataKey].push(metadata);
+            }
+          }
+        }
+      };
+      lunr2.Builder.prototype.calculateAverageFieldLengths = function() {
+        var fieldRefs = Object.keys(this.fieldLengths), numberOfFields = fieldRefs.length, accumulator = {}, documentsWithField = {};
+        for (var i = 0; i < numberOfFields; i++) {
+          var fieldRef = lunr2.FieldRef.fromString(fieldRefs[i]), field = fieldRef.fieldName;
+          documentsWithField[field] || (documentsWithField[field] = 0);
+          documentsWithField[field] += 1;
+          accumulator[field] || (accumulator[field] = 0);
+          accumulator[field] += this.fieldLengths[fieldRef];
+        }
+        var fields = Object.keys(this._fields);
+        for (var i = 0; i < fields.length; i++) {
+          var fieldName = fields[i];
+          accumulator[fieldName] = accumulator[fieldName] / documentsWithField[fieldName];
+        }
+        this.averageFieldLength = accumulator;
+      };
+      lunr2.Builder.prototype.createFieldVectors = function() {
+        var fieldVectors = {}, fieldRefs = Object.keys(this.fieldTermFrequencies), fieldRefsLength = fieldRefs.length, termIdfCache = /* @__PURE__ */ Object.create(null);
+        for (var i = 0; i < fieldRefsLength; i++) {
+          var fieldRef = lunr2.FieldRef.fromString(fieldRefs[i]), fieldName = fieldRef.fieldName, fieldLength = this.fieldLengths[fieldRef], fieldVector = new lunr2.Vector(), termFrequencies = this.fieldTermFrequencies[fieldRef], terms = Object.keys(termFrequencies), termsLength = terms.length;
+          var fieldBoost = this._fields[fieldName].boost || 1, docBoost = this._documents[fieldRef.docRef].boost || 1;
+          for (var j = 0; j < termsLength; j++) {
+            var term = terms[j], tf = termFrequencies[term], termIndex = this.invertedIndex[term]._index, idf, score, scoreWithPrecision;
+            if (termIdfCache[term] === void 0) {
+              idf = lunr2.idf(this.invertedIndex[term], this.documentCount);
+              termIdfCache[term] = idf;
+            } else {
+              idf = termIdfCache[term];
+            }
+            score = idf * ((this._k1 + 1) * tf) / (this._k1 * (1 - this._b + this._b * (fieldLength / this.averageFieldLength[fieldName])) + tf);
+            score *= fieldBoost;
+            score *= docBoost;
+            scoreWithPrecision = Math.round(score * 1e3) / 1e3;
+            fieldVector.insert(termIndex, scoreWithPrecision);
+          }
+          fieldVectors[fieldRef] = fieldVector;
+        }
+        this.fieldVectors = fieldVectors;
+      };
+      lunr2.Builder.prototype.createTokenSet = function() {
+        this.tokenSet = lunr2.TokenSet.fromArray(
+          Object.keys(this.invertedIndex).sort()
+        );
+      };
+      lunr2.Builder.prototype.build = function() {
+        this.calculateAverageFieldLengths();
+        this.createFieldVectors();
+        this.createTokenSet();
+        return new lunr2.Index({
+          invertedIndex: this.invertedIndex,
+          fieldVectors: this.fieldVectors,
+          tokenSet: this.tokenSet,
+          fields: Object.keys(this._fields),
+          pipeline: this.searchPipeline
+        });
+      };
+      lunr2.Builder.prototype.use = function(fn) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        args.unshift(this);
+        fn.apply(this, args);
+      };
+      lunr2.MatchData = function(term, field, metadata) {
+        var clonedMetadata = /* @__PURE__ */ Object.create(null), metadataKeys = Object.keys(metadata || {});
+        for (var i = 0; i < metadataKeys.length; i++) {
+          var key = metadataKeys[i];
+          clonedMetadata[key] = metadata[key].slice();
+        }
+        this.metadata = /* @__PURE__ */ Object.create(null);
+        if (term !== void 0) {
+          this.metadata[term] = /* @__PURE__ */ Object.create(null);
+          this.metadata[term][field] = clonedMetadata;
+        }
+      };
+      lunr2.MatchData.prototype.combine = function(otherMatchData) {
+        var terms = Object.keys(otherMatchData.metadata);
+        for (var i = 0; i < terms.length; i++) {
+          var term = terms[i], fields = Object.keys(otherMatchData.metadata[term]);
+          if (this.metadata[term] == void 0) {
+            this.metadata[term] = /* @__PURE__ */ Object.create(null);
+          }
+          for (var j = 0; j < fields.length; j++) {
+            var field = fields[j], keys = Object.keys(otherMatchData.metadata[term][field]);
+            if (this.metadata[term][field] == void 0) {
+              this.metadata[term][field] = /* @__PURE__ */ Object.create(null);
+            }
+            for (var k = 0; k < keys.length; k++) {
+              var key = keys[k];
+              if (this.metadata[term][field][key] == void 0) {
+                this.metadata[term][field][key] = otherMatchData.metadata[term][field][key];
+              } else {
+                this.metadata[term][field][key] = this.metadata[term][field][key].concat(otherMatchData.metadata[term][field][key]);
+              }
+            }
+          }
+        }
+      };
+      lunr2.MatchData.prototype.add = function(term, field, metadata) {
+        if (!(term in this.metadata)) {
+          this.metadata[term] = /* @__PURE__ */ Object.create(null);
+          this.metadata[term][field] = metadata;
+          return;
+        }
+        if (!(field in this.metadata[term])) {
+          this.metadata[term][field] = metadata;
+          return;
+        }
+        var metadataKeys = Object.keys(metadata);
+        for (var i = 0; i < metadataKeys.length; i++) {
+          var key = metadataKeys[i];
+          if (key in this.metadata[term][field]) {
+            this.metadata[term][field][key] = this.metadata[term][field][key].concat(metadata[key]);
+          } else {
+            this.metadata[term][field][key] = metadata[key];
+          }
+        }
+      };
+      lunr2.Query = function(allFields) {
+        this.clauses = [];
+        this.allFields = allFields;
+      };
+      lunr2.Query.wildcard = new String("*");
+      lunr2.Query.wildcard.NONE = 0;
+      lunr2.Query.wildcard.LEADING = 1;
+      lunr2.Query.wildcard.TRAILING = 2;
+      lunr2.Query.presence = {
+        /**
+         * Term's presence in a document is optional, this is the default value.
+         */
+        OPTIONAL: 1,
+        /**
+         * Term's presence in a document is required, documents that do not contain
+         * this term will not be returned.
+         */
+        REQUIRED: 2,
+        /**
+         * Term's presence in a document is prohibited, documents that do contain
+         * this term will not be returned.
+         */
+        PROHIBITED: 3
+      };
+      lunr2.Query.prototype.clause = function(clause) {
+        if (!("fields" in clause)) {
+          clause.fields = this.allFields;
+        }
+        if (!("boost" in clause)) {
+          clause.boost = 1;
+        }
+        if (!("usePipeline" in clause)) {
+          clause.usePipeline = true;
+        }
+        if (!("wildcard" in clause)) {
+          clause.wildcard = lunr2.Query.wildcard.NONE;
+        }
+        if (clause.wildcard & lunr2.Query.wildcard.LEADING && clause.term.charAt(0) != lunr2.Query.wildcard) {
+          clause.term = "*" + clause.term;
+        }
+        if (clause.wildcard & lunr2.Query.wildcard.TRAILING && clause.term.slice(-1) != lunr2.Query.wildcard) {
+          clause.term = "" + clause.term + "*";
+        }
+        if (!("presence" in clause)) {
+          clause.presence = lunr2.Query.presence.OPTIONAL;
+        }
+        this.clauses.push(clause);
+        return this;
+      };
+      lunr2.Query.prototype.isNegated = function() {
+        for (var i = 0; i < this.clauses.length; i++) {
+          if (this.clauses[i].presence != lunr2.Query.presence.PROHIBITED) {
+            return false;
+          }
+        }
+        return true;
+      };
+      lunr2.Query.prototype.term = function(term, options2) {
+        if (Array.isArray(term)) {
+          term.forEach(function(t) {
+            this.term(t, lunr2.utils.clone(options2));
+          }, this);
+          return this;
+        }
+        var clause = options2 || {};
+        clause.term = term.toString();
+        this.clause(clause);
+        return this;
+      };
+      lunr2.QueryParseError = function(message, start, end) {
+        this.name = "QueryParseError";
+        this.message = message;
+        this.start = start;
+        this.end = end;
+      };
+      lunr2.QueryParseError.prototype = new Error();
+      lunr2.QueryLexer = function(str) {
+        this.lexemes = [];
+        this.str = str;
+        this.length = str.length;
+        this.pos = 0;
+        this.start = 0;
+        this.escapeCharPositions = [];
+      };
+      lunr2.QueryLexer.prototype.run = function() {
+        var state = lunr2.QueryLexer.lexText;
+        while (state) {
+          state = state(this);
+        }
+      };
+      lunr2.QueryLexer.prototype.sliceString = function() {
+        var subSlices = [], sliceStart = this.start, sliceEnd = this.pos;
+        for (var i = 0; i < this.escapeCharPositions.length; i++) {
+          sliceEnd = this.escapeCharPositions[i];
+          subSlices.push(this.str.slice(sliceStart, sliceEnd));
+          sliceStart = sliceEnd + 1;
+        }
+        subSlices.push(this.str.slice(sliceStart, this.pos));
+        this.escapeCharPositions.length = 0;
+        return subSlices.join("");
+      };
+      lunr2.QueryLexer.prototype.emit = function(type) {
+        this.lexemes.push({
+          type,
+          str: this.sliceString(),
+          start: this.start,
+          end: this.pos
+        });
+        this.start = this.pos;
+      };
+      lunr2.QueryLexer.prototype.escapeCharacter = function() {
+        this.escapeCharPositions.push(this.pos - 1);
+        this.pos += 1;
+      };
+      lunr2.QueryLexer.prototype.next = function() {
+        if (this.pos >= this.length) {
+          return lunr2.QueryLexer.EOS;
+        }
+        var char = this.str.charAt(this.pos);
+        this.pos += 1;
+        return char;
+      };
+      lunr2.QueryLexer.prototype.width = function() {
+        return this.pos - this.start;
+      };
+      lunr2.QueryLexer.prototype.ignore = function() {
+        if (this.start == this.pos) {
+          this.pos += 1;
+        }
+        this.start = this.pos;
+      };
+      lunr2.QueryLexer.prototype.backup = function() {
+        this.pos -= 1;
+      };
+      lunr2.QueryLexer.prototype.acceptDigitRun = function() {
+        var char, charCode;
+        do {
+          char = this.next();
+          charCode = char.charCodeAt(0);
+        } while (charCode > 47 && charCode < 58);
+        if (char != lunr2.QueryLexer.EOS) {
+          this.backup();
+        }
+      };
+      lunr2.QueryLexer.prototype.more = function() {
+        return this.pos < this.length;
+      };
+      lunr2.QueryLexer.EOS = "EOS";
+      lunr2.QueryLexer.FIELD = "FIELD";
+      lunr2.QueryLexer.TERM = "TERM";
+      lunr2.QueryLexer.EDIT_DISTANCE = "EDIT_DISTANCE";
+      lunr2.QueryLexer.BOOST = "BOOST";
+      lunr2.QueryLexer.PRESENCE = "PRESENCE";
+      lunr2.QueryLexer.lexField = function(lexer) {
+        lexer.backup();
+        lexer.emit(lunr2.QueryLexer.FIELD);
+        lexer.ignore();
+        return lunr2.QueryLexer.lexText;
+      };
+      lunr2.QueryLexer.lexTerm = function(lexer) {
+        if (lexer.width() > 1) {
+          lexer.backup();
+          lexer.emit(lunr2.QueryLexer.TERM);
+        }
+        lexer.ignore();
+        if (lexer.more()) {
+          return lunr2.QueryLexer.lexText;
+        }
+      };
+      lunr2.QueryLexer.lexEditDistance = function(lexer) {
+        lexer.ignore();
+        lexer.acceptDigitRun();
+        lexer.emit(lunr2.QueryLexer.EDIT_DISTANCE);
+        return lunr2.QueryLexer.lexText;
+      };
+      lunr2.QueryLexer.lexBoost = function(lexer) {
+        lexer.ignore();
+        lexer.acceptDigitRun();
+        lexer.emit(lunr2.QueryLexer.BOOST);
+        return lunr2.QueryLexer.lexText;
+      };
+      lunr2.QueryLexer.lexEOS = function(lexer) {
+        if (lexer.width() > 0) {
+          lexer.emit(lunr2.QueryLexer.TERM);
+        }
+      };
+      lunr2.QueryLexer.termSeparator = lunr2.tokenizer.separator;
+      lunr2.QueryLexer.lexText = function(lexer) {
+        while (true) {
+          var char = lexer.next();
+          if (char == lunr2.QueryLexer.EOS) {
+            return lunr2.QueryLexer.lexEOS;
+          }
+          if (char.charCodeAt(0) == 92) {
+            lexer.escapeCharacter();
+            continue;
+          }
+          if (char == ":") {
+            return lunr2.QueryLexer.lexField;
+          }
+          if (char == "~") {
+            lexer.backup();
+            if (lexer.width() > 0) {
+              lexer.emit(lunr2.QueryLexer.TERM);
+            }
+            return lunr2.QueryLexer.lexEditDistance;
+          }
+          if (char == "^") {
+            lexer.backup();
+            if (lexer.width() > 0) {
+              lexer.emit(lunr2.QueryLexer.TERM);
+            }
+            return lunr2.QueryLexer.lexBoost;
+          }
+          if (char == "+" && lexer.width() === 1) {
+            lexer.emit(lunr2.QueryLexer.PRESENCE);
+            return lunr2.QueryLexer.lexText;
+          }
+          if (char == "-" && lexer.width() === 1) {
+            lexer.emit(lunr2.QueryLexer.PRESENCE);
+            return lunr2.QueryLexer.lexText;
+          }
+          if (char.match(lunr2.QueryLexer.termSeparator)) {
+            return lunr2.QueryLexer.lexTerm;
+          }
+        }
+      };
+      lunr2.QueryParser = function(str, query) {
+        this.lexer = new lunr2.QueryLexer(str);
+        this.query = query;
+        this.currentClause = {};
+        this.lexemeIdx = 0;
+      };
+      lunr2.QueryParser.prototype.parse = function() {
+        this.lexer.run();
+        this.lexemes = this.lexer.lexemes;
+        var state = lunr2.QueryParser.parseClause;
+        while (state) {
+          state = state(this);
+        }
+        return this.query;
+      };
+      lunr2.QueryParser.prototype.peekLexeme = function() {
+        return this.lexemes[this.lexemeIdx];
+      };
+      lunr2.QueryParser.prototype.consumeLexeme = function() {
+        var lexeme = this.peekLexeme();
+        this.lexemeIdx += 1;
+        return lexeme;
+      };
+      lunr2.QueryParser.prototype.nextClause = function() {
+        var completedClause = this.currentClause;
+        this.query.clause(completedClause);
+        this.currentClause = {};
+      };
+      lunr2.QueryParser.parseClause = function(parser2) {
+        var lexeme = parser2.peekLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        switch (lexeme.type) {
+          case lunr2.QueryLexer.PRESENCE:
+            return lunr2.QueryParser.parsePresence;
+          case lunr2.QueryLexer.FIELD:
+            return lunr2.QueryParser.parseField;
+          case lunr2.QueryLexer.TERM:
+            return lunr2.QueryParser.parseTerm;
+          default:
+            var errorMessage = "expected either a field or a term, found " + lexeme.type;
+            if (lexeme.str.length >= 1) {
+              errorMessage += " with value '" + lexeme.str + "'";
+            }
+            throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+      };
+      lunr2.QueryParser.parsePresence = function(parser2) {
+        var lexeme = parser2.consumeLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        switch (lexeme.str) {
+          case "-":
+            parser2.currentClause.presence = lunr2.Query.presence.PROHIBITED;
+            break;
+          case "+":
+            parser2.currentClause.presence = lunr2.Query.presence.REQUIRED;
+            break;
+          default:
+            var errorMessage = "unrecognised presence operator'" + lexeme.str + "'";
+            throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        var nextLexeme = parser2.peekLexeme();
+        if (nextLexeme == void 0) {
+          var errorMessage = "expecting term or field, found nothing";
+          throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        switch (nextLexeme.type) {
+          case lunr2.QueryLexer.FIELD:
+            return lunr2.QueryParser.parseField;
+          case lunr2.QueryLexer.TERM:
+            return lunr2.QueryParser.parseTerm;
+          default:
+            var errorMessage = "expecting term or field, found '" + nextLexeme.type + "'";
+            throw new lunr2.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);
+        }
+      };
+      lunr2.QueryParser.parseField = function(parser2) {
+        var lexeme = parser2.consumeLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        if (parser2.query.allFields.indexOf(lexeme.str) == -1) {
+          var possibleFields = parser2.query.allFields.map(function(f) {
+            return "'" + f + "'";
+          }).join(", "), errorMessage = "unrecognised field '" + lexeme.str + "', possible fields: " + possibleFields;
+          throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        parser2.currentClause.fields = [lexeme.str];
+        var nextLexeme = parser2.peekLexeme();
+        if (nextLexeme == void 0) {
+          var errorMessage = "expecting term, found nothing";
+          throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        switch (nextLexeme.type) {
+          case lunr2.QueryLexer.TERM:
+            return lunr2.QueryParser.parseTerm;
+          default:
+            var errorMessage = "expecting term, found '" + nextLexeme.type + "'";
+            throw new lunr2.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);
+        }
+      };
+      lunr2.QueryParser.parseTerm = function(parser2) {
+        var lexeme = parser2.consumeLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        parser2.currentClause.term = lexeme.str.toLowerCase();
+        if (lexeme.str.indexOf("*") != -1) {
+          parser2.currentClause.usePipeline = false;
+        }
+        var nextLexeme = parser2.peekLexeme();
+        if (nextLexeme == void 0) {
+          parser2.nextClause();
+          return;
+        }
+        switch (nextLexeme.type) {
+          case lunr2.QueryLexer.TERM:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseTerm;
+          case lunr2.QueryLexer.FIELD:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseField;
+          case lunr2.QueryLexer.EDIT_DISTANCE:
+            return lunr2.QueryParser.parseEditDistance;
+          case lunr2.QueryLexer.BOOST:
+            return lunr2.QueryParser.parseBoost;
+          case lunr2.QueryLexer.PRESENCE:
+            parser2.nextClause();
+            return lunr2.QueryParser.parsePresence;
+          default:
+            var errorMessage = "Unexpected lexeme type '" + nextLexeme.type + "'";
+            throw new lunr2.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);
+        }
+      };
+      lunr2.QueryParser.parseEditDistance = function(parser2) {
+        var lexeme = parser2.consumeLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        var editDistance = parseInt(lexeme.str, 10);
+        if (isNaN(editDistance)) {
+          var errorMessage = "edit distance must be numeric";
+          throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        parser2.currentClause.editDistance = editDistance;
+        var nextLexeme = parser2.peekLexeme();
+        if (nextLexeme == void 0) {
+          parser2.nextClause();
+          return;
+        }
+        switch (nextLexeme.type) {
+          case lunr2.QueryLexer.TERM:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseTerm;
+          case lunr2.QueryLexer.FIELD:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseField;
+          case lunr2.QueryLexer.EDIT_DISTANCE:
+            return lunr2.QueryParser.parseEditDistance;
+          case lunr2.QueryLexer.BOOST:
+            return lunr2.QueryParser.parseBoost;
+          case lunr2.QueryLexer.PRESENCE:
+            parser2.nextClause();
+            return lunr2.QueryParser.parsePresence;
+          default:
+            var errorMessage = "Unexpected lexeme type '" + nextLexeme.type + "'";
+            throw new lunr2.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);
+        }
+      };
+      lunr2.QueryParser.parseBoost = function(parser2) {
+        var lexeme = parser2.consumeLexeme();
+        if (lexeme == void 0) {
+          return;
+        }
+        var boost = parseInt(lexeme.str, 10);
+        if (isNaN(boost)) {
+          var errorMessage = "boost must be numeric";
+          throw new lunr2.QueryParseError(errorMessage, lexeme.start, lexeme.end);
+        }
+        parser2.currentClause.boost = boost;
+        var nextLexeme = parser2.peekLexeme();
+        if (nextLexeme == void 0) {
+          parser2.nextClause();
+          return;
+        }
+        switch (nextLexeme.type) {
+          case lunr2.QueryLexer.TERM:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseTerm;
+          case lunr2.QueryLexer.FIELD:
+            parser2.nextClause();
+            return lunr2.QueryParser.parseField;
+          case lunr2.QueryLexer.EDIT_DISTANCE:
+            return lunr2.QueryParser.parseEditDistance;
+          case lunr2.QueryLexer.BOOST:
+            return lunr2.QueryParser.parseBoost;
+          case lunr2.QueryLexer.PRESENCE:
+            parser2.nextClause();
+            return lunr2.QueryParser.parsePresence;
+          default:
+            var errorMessage = "Unexpected lexeme type '" + nextLexeme.type + "'";
+            throw new lunr2.QueryParseError(errorMessage, nextLexeme.start, nextLexeme.end);
+        }
+      };
+      (function(root, factory) {
+        if (typeof define === "function" && define.amd) {
+          define(factory);
+        } else if (typeof exports2 === "object") {
+          module.exports = factory();
+        } else {
+          root.lunr = factory();
+        }
+      })(this, function() {
+        return lunr2;
+      });
+    })();
+  }
+});
+
 // ../reporter/src/console-reporter.ts
 import { writeFile } from "node:fs/promises";
 import { blue, gray, green, red, yellow, yellowBright } from "colorette";
@@ -5537,29 +7268,17 @@ import { blue, gray, green, red, yellow, yellowBright } from "colorette";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-function resolvePackageJson() {
-  try {
-    const currentModulePath = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentModulePath);
-    const packageRoot = join(currentDir, "..");
-    const packageJsonPath = join(packageRoot, "package.json");
-    return packageJsonPath;
-  } catch (error) {
-    throw new Error(`Unable to resolve package.json path: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-function readPackage() {
-  try {
-    const packagePath = resolvePackageJson();
-    const content = readFileSync(packagePath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to read package.json: ${message}`);
-  }
+function getPackageVersion() {
+  if (true) {
+    return "4.0.0-beta.42";
+  }
+  const currentModulePath = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentModulePath);
+  const packageJsonPath = join(currentDir, "..", "package.json");
+  const content = readFileSync(packageJsonPath, "utf-8");
+  return JSON.parse(content).version;
 }
-var PACKAGE = readPackage();
-var PACKAGE_VERSION = PACKAGE.version;
+var PACKAGE_VERSION = getPackageVersion();
 
 // ../reporter/src/types/problem.ts
 var ProblemCategory = /* @__PURE__ */ ((ProblemCategory2) => {
@@ -6445,32 +8164,20 @@ import { readFileSync as readFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var NEW_LINE_REG_EXP = /[\n\r]+/g;
-function resolvePackageJson2() {
-  try {
-    const currentModulePath = fileURLToPath2(import.meta.url);
-    const currentDir = dirname2(currentModulePath);
-    const packageRoot = join2(currentDir, "..");
-    const packageJsonPath = join2(packageRoot, "package.json");
-    return packageJsonPath;
-  } catch (error) {
-    throw new Error(`Unable to resolve package.json path: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-function readPackageSync() {
-  try {
-    const packagePath = resolvePackageJson2();
-    const content = readFileSync2(packagePath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to read package.json: ${message}`);
-  }
+function getPackageVersion2() {
+  if (true) {
+    return "4.0.0-beta.42";
+  }
+  const currentModulePath = fileURLToPath2(import.meta.url);
+  const currentDir = dirname2(currentModulePath);
+  const packageJsonPath = join2(currentDir, "..", "package.json");
+  const content = readFileSync2(packageJsonPath, "utf-8");
+  return JSON.parse(content).version;
 }
-var PACKAGE2 = readPackageSync();
 var APP_NAME = "ts-for-gir";
 var APP_USAGE = "TypeScript type definition generator for GObject introspection GIR files";
 var APP_SOURCE = "https://github.com/gjsify/ts-for-gir";
-var APP_VERSION = PACKAGE2.version;
+var APP_VERSION = getPackageVersion2();
 var PACKAGE_DESC = (packageName, libraryVersion) => {
   if (libraryVersion) {
     return `GJS TypeScript type definitions for ${packageName}, generated from library version ${libraryVersion.toString()}`;
@@ -6491,7 +8198,7 @@ __export(parser_exports, {
   parseGir: () => parseGir
 });
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/util.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.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 + "]*";
@@ -6532,7 +8239,7 @@ var DANGEROUS_PROPERTY_NAMES = [
 ];
 var criticalProperties = ["__proto__", "constructor", "prototype"];
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/validator.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/validator.js
 var defaultOptions = {
   allowBooleanAttributes: false,
   //A tag can have attributes without any value
@@ -6838,7 +8545,7 @@ function getPositionFromMatch(match) {
   return match.startIndex + match[1].length;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
 var defaultOnDangerousProperty = (name) => {
   if (DANGEROUS_PROPERTY_NAMES.includes(name)) {
     return "__" + name;
@@ -6968,7 +8675,7 @@ var buildOptions = function(options2) {
   return built;
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
 var METADATA_SYMBOL;
 if (typeof Symbol !== "function") {
   METADATA_SYMBOL = "@@xmlMetadata";
@@ -7002,7 +8709,7 @@ var XmlNode = class {
   }
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
 var DocTypeReader = class {
   constructor(options2) {
     this.suppressValidationErr = !options2;
@@ -7403,7 +9110,7 @@ function handleInfinity(str, num, options2) {
   }
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/ignoreAttributes.js
 function getIgnoreAttributesFn(ignoreAttributes) {
   if (typeof ignoreAttributes === "function") {
     return ignoreAttributes;
@@ -7423,7 +9130,7 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 
-// ../../.yarn/cache/path-expression-matcher-npm-1.1.3-ea64bf895d-9a607d0bf9.zip/node_modules/path-expression-matcher/src/Expression.js
+// ../../.yarn/cache/path-expression-matcher-npm-1.2.0-0a1470212e-eab23babd9.zip/node_modules/path-expression-matcher/src/Expression.js
 var Expression = class {
   /**
    * Create a new Expression
@@ -7585,7 +9292,8 @@ var Expression = class {
   }
 };
 
-// ../../.yarn/cache/path-expression-matcher-npm-1.1.3-ea64bf895d-9a607d0bf9.zip/node_modules/path-expression-matcher/src/Matcher.js
+// ../../.yarn/cache/path-expression-matcher-npm-1.2.0-0a1470212e-eab23babd9.zip/node_modules/path-expression-matcher/src/Matcher.js
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["push", "pop", "reset", "updateCurrent", "restore"]);
 var Matcher = class {
   /**
    * Create a new Matcher
@@ -7894,9 +9602,69 @@ var Matcher = class {
     this.path = snapshot.path.map((node) => ({ ...node }));
     this.siblingStacks = snapshot.siblingStacks.map((map2) => new Map(map2));
   }
+  /**
+   * Return a read-only view of 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.
+   *
+   * @returns {ReadOnlyMatcher} A proxy that forwards read operations and blocks writes.
+   *
+   * @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
+   */
+  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.`
+        );
+      }
+    });
+  }
 };
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.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;
@@ -7967,6 +9735,7 @@ var OrderedObjParser = class {
     this.entityExpansionCount = 0;
     this.currentExpandedLength = 0;
     this.matcher = new Matcher();
+    this.readonlyMatcher = this.matcher.readOnly();
     this.isCurrentNodeStopNode = false;
     if (this.options.stopNodes && this.options.stopNodes.length > 0) {
       this.stopNodeExpressions = [];
@@ -8046,7 +9815,7 @@ function buildAttributesMap(attrStr, jPath, tagName) {
         if (this.options.trimValues) {
           parsedVal = parsedVal.trim();
         }
-        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, jPath);
+        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, this.readonlyMatcher);
         rawAttrsForMatcher[attrName] = parsedVal;
       }
     }
@@ -8055,7 +9824,7 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     }
     for (let i = 0; i < len; i++) {
       const attrName = this.resolveNameSpace(matches[i][1]);
-      const jPathStr = this.options.jPath ? jPath.toString() : jPath;
+      const jPathStr = this.options.jPath ? jPath.toString() : this.readonlyMatcher;
       if (this.ignoreAttributesFn(attrName, jPathStr)) {
         continue;
       }
@@ -8070,8 +9839,8 @@ function buildAttributesMap(attrStr, jPath, tagName) {
           if (this.options.trimValues) {
             oldVal = oldVal.trim();
           }
-          oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
-          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+          oldVal = this.replaceEntitiesValue(oldVal, tagName, this.readonlyMatcher);
+          const jPathOrMatcher = this.options.jPath ? jPath.toString() : this.readonlyMatcher;
           const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);
           if (newVal === null || newVal === void 0) {
             attrs[aName] = oldVal;
@@ -8123,7 +9892,7 @@ var parseXml = function(xmlData) {
         }
         tagName = transformTagName(this.options.transformTagName, tagName, "", this.options).tagName;
         if (currentNode) {
-          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
+          textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
         }
         const lastTagName = this.matcher.getCurrentTag();
         if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
@@ -8141,7 +9910,7 @@ var parseXml = function(xmlData) {
       } else if (xmlData[i + 1] === "?") {
         let tagData = readTagExp(xmlData, i, false, "?>");
         if (!tagData) throw new Error("Pi Tag is not closed.");
-        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
+        textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
         if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {
         } else {
           const childNode = new XmlNode(tagData.tagName);
@@ -8149,14 +9918,14 @@ var parseXml = function(xmlData) {
           if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
             childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
           }
-          this.addChild(currentNode, childNode, this.matcher, i);
+          this.addChild(currentNode, childNode, this.readonlyMatcher, i);
         }
         i = tagData.closeIndex + 1;
       } else if (xmlData.substr(i + 1, 3) === "!--") {
         const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
         if (this.options.commentPropName) {
           const comment = xmlData.substring(i + 4, endIndex - 2);
-          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
+          textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
           currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
         }
         i = endIndex;
@@ -8167,8 +9936,8 @@ var parseXml = function(xmlData) {
       } else if (xmlData.substr(i + 1, 2) === "![") {
         const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
         const tagExp = xmlData.substring(i + 9, closeIndex);
-        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
-        let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);
+        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 }]);
@@ -8193,7 +9962,7 @@ var parseXml = function(xmlData) {
         }
         if (currentNode && textData) {
           if (currentNode.tagname !== "!xml") {
-            textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);
+            textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher, false);
           }
         }
         const lastTag = currentNode;
@@ -8248,7 +10017,7 @@ var parseXml = function(xmlData) {
           childNode.add(this.options.textNodeName, tagContent);
           this.matcher.pop();
           this.isCurrentNodeStopNode = false;
-          this.addChild(currentNode, childNode, this.matcher, startIndex);
+          this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
         } else {
           if (isSelfClosing) {
             ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
@@ -8256,7 +10025,7 @@ var parseXml = function(xmlData) {
             if (prefixedAttrs) {
               childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
+            this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
             this.matcher.pop();
             this.isCurrentNodeStopNode = false;
           } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
@@ -8264,7 +10033,7 @@ var parseXml = function(xmlData) {
             if (prefixedAttrs) {
               childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
+            this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
             this.matcher.pop();
             this.isCurrentNodeStopNode = false;
             i = result.closeIndex;
@@ -8278,7 +10047,7 @@ var parseXml = function(xmlData) {
             if (prefixedAttrs) {
               childNode[":@"] = prefixedAttrs;
             }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
+            this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
             currentNode = childNode;
           }
           textData = "";
@@ -8548,7 +10317,7 @@ function sanitizeName(name, options2) {
   return name;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/node2json.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.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 {};
@@ -8564,10 +10333,10 @@ function stripAttributePrefix(attrs, prefix) {
   }
   return rawAttrs;
 }
-function prettify(node, options2, matcher) {
-  return compress(node, options2, matcher);
+function prettify(node, options2, matcher, readonlyMatcher) {
+  return compress(node, options2, matcher, readonlyMatcher);
 }
-function compress(arr, options2, matcher) {
+function compress(arr, options2, matcher, readonlyMatcher) {
   let text;
   const compressedObj = {};
   for (let i = 0; i < arr.length; i++) {
@@ -8586,10 +10355,10 @@ function compress(arr, options2, matcher) {
     } else if (property === void 0) {
       continue;
     } else if (tagObj[property]) {
-      let val = compress(tagObj[property], options2, matcher);
+      let val = compress(tagObj[property], options2, matcher, readonlyMatcher);
       const isLeaf = isLeafTag(val, options2);
       if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], matcher, options2);
+        assignAttributes(val, tagObj[":@"], readonlyMatcher, options2);
       } else if (Object.keys(val).length === 1 && val[options2.textNodeName] !== void 0 && !options2.alwaysCreateTextNode) {
         val = val[options2.textNodeName];
       } else if (Object.keys(val).length === 0) {
@@ -8605,7 +10374,7 @@ function compress(arr, options2, matcher) {
         }
         compressedObj[property].push(val);
       } else {
-        const jPathOrMatcher = options2.jPath ? matcher.toString() : matcher;
+        const jPathOrMatcher = options2.jPath ? readonlyMatcher.toString() : readonlyMatcher;
         if (options2.isArray(property, jPathOrMatcher, isLeaf)) {
           compressedObj[property] = [val];
         } else {
@@ -8629,14 +10398,14 @@ function propName(obj) {
     if (key !== ":@") return key;
   }
 }
-function assignAttributes(obj, attrMap, matcher, options2) {
+function assignAttributes(obj, attrMap, readonlyMatcher, options2) {
   if (attrMap) {
     const keys = Object.keys(attrMap);
     const len = keys.length;
     for (let i = 0; i < len; i++) {
       const atrrName = keys[i];
       const rawAttrName = atrrName.startsWith(options2.attributeNamePrefix) ? atrrName.substring(options2.attributeNamePrefix.length) : atrrName;
-      const jPathOrMatcher = options2.jPath ? matcher.toString() + "." + rawAttrName : matcher;
+      const jPathOrMatcher = options2.jPath ? readonlyMatcher.toString() + "." + rawAttrName : readonlyMatcher;
       if (options2.isArray(atrrName, jPathOrMatcher, true, true)) {
         obj[atrrName] = [attrMap[atrrName]];
       } else {
@@ -8657,7 +10426,7 @@ function isLeafTag(obj, options2) {
   return false;
 }
 
-// ../../.yarn/cache/fast-xml-parser-npm-5.5.7-d3593c54f5-b69e65cb1c.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+// ../../.yarn/cache/fast-xml-parser-npm-5.5.8-4d571da1cb-888f9a5d34.zip/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
 var XMLParser = class {
   constructor(options2) {
     this.externalEntities = {};
@@ -8685,7 +10454,7 @@ var XMLParser = class {
     orderedObjParser.addExternalEntities(this.externalEntities);
     const orderedResult = orderedObjParser.parseXml(xmlData);
     if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
-    else return prettify(orderedResult, this.options, orderedObjParser.matcher);
+    else return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
   }
   /**
    * Add Entity which is not by default supported by this library
@@ -18857,7 +20626,7 @@ var copy = {
 
 // ../generator-html-doc/src/html-doc-generator.ts
 import { mkdir as mkdir4 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // ../generator-json/src/gir-metadata-deserializer.ts
 import { DeclarationReflection } from "typedoc";
@@ -21477,6 +23246,7 @@ import {
   Application,
   Converter,
   normalizePath,
+  ReferenceReflection,
   ReflectionCategory,
   Serializer,
   TSConfigReader
@@ -21805,7 +23575,7 @@ var TypeDocPipeline = class {
    * converts each package separately, then merges them into one ProjectReflection.
    */
   async createCombinedTypeDocApp() {
-    return this.bootstrapAndConvert(
+    const result = await this.bootstrapAndConvert(
       {
         entryPoints: [join10(this.tempDir, "*")],
         entryPointStrategy: "packages",
@@ -21819,6 +23589,8 @@ var TypeDocPipeline = class {
       },
       [new TSConfigReader()]
     );
+    this.fixExportImportReferences(result.project);
+    return result;
   }
   /**
    * Bootstrap a TypeDoc Application using the "merge" entry point strategy.
@@ -21837,7 +23609,9 @@ var TypeDocPipeline = class {
       []
     );
     app.deserializer.addDeserializer(new GirMetadataDeserializer());
-    return this.convertApp(app, "merged documentation");
+    const result = await this.convertApp(app, "merged documentation");
+    this.fixExportImportReferences(result.project);
+    return result;
   }
   async cleanup() {
     if (this.tempDir) {
@@ -22027,6 +23801,56 @@ var TypeDocPipeline = class {
     const dotIdx = name.indexOf(".");
     return dotIdx > 0 ? name.slice(0, dotIdx) : name;
   }
+  /**
+   * Fix ReferenceReflection targets broken by TypeDoc's handling of
+   * `export import X = Y.Z` statements.
+   *
+   * TypeDoc may resolve all such re-exports within a namespace to the same
+   * target reflection (e.g. every Cairo enum points to Status). This method
+   * detects the mismatch and corrects each reference's internal target ID.
+   */
+  fixExportImportReferences(project) {
+    const refsByTargetId = /* @__PURE__ */ new Map();
+    for (const r of Object.values(project.reflections)) {
+      if (!(r instanceof ReferenceReflection)) continue;
+      const target = r.tryGetTargetReflectionDeep();
+      if (!target) continue;
+      let list2 = refsByTargetId.get(target.id);
+      if (!list2) {
+        list2 = [];
+        refsByTargetId.set(target.id, list2);
+      }
+      list2.push(r);
+    }
+    const brokenTargetIds = /* @__PURE__ */ new Set();
+    for (const [targetId, refs] of refsByTargetId) {
+      const distinctNames = new Set(refs.map((r) => r.name));
+      if (distinctNames.size > 1) {
+        brokenTargetIds.add(targetId);
+      }
+    }
+    if (brokenTargetIds.size === 0) return;
+    const nonRefByName = /* @__PURE__ */ new Map();
+    for (const refl of Object.values(project.reflections)) {
+      if (refl.isReference()) continue;
+      let list2 = nonRefByName.get(refl.name);
+      if (!list2) {
+        list2 = [];
+        nonRefByName.set(refl.name, list2);
+      }
+      list2.push({ id: refl.id, kind: refl.kind });
+    }
+    for (const r of Object.values(project.reflections)) {
+      if (!(r instanceof ReferenceReflection)) continue;
+      const target = r.tryGetTargetReflectionDeep();
+      if (!target || target.name === r.name) continue;
+      if (!brokenTargetIds.has(target.id)) continue;
+      const candidates = nonRefByName.get(r.name);
+      if (!candidates?.length) continue;
+      const correctTarget = candidates.find((c) => c.kind === target.kind) ?? candidates[0];
+      r._target = correctTarget.id;
+    }
+  }
   /** Register GIR metadata serializer and namespace-level metadata on a TypeDoc app. */
   registerGirMetadata(app, module) {
     const index = buildGirLookupIndex(module);
@@ -22186,8 +24010,8 @@ var JsonDefinitionGenerator = class _JsonDefinitionGenerator {
 };
 
 // ../typedoc-theme/src/theme.ts
-import { copyFileSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { copyFileSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { DefaultTheme, RendererEvent } from "typedoc";
 
@@ -22307,7 +24131,7 @@ function getGirNamespaceMetadata(reflection) {
   const mod = findOwningModule(reflection) ?? reflection;
   return mod.girNamespaceMetadata;
 }
-var COMPANION_OWNER_KINDS = ReflectionKind.Class | ReflectionKind.Interface;
+var COMPANION_OWNER_KINDS = ReflectionKind.Class | ReflectionKind.Interface | ReflectionKind.Enum;
 function findCompanionNamespace(refl) {
   if (!refl.kindOf(COMPANION_OWNER_KINDS)) return void 0;
   const parent = refl.parent;
@@ -22458,6 +24282,99 @@ var giDocgenHeader = (context, props) => {
 
 // ../typedoc-theme/src/partials/layout.ts
 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 { deflateSync, inflateSync } from "node:zlib";
+var KIND_MODULE = 2;
+function sanitizeModuleName(name) {
+  return name.toLowerCase().replace(/[/\\]/g, "_");
+}
+function getModuleName(row, moduleNames) {
+  if (row.kind === KIND_MODULE) return row.name;
+  if (!row.parent) return void 0;
+  for (const mod of moduleNames) {
+    if (row.parent === mod || row.parent.startsWith(`${mod}.`)) {
+      return mod;
+    }
+  }
+  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 });
+  for (let i = 0; i < rows.length; i++) {
+    builder7.add({ id: i, name: rows[i].name });
+  }
+  const index = builder7.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 match = raw.match(/window\.searchData\s*=\s*"([^"]+)"/);
+  if (!match?.[1]) {
+    throw new Error("Could not extract searchData from search.js");
+  }
+  const decoded = Buffer.from(match[1], "base64");
+  const decompressed = inflateSync(decoded);
+  return JSON.parse(decompressed.toString("utf-8"));
+}
+async function splitSearchIndex(outputDir) {
+  const assetsDir = join12(outputDir, "assets");
+  let searchData;
+  try {
+    searchData = readSearchData(assetsDir);
+  } catch {
+    return;
+  }
+  const { rows } = searchData;
+  const moduleNames = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.kind === KIND_MODULE) {
+      moduleNames.add(row.name);
+    }
+  }
+  const moduleMap = /* @__PURE__ */ new Map();
+  const moduleEntries = [];
+  for (const row of rows) {
+    if (row.kind === KIND_MODULE) {
+      moduleEntries.push(row);
+    }
+    const mod = getModuleName(row, moduleNames);
+    if (!mod) continue;
+    let bucket = moduleMap.get(mod);
+    if (!bucket) {
+      bucket = [];
+      moduleMap.set(mod, bucket);
+    }
+    bucket.push(row);
+  }
+  for (const [moduleName, moduleRows] of moduleMap) {
+    const chunk = buildChunk(moduleRows);
+    const filename = `search-${sanitizeModuleName(moduleName)}.js`;
+    writeFileSync2(join12(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;");
+  const totalChunks = moduleMap.size + 1;
+  console.log(`[search-splitter] Split ${rows.length} entries into ${totalChunks} chunks (${moduleMap.size} modules)`);
+}
+
+// ../typedoc-theme/src/partials/layout.ts
+function getSearchScript(props) {
+  const owningModule = findOwningModule(props.model);
+  if (owningModule) {
+    return `assets/search-${sanitizeModuleName(owningModule.name)}.js`;
+  }
+  return "assets/search-modules.js";
+}
 var giDocgenLayout = (context, template, props) => JSX3.createElement(
   "html",
   { class: "default", lang: context.options.getValue("lang"), "data-base": context.relativeURL("./") },
@@ -22508,7 +24425,7 @@ var giDocgenLayout = (context, template, props) => JSX3.createElement(
     }),
     JSX3.createElement("script", {
       async: true,
-      src: context.relativeURL("assets/search.js", true),
+      src: context.relativeURL(getSearchScript(props), true),
       id: "tsd-search-script"
     }),
     JSX3.createElement("script", {
@@ -22566,7 +24483,7 @@ var giDocgenLayout = (context, template, props) => JSX3.createElement(
 // ../typedoc-theme/src/partials/module-reflection.ts
 import {
   JSX as JSX4,
-  ReferenceReflection,
+  ReferenceReflection as ReferenceReflection2,
   ReflectionKind as ReflectionKind3
 } from "typedoc";
 function isNoneSection(section) {
@@ -22669,11 +24586,12 @@ function giDocgenModuleReflection(context, mod) {
   if (mod.isDeclaration() && isCompanionNamespace(mod)) {
     const parent = mod.parent;
     const siblings = parent && "children" in parent ? parent.children : void 0;
-    const companionClass = siblings?.find(
-      (child) => child !== mod && child.kindOf(ReflectionKind3.Class) && child.name === mod.name
+    const companionOwner = siblings?.find(
+      (child) => child !== mod && child.kindOf(ReflectionKind3.Class | ReflectionKind3.Interface | ReflectionKind3.Enum) && child.name === mod.name
     );
-    if (companionClass) {
-      const classUrl = context.urlTo(companionClass);
+    if (companionOwner) {
+      const ownerUrl = context.urlTo(companionOwner);
+      const kindName = companionOwner.kindOf(ReflectionKind3.Enum) ? "enum" : companionOwner.kindOf(ReflectionKind3.Interface) ? "interface" : "class";
       return JSX4.createElement(
         JSX4.Fragment,
         null,
@@ -22681,13 +24599,13 @@ function giDocgenModuleReflection(context, mod) {
           "p",
           null,
           "This namespace is a companion to the ",
-          JSX4.createElement("a", { href: classUrl }, companionClass.name),
-          " class. See the class page for full documentation."
+          JSX4.createElement("a", { href: ownerUrl }, companionOwner.name),
+          ` ${kindName}. See the ${kindName} page for full documentation.`
         ),
         JSX4.createElement(
           "script",
           null,
-          JSX4.createElement(JSX4.Raw, { html: `window.location.replace("${classUrl}");` })
+          JSX4.createElement(JSX4.Raw, { html: `window.location.replace("${ownerUrl}");` })
         )
       );
     }
@@ -22797,12 +24715,12 @@ function giDocgenModuleMemberSummary(context, member) {
   context.page.pageHeadings.push({
     link: `#${id}`,
     text: getDisplayName(member),
-    kind: member instanceof ReferenceReflection ? member.getTargetReflectionDeep().kind : member.kind,
+    kind: member instanceof ReferenceReflection2 ? member.getTargetReflectionDeep().kind : member.kind,
     classes: context.getReflectionClasses(member),
     icon: context.theme.getReflectionIcon(member)
   });
   let name;
-  if (member instanceof ReferenceReflection) {
+  if (member instanceof ReferenceReflection2) {
     const target = member.getTargetReflectionDeep();
     name = JSX4.createElement(
       "span",
@@ -22965,12 +24883,18 @@ 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 readFileSync5 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+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 { i18n, JSX as JSX8, ReflectionKind as ReflectionKind4 } from "typedoc";
-var __dirname2 = dirname7(fileURLToPath4(import.meta.url));
-var TSFOR_GIR_VERSION = JSON.parse(readFileSync5(join12(__dirname2, "..", "..", "package.json"), "utf8")).version;
+function getTsForGirVersion() {
+  if (true) {
+    return "4.0.0-beta.42";
+  }
+  const __dirname3 = dirname7(fileURLToPath4(import.meta.url));
+  return JSON.parse(readFileSync6(join13(__dirname3, "..", "..", "package.json"), "utf8")).version;
+}
+var TSFOR_GIR_VERSION = getTsForGirVersion();
 function giDocgenModuleInfo(context, mod, nsMeta) {
   const depElements = nsMeta.dependencies.map((dep) => {
     const depPackageName = `${dep.namespace}-${dep.version}`;
@@ -23401,7 +25325,7 @@ var GiDocgenThemeRenderContext = class extends DefaultThemeRenderContext {
 };
 
 // ../typedoc-theme/src/theme.ts
-var __dirname3 = dirname8(fileURLToPath5(import.meta.url));
+var __dirname2 = dirname8(fileURLToPath5(import.meta.url));
 var FAVICON_FILES = [
   "favicon.ico",
   "favicon-96x96.png",
@@ -23424,13 +25348,13 @@ var GiDocgenTheme = class extends DefaultTheme {
   constructor(renderer) {
     super(renderer);
     this.owner.on(RendererEvent.END, (event) => {
-      const assetsDir = join13(event.outputDirectory, "assets");
-      copyFileSync(join13(__dirname3, "static", "style.css"), join13(assetsDir, "gi-docgen.css"));
-      copyFileSync(join13(__dirname3, "static", "gi-docgen-inherited.js"), join13(assetsDir, "gi-docgen-inherited.js"));
-      copyFileSync(join13(__dirname3, "static", "logo_x4.png"), join13(assetsDir, "logo_x4.png"));
-      const faviconDir = join13(__dirname3, "static", "favicon");
+      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");
       for (const file of FAVICON_FILES) {
-        copyFileSync(join13(faviconDir, file), join13(assetsDir, file));
+        copyFileSync(join14(faviconDir, file), join14(assetsDir, file));
       }
       const projectName = event.project.name || "TS for GIR";
       const manifest = {
@@ -23444,12 +25368,15 @@ var GiDocgenTheme = class extends DefaultTheme {
         background_color: "#1e1e1e",
         display: "standalone"
       };
-      writeFileSync2(join13(assetsDir, "site.webmanifest"), JSON.stringify(manifest, null, 2));
+      writeFileSync3(join14(assetsDir, "site.webmanifest"), JSON.stringify(manifest, null, 2));
     });
   }
   getNavigation(project) {
     return buildShallowNavigation(super.getNavigation(project));
   }
+  async postRender(event) {
+    await splitSearchIndex(event.outputDirectory);
+  }
 };
 
 // ../typedoc-theme/src/index.ts
@@ -23495,7 +25422,7 @@ var HtmlDocGenerator = class _HtmlDocGenerator {
       } else {
         for (const module of this.pipeline.modules) {
           const result = await this.pipeline.createTypeDocApp(module);
-          await this.generateDocsWithTheme(result, join14(outdir, module.packageName));
+          await this.generateDocsWithTheme(result, join15(outdir, module.packageName));
         }
       }
       this.log.success(`HTML documentation generated for ${this.pipeline.modules.length} modules in ${outdir}`);
@@ -23848,4 +25775,56 @@ lodash/lodash.js:
    * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
+
+lunr/lunr.js:
+  (**
+   * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9
+   * Copyright (C) 2020 Oliver Nightingale
+   * @license MIT
+   *)
+  (*!
+   * lunr.utils
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.Set
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.tokenizer
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.Pipeline
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.Vector
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.stemmer
+   * Copyright (C) 2020 Oliver Nightingale
+   * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt
+   *)
+  (*!
+   * lunr.stopWordFilter
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.trimmer
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.TokenSet
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.Index
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
+  (*!
+   * lunr.Builder
+   * Copyright (C) 2020 Oliver Nightingale
+   *)
 */