@elliemae/pui-cli 7.0.0-alpha.3 → 7.0.0-alpha.30

package/dist/esm/docs/assets/main.js

@@ -0,0 +1,1303 @@
+(() => {
+  var Ce = Object.create;
+  var ue = Object.defineProperty;
+  var Pe = Object.getOwnPropertyDescriptor;
+  var Oe = Object.getOwnPropertyNames;
+  var Re = Object.getPrototypeOf, _e = Object.prototype.hasOwnProperty;
+  var Me = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports);
+  var De = (t, e, r, n) => {
+    if (e && typeof e == "object" || typeof e == "function")
+      for (let i of Oe(e))
+        !_e.call(t, i) && i !== r && ue(t, i, { get: () => e[i], enumerable: !(n = Pe(e, i)) || n.enumerable });
+    return t;
+  };
+  var Fe = (t, e, r) => (r = t != null ? Ce(Re(t)) : {}, De(e || !t || !t.__esModule ? ue(r, "default", { value: t, enumerable: true }) : r, t));
+  var pe = Me((de, fe) => {
+    (function() {
+      var t = function(e) {
+        var r = new t.Builder();
+        return r.pipeline.add(t.trimmer, t.stopWordFilter, t.stemmer), r.searchPipeline.add(t.stemmer), e.call(r, r), r.build();
+      };
+      t.version = "2.3.9";
+      t.utils = {}, t.utils.warn = function(e) {
+        return function(r) {
+          e.console && console.warn && console.warn(r);
+        };
+      }(this), t.utils.asString = function(e) {
+        return e == null ? "" : e.toString();
+      }, t.utils.clone = function(e) {
+        if (e == null)
+          return e;
+        for (var r = /* @__PURE__ */ Object.create(null), n = Object.keys(e), i = 0; i < n.length; i++) {
+          var s = n[i], o = e[s];
+          if (Array.isArray(o)) {
+            r[s] = o.slice();
+            continue;
+          }
+          if (typeof o == "string" || typeof o == "number" || typeof o == "boolean") {
+            r[s] = o;
+            continue;
+          }
+          throw new TypeError("clone is not deep and does not support nested objects");
+        }
+        return r;
+      }, t.FieldRef = function(e, r, n) {
+        this.docRef = e, this.fieldName = r, this._stringValue = n;
+      }, t.FieldRef.joiner = "/", t.FieldRef.fromString = function(e) {
+        var r = e.indexOf(t.FieldRef.joiner);
+        if (r === -1)
+          throw "malformed field ref string";
+        var n = e.slice(0, r), i = e.slice(r + 1);
+        return new t.FieldRef(i, n, e);
+      }, t.FieldRef.prototype.toString = function() {
+        return this._stringValue == null && (this._stringValue = this.fieldName + t.FieldRef.joiner + this.docRef), this._stringValue;
+      };
+      t.Set = function(e) {
+        if (this.elements = /* @__PURE__ */ Object.create(null), e) {
+          this.length = e.length;
+          for (var r = 0; r < this.length; r++)
+            this.elements[e[r]] = true;
+        } else
+          this.length = 0;
+      }, t.Set.complete = { intersect: function(e) {
+        return e;
+      }, union: function() {
+        return this;
+      }, contains: function() {
+        return true;
+      } }, t.Set.empty = { intersect: function() {
+        return this;
+      }, union: function(e) {
+        return e;
+      }, contains: function() {
+        return false;
+      } }, t.Set.prototype.contains = function(e) {
+        return !!this.elements[e];
+      }, t.Set.prototype.intersect = function(e) {
+        var r, n, i, s = [];
+        if (e === t.Set.complete)
+          return this;
+        if (e === t.Set.empty)
+          return e;
+        this.length < e.length ? (r = this, n = e) : (r = e, n = this), i = Object.keys(r.elements);
+        for (var o = 0; o < i.length; o++) {
+          var a = i[o];
+          a in n.elements && s.push(a);
+        }
+        return new t.Set(s);
+      }, t.Set.prototype.union = function(e) {
+        return e === t.Set.complete ? t.Set.complete : e === t.Set.empty ? this : new t.Set(Object.keys(this.elements).concat(Object.keys(e.elements)));
+      }, t.idf = function(e, r) {
+        var n = 0;
+        for (var i in e)
+          i != "_index" && (n += Object.keys(e[i]).length);
+        var s = (r - n + 0.5) / (n + 0.5);
+        return Math.log(1 + Math.abs(s));
+      }, t.Token = function(e, r) {
+        this.str = e || "", this.metadata = r || {};
+      }, t.Token.prototype.toString = function() {
+        return this.str;
+      }, t.Token.prototype.update = function(e) {
+        return this.str = e(this.str, this.metadata), this;
+      }, t.Token.prototype.clone = function(e) {
+        return e = e || function(r) {
+          return r;
+        }, new t.Token(e(this.str, this.metadata), this.metadata);
+      };
+      t.tokenizer = function(e, r) {
+        if (e == null || e == null)
+          return [];
+        if (Array.isArray(e))
+          return e.map(function(f) {
+            return new t.Token(t.utils.asString(f).toLowerCase(), t.utils.clone(r));
+          });
+        for (var n = e.toString().toLowerCase(), i = n.length, s = [], o = 0, a = 0; o <= i; o++) {
+          var l = n.charAt(o), u = o - a;
+          if (l.match(t.tokenizer.separator) || o == i) {
+            if (u > 0) {
+              var h = t.utils.clone(r) || {};
+              h.position = [a, u], h.index = s.length, s.push(new t.Token(n.slice(a, o), h));
+            }
+            a = o + 1;
+          }
+        }
+        return s;
+      }, t.tokenizer.separator = /[\s\-]+/;
+      t.Pipeline = function() {
+        this._stack = [];
+      }, t.Pipeline.registeredFunctions = /* @__PURE__ */ Object.create(null), t.Pipeline.registerFunction = function(e, r) {
+        r in this.registeredFunctions && t.utils.warn("Overwriting existing registered function: " + r), e.label = r, t.Pipeline.registeredFunctions[e.label] = e;
+      }, t.Pipeline.warnIfFunctionNotRegistered = function(e) {
+        var r = e.label && e.label in this.registeredFunctions;
+        r || t.utils.warn(`Function is not registered with pipeline. This may cause problems when serialising the index.
+`, e);
+      }, t.Pipeline.load = function(e) {
+        var r = new t.Pipeline();
+        return e.forEach(function(n) {
+          var i = t.Pipeline.registeredFunctions[n];
+          if (i)
+            r.add(i);
+          else
+            throw new Error("Cannot load unregistered function: " + n);
+        }), r;
+      }, t.Pipeline.prototype.add = function() {
+        var e = Array.prototype.slice.call(arguments);
+        e.forEach(function(r) {
+          t.Pipeline.warnIfFunctionNotRegistered(r), this._stack.push(r);
+        }, this);
+      }, t.Pipeline.prototype.after = function(e, r) {
+        t.Pipeline.warnIfFunctionNotRegistered(r);
+        var n = this._stack.indexOf(e);
+        if (n == -1)
+          throw new Error("Cannot find existingFn");
+        n = n + 1, this._stack.splice(n, 0, r);
+      }, t.Pipeline.prototype.before = function(e, r) {
+        t.Pipeline.warnIfFunctionNotRegistered(r);
+        var n = this._stack.indexOf(e);
+        if (n == -1)
+          throw new Error("Cannot find existingFn");
+        this._stack.splice(n, 0, r);
+      }, t.Pipeline.prototype.remove = function(e) {
+        var r = this._stack.indexOf(e);
+        r != -1 && this._stack.splice(r, 1);
+      }, t.Pipeline.prototype.run = function(e) {
+        for (var r = this._stack.length, n = 0; n < r; n++) {
+          for (var i = this._stack[n], s = [], o = 0; o < e.length; o++) {
+            var a = i(e[o], o, e);
+            if (!(a == null || a === ""))
+              if (Array.isArray(a))
+                for (var l = 0; l < a.length; l++)
+                  s.push(a[l]);
+              else
+                s.push(a);
+          }
+          e = s;
+        }
+        return e;
+      }, t.Pipeline.prototype.runString = function(e, r) {
+        var n = new t.Token(e, r);
+        return this.run([n]).map(function(i) {
+          return i.toString();
+        });
+      }, t.Pipeline.prototype.reset = function() {
+        this._stack = [];
+      }, t.Pipeline.prototype.toJSON = function() {
+        return this._stack.map(function(e) {
+          return t.Pipeline.warnIfFunctionNotRegistered(e), e.label;
+        });
+      };
+      t.Vector = function(e) {
+        this._magnitude = 0, this.elements = e || [];
+      }, t.Vector.prototype.positionForIndex = function(e) {
+        if (this.elements.length == 0)
+          return 0;
+        for (var r = 0, n = this.elements.length / 2, i = n - r, s = Math.floor(i / 2), o = this.elements[s * 2]; i > 1 && (o < e && (r = s), o > e && (n = s), o != e); )
+          i = n - r, s = r + Math.floor(i / 2), o = this.elements[s * 2];
+        if (o == e || o > e)
+          return s * 2;
+        if (o < e)
+          return (s + 1) * 2;
+      }, t.Vector.prototype.insert = function(e, r) {
+        this.upsert(e, r, function() {
+          throw "duplicate index";
+        });
+      }, t.Vector.prototype.upsert = function(e, r, n) {
+        this._magnitude = 0;
+        var i = this.positionForIndex(e);
+        this.elements[i] == e ? this.elements[i + 1] = n(this.elements[i + 1], r) : this.elements.splice(i, 0, e, r);
+      }, t.Vector.prototype.magnitude = function() {
+        if (this._magnitude)
+          return this._magnitude;
+        for (var e = 0, r = this.elements.length, n = 1; n < r; n += 2) {
+          var i = this.elements[n];
+          e += i * i;
+        }
+        return this._magnitude = Math.sqrt(e);
+      }, t.Vector.prototype.dot = function(e) {
+        for (var r = 0, n = this.elements, i = e.elements, s = n.length, o = i.length, a = 0, l = 0, u = 0, h = 0; u < s && h < o; )
+          a = n[u], l = i[h], a < l ? u += 2 : a > l ? h += 2 : a == l && (r += n[u + 1] * i[h + 1], u += 2, h += 2);
+        return r;
+      }, t.Vector.prototype.similarity = function(e) {
+        return this.dot(e) / this.magnitude() || 0;
+      }, t.Vector.prototype.toArray = function() {
+        for (var e = new Array(this.elements.length / 2), r = 1, n = 0; r < this.elements.length; r += 2, n++)
+          e[n] = this.elements[r];
+        return e;
+      }, t.Vector.prototype.toJSON = function() {
+        return this.elements;
+      };
+      t.stemmer = function() {
+        var e = { 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" }, r = { icate: "ic", ative: "", alize: "al", iciti: "ic", ical: "ic", ful: "", ness: "" }, n = "[^aeiou]", i = "[aeiouy]", s = n + "[^aeiouy]*", o = i + "[aeiou]*", a = "^(" + s + ")?" + o + s, l = "^(" + s + ")?" + o + s + "(" + o + ")?$", u = "^(" + s + ")?" + o + s + o + s, h = "^(" + s + ")?" + i, f = new RegExp(a), p = new RegExp(u), E = new RegExp(l), y = new RegExp(h), b = /^(.+?)(ss|i)es$/, m = /^(.+?)([^s])s$/, v = /^(.+?)eed$/, T = /^(.+?)(ed|ing)$/, w = /.$/, I = /(at|bl|iz)$/, M = new RegExp("([^aeiouylsz])\\1$"), B = new RegExp("^" + s + i + "[^aeiouwxy]$"), V = /^(.+?[^aeiou])y$/, q = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/, $ = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/, H = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/, W = /^(.+?)(s|t)(ion)$/, P = /^(.+?)e$/, U = /ll$/, G = new RegExp("^" + s + i + "[^aeiouwxy]$"), z = function(c) {
+          var g, O, S, d, x, R, F;
+          if (c.length < 3)
+            return c;
+          if (S = c.substr(0, 1), S == "y" && (c = S.toUpperCase() + c.substr(1)), d = b, x = m, d.test(c) ? c = c.replace(d, "$1$2") : x.test(c) && (c = c.replace(x, "$1$2")), d = v, x = T, d.test(c)) {
+            var L = d.exec(c);
+            d = f, d.test(L[1]) && (d = w, c = c.replace(d, ""));
+          } else if (x.test(c)) {
+            var L = x.exec(c);
+            g = L[1], x = y, x.test(g) && (c = g, x = I, R = M, F = B, x.test(c) ? c = c + "e" : R.test(c) ? (d = w, c = c.replace(d, "")) : F.test(c) && (c = c + "e"));
+          }
+          if (d = V, d.test(c)) {
+            var L = d.exec(c);
+            g = L[1], c = g + "i";
+          }
+          if (d = q, d.test(c)) {
+            var L = d.exec(c);
+            g = L[1], O = L[2], d = f, d.test(g) && (c = g + e[O]);
+          }
+          if (d = $, d.test(c)) {
+            var L = d.exec(c);
+            g = L[1], O = L[2], d = f, d.test(g) && (c = g + r[O]);
+          }
+          if (d = H, x = W, d.test(c)) {
+            var L = d.exec(c);
+            g = L[1], d = p, d.test(g) && (c = g);
+          } else if (x.test(c)) {
+            var L = x.exec(c);
+            g = L[1] + L[2], x = p, x.test(g) && (c = g);
+          }
+          if (d = P, d.test(c)) {
+            var L = d.exec(c);
+            g = L[1], d = p, x = E, R = G, (d.test(g) || x.test(g) && !R.test(g)) && (c = g);
+          }
+          return d = U, x = p, d.test(c) && x.test(c) && (d = w, c = c.replace(d, "")), S == "y" && (c = S.toLowerCase() + c.substr(1)), c;
+        };
+        return function(D) {
+          return D.update(z);
+        };
+      }(), t.Pipeline.registerFunction(t.stemmer, "stemmer");
+      t.generateStopWordFilter = function(e) {
+        var r = e.reduce(function(n, i) {
+          return n[i] = i, n;
+        }, {});
+        return function(n) {
+          if (n && r[n.toString()] !== n.toString())
+            return n;
+        };
+      }, t.stopWordFilter = t.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"]), t.Pipeline.registerFunction(t.stopWordFilter, "stopWordFilter");
+      t.trimmer = function(e) {
+        return e.update(function(r) {
+          return r.replace(/^\W+/, "").replace(/\W+$/, "");
+        });
+      }, t.Pipeline.registerFunction(t.trimmer, "trimmer");
+      t.TokenSet = function() {
+        this.final = false, this.edges = {}, this.id = t.TokenSet._nextId, t.TokenSet._nextId += 1;
+      }, t.TokenSet._nextId = 1, t.TokenSet.fromArray = function(e) {
+        for (var r = new t.TokenSet.Builder(), n = 0, i = e.length; n < i; n++)
+          r.insert(e[n]);
+        return r.finish(), r.root;
+      }, t.TokenSet.fromClause = function(e) {
+        return "editDistance" in e ? t.TokenSet.fromFuzzyString(e.term, e.editDistance) : t.TokenSet.fromString(e.term);
+      }, t.TokenSet.fromFuzzyString = function(e, r) {
+        for (var n = new t.TokenSet(), i = [{ node: n, editsRemaining: r, str: e }]; i.length; ) {
+          var s = i.pop();
+          if (s.str.length > 0) {
+            var o = s.str.charAt(0), a;
+            o in s.node.edges ? a = s.node.edges[o] : (a = new t.TokenSet(), s.node.edges[o] = a), s.str.length == 1 && (a.final = true), i.push({ node: a, editsRemaining: s.editsRemaining, str: s.str.slice(1) });
+          }
+          if (s.editsRemaining != 0) {
+            if ("*" in s.node.edges)
+              var l = s.node.edges["*"];
+            else {
+              var l = new t.TokenSet();
+              s.node.edges["*"] = l;
+            }
+            if (s.str.length == 0 && (l.final = true), i.push({ node: l, editsRemaining: s.editsRemaining - 1, str: s.str }), s.str.length > 1 && i.push({ node: s.node, editsRemaining: s.editsRemaining - 1, str: s.str.slice(1) }), s.str.length == 1 && (s.node.final = true), s.str.length >= 1) {
+              if ("*" in s.node.edges)
+                var u = s.node.edges["*"];
+              else {
+                var u = new t.TokenSet();
+                s.node.edges["*"] = u;
+              }
+              s.str.length == 1 && (u.final = true), i.push({ node: u, editsRemaining: s.editsRemaining - 1, str: s.str.slice(1) });
+            }
+            if (s.str.length > 1) {
+              var h = s.str.charAt(0), f = s.str.charAt(1), p;
+              f in s.node.edges ? p = s.node.edges[f] : (p = new t.TokenSet(), s.node.edges[f] = p), s.str.length == 1 && (p.final = true), i.push({ node: p, editsRemaining: s.editsRemaining - 1, str: h + s.str.slice(2) });
+            }
+          }
+        }
+        return n;
+      }, t.TokenSet.fromString = function(e) {
+        for (var r = new t.TokenSet(), n = r, i = 0, s = e.length; i < s; i++) {
+          var o = e[i], a = i == s - 1;
+          if (o == "*")
+            r.edges[o] = r, r.final = a;
+          else {
+            var l = new t.TokenSet();
+            l.final = a, r.edges[o] = l, r = l;
+          }
+        }
+        return n;
+      }, t.TokenSet.prototype.toArray = function() {
+        for (var e = [], r = [{ prefix: "", node: this }]; r.length; ) {
+          var n = r.pop(), i = Object.keys(n.node.edges), s = i.length;
+          n.node.final && (n.prefix.charAt(0), e.push(n.prefix));
+          for (var o = 0; o < s; o++) {
+            var a = i[o];
+            r.push({ prefix: n.prefix.concat(a), node: n.node.edges[a] });
+          }
+        }
+        return e;
+      }, t.TokenSet.prototype.toString = function() {
+        if (this._str)
+          return this._str;
+        for (var e = this.final ? "1" : "0", r = Object.keys(this.edges).sort(), n = r.length, i = 0; i < n; i++) {
+          var s = r[i], o = this.edges[s];
+          e = e + s + o.id;
+        }
+        return e;
+      }, t.TokenSet.prototype.intersect = function(e) {
+        for (var r = new t.TokenSet(), n = void 0, i = [{ qNode: e, output: r, node: this }]; i.length; ) {
+          n = i.pop();
+          for (var s = Object.keys(n.qNode.edges), o = s.length, a = Object.keys(n.node.edges), l = a.length, u = 0; u < o; u++)
+            for (var h = s[u], f = 0; f < l; f++) {
+              var p = a[f];
+              if (p == h || h == "*") {
+                var E = n.node.edges[p], y = n.qNode.edges[h], b = E.final && y.final, m = void 0;
+                p in n.output.edges ? (m = n.output.edges[p], m.final = m.final || b) : (m = new t.TokenSet(), m.final = b, n.output.edges[p] = m), i.push({ qNode: y, output: m, node: E });
+              }
+            }
+        }
+        return r;
+      }, t.TokenSet.Builder = function() {
+        this.previousWord = "", this.root = new t.TokenSet(), this.uncheckedNodes = [], this.minimizedNodes = {};
+      }, t.TokenSet.Builder.prototype.insert = function(e) {
+        var r, n = 0;
+        if (e < this.previousWord)
+          throw new Error("Out of order word insertion");
+        for (var i = 0; i < e.length && i < this.previousWord.length && e[i] == this.previousWord[i]; i++)
+          n++;
+        this.minimize(n), this.uncheckedNodes.length == 0 ? r = this.root : r = this.uncheckedNodes[this.uncheckedNodes.length - 1].child;
+        for (var i = n; i < e.length; i++) {
+          var s = new t.TokenSet(), o = e[i];
+          r.edges[o] = s, this.uncheckedNodes.push({ parent: r, char: o, child: s }), r = s;
+        }
+        r.final = true, this.previousWord = e;
+      }, t.TokenSet.Builder.prototype.finish = function() {
+        this.minimize(0);
+      }, t.TokenSet.Builder.prototype.minimize = function(e) {
+        for (var r = this.uncheckedNodes.length - 1; r >= e; r--) {
+          var n = this.uncheckedNodes[r], i = n.child.toString();
+          i in this.minimizedNodes ? n.parent.edges[n.char] = this.minimizedNodes[i] : (n.child._str = i, this.minimizedNodes[i] = n.child), this.uncheckedNodes.pop();
+        }
+      };
+      t.Index = function(e) {
+        this.invertedIndex = e.invertedIndex, this.fieldVectors = e.fieldVectors, this.tokenSet = e.tokenSet, this.fields = e.fields, this.pipeline = e.pipeline;
+      }, t.Index.prototype.search = function(e) {
+        return this.query(function(r) {
+          var n = new t.QueryParser(e, r);
+          n.parse();
+        });
+      }, t.Index.prototype.query = function(e) {
+        for (var r = new t.Query(this.fields), n = /* @__PURE__ */ Object.create(null), i = /* @__PURE__ */ Object.create(null), s = /* @__PURE__ */ Object.create(null), o = /* @__PURE__ */ Object.create(null), a = /* @__PURE__ */ Object.create(null), l = 0; l < this.fields.length; l++)
+          i[this.fields[l]] = new t.Vector();
+        e.call(r, r);
+        for (var l = 0; l < r.clauses.length; l++) {
+          var u = r.clauses[l], h = null, f = t.Set.empty;
+          u.usePipeline ? h = this.pipeline.runString(u.term, { fields: u.fields }) : h = [u.term];
+          for (var p = 0; p < h.length; p++) {
+            var E = h[p];
+            u.term = E;
+            var y = t.TokenSet.fromClause(u), b = this.tokenSet.intersect(y).toArray();
+            if (b.length === 0 && u.presence === t.Query.presence.REQUIRED) {
+              for (var m = 0; m < u.fields.length; m++) {
+                var v = u.fields[m];
+                o[v] = t.Set.empty;
+              }
+              break;
+            }
+            for (var T = 0; T < b.length; T++)
+              for (var w = b[T], I = this.invertedIndex[w], M = I._index, m = 0; m < u.fields.length; m++) {
+                var v = u.fields[m], B = I[v], V = Object.keys(B), q = w + "/" + v, $ = new t.Set(V);
+                if (u.presence == t.Query.presence.REQUIRED && (f = f.union($), o[v] === void 0 && (o[v] = t.Set.complete)), u.presence == t.Query.presence.PROHIBITED) {
+                  a[v] === void 0 && (a[v] = t.Set.empty), a[v] = a[v].union($);
+                  continue;
+                }
+                if (i[v].upsert(M, u.boost, function(Qe, Ie) {
+                  return Qe + Ie;
+                }), !s[q]) {
+                  for (var H = 0; H < V.length; H++) {
+                    var W = V[H], P = new t.FieldRef(W, v), U = B[W], G;
+                    (G = n[P]) === void 0 ? n[P] = new t.MatchData(w, v, U) : G.add(w, v, U);
+                  }
+                  s[q] = true;
+                }
+              }
+          }
+          if (u.presence === t.Query.presence.REQUIRED)
+            for (var m = 0; m < u.fields.length; m++) {
+              var v = u.fields[m];
+              o[v] = o[v].intersect(f);
+            }
+        }
+        for (var z = t.Set.complete, D = t.Set.empty, l = 0; l < this.fields.length; l++) {
+          var v = this.fields[l];
+          o[v] && (z = z.intersect(o[v])), a[v] && (D = D.union(a[v]));
+        }
+        var c = Object.keys(n), g = [], O = /* @__PURE__ */ Object.create(null);
+        if (r.isNegated()) {
+          c = Object.keys(this.fieldVectors);
+          for (var l = 0; l < c.length; l++) {
+            var P = c[l], S = t.FieldRef.fromString(P);
+            n[P] = new t.MatchData();
+          }
+        }
+        for (var l = 0; l < c.length; l++) {
+          var S = t.FieldRef.fromString(c[l]), d = S.docRef;
+          if (!!z.contains(d) && !D.contains(d)) {
+            var x = this.fieldVectors[S], R = i[S.fieldName].similarity(x), F;
+            if ((F = O[d]) !== void 0)
+              F.score += R, F.matchData.combine(n[S]);
+            else {
+              var L = { ref: d, score: R, matchData: n[S] };
+              O[d] = L, g.push(L);
+            }
+          }
+        }
+        return g.sort(function(Se, ke) {
+          return ke.score - Se.score;
+        });
+      }, t.Index.prototype.toJSON = function() {
+        var e = Object.keys(this.invertedIndex).sort().map(function(n) {
+          return [n, this.invertedIndex[n]];
+        }, this), r = Object.keys(this.fieldVectors).map(function(n) {
+          return [n, this.fieldVectors[n].toJSON()];
+        }, this);
+        return { version: t.version, fields: this.fields, fieldVectors: r, invertedIndex: e, pipeline: this.pipeline.toJSON() };
+      }, t.Index.load = function(e) {
+        var r = {}, n = {}, i = e.fieldVectors, s = /* @__PURE__ */ Object.create(null), o = e.invertedIndex, a = new t.TokenSet.Builder(), l = t.Pipeline.load(e.pipeline);
+        e.version != t.version && t.utils.warn("Version mismatch when loading serialised index. Current version of lunr '" + t.version + "' does not match serialized index '" + e.version + "'");
+        for (var u = 0; u < i.length; u++) {
+          var h = i[u], f = h[0], p = h[1];
+          n[f] = new t.Vector(p);
+        }
+        for (var u = 0; u < o.length; u++) {
+          var h = o[u], E = h[0], y = h[1];
+          a.insert(E), s[E] = y;
+        }
+        return a.finish(), r.fields = e.fields, r.fieldVectors = n, r.invertedIndex = s, r.tokenSet = a.root, r.pipeline = l, new t.Index(r);
+      };
+      t.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 = t.tokenizer, this.pipeline = new t.Pipeline(), this.searchPipeline = new t.Pipeline(), this.documentCount = 0, this._b = 0.75, this._k1 = 1.2, this.termIndex = 0, this.metadataWhitelist = [];
+      }, t.Builder.prototype.ref = function(e) {
+        this._ref = e;
+      }, t.Builder.prototype.field = function(e, r) {
+        if (/\//.test(e))
+          throw new RangeError("Field '" + e + "' contains illegal character '/'");
+        this._fields[e] = r || {};
+      }, t.Builder.prototype.b = function(e) {
+        e < 0 ? this._b = 0 : e > 1 ? this._b = 1 : this._b = e;
+      }, t.Builder.prototype.k1 = function(e) {
+        this._k1 = e;
+      }, t.Builder.prototype.add = function(e, r) {
+        var n = e[this._ref], i = Object.keys(this._fields);
+        this._documents[n] = r || {}, this.documentCount += 1;
+        for (var s = 0; s < i.length; s++) {
+          var o = i[s], a = this._fields[o].extractor, l = a ? a(e) : e[o], u = this.tokenizer(l, { fields: [o] }), h = this.pipeline.run(u), f = new t.FieldRef(n, o), p = /* @__PURE__ */ Object.create(null);
+          this.fieldTermFrequencies[f] = p, this.fieldLengths[f] = 0, this.fieldLengths[f] += h.length;
+          for (var E = 0; E < h.length; E++) {
+            var y = h[E];
+            if (p[y] == null && (p[y] = 0), p[y] += 1, this.invertedIndex[y] == null) {
+              var b = /* @__PURE__ */ Object.create(null);
+              b._index = this.termIndex, this.termIndex += 1;
+              for (var m = 0; m < i.length; m++)
+                b[i[m]] = /* @__PURE__ */ Object.create(null);
+              this.invertedIndex[y] = b;
+            }
+            this.invertedIndex[y][o][n] == null && (this.invertedIndex[y][o][n] = /* @__PURE__ */ Object.create(null));
+            for (var v = 0; v < this.metadataWhitelist.length; v++) {
+              var T = this.metadataWhitelist[v], w = y.metadata[T];
+              this.invertedIndex[y][o][n][T] == null && (this.invertedIndex[y][o][n][T] = []), this.invertedIndex[y][o][n][T].push(w);
+            }
+          }
+        }
+      }, t.Builder.prototype.calculateAverageFieldLengths = function() {
+        for (var e = Object.keys(this.fieldLengths), r = e.length, n = {}, i = {}, s = 0; s < r; s++) {
+          var o = t.FieldRef.fromString(e[s]), a = o.fieldName;
+          i[a] || (i[a] = 0), i[a] += 1, n[a] || (n[a] = 0), n[a] += this.fieldLengths[o];
+        }
+        for (var l = Object.keys(this._fields), s = 0; s < l.length; s++) {
+          var u = l[s];
+          n[u] = n[u] / i[u];
+        }
+        this.averageFieldLength = n;
+      }, t.Builder.prototype.createFieldVectors = function() {
+        for (var e = {}, r = Object.keys(this.fieldTermFrequencies), n = r.length, i = /* @__PURE__ */ Object.create(null), s = 0; s < n; s++) {
+          for (var o = t.FieldRef.fromString(r[s]), a = o.fieldName, l = this.fieldLengths[o], u = new t.Vector(), h = this.fieldTermFrequencies[o], f = Object.keys(h), p = f.length, E = this._fields[a].boost || 1, y = this._documents[o.docRef].boost || 1, b = 0; b < p; b++) {
+            var m = f[b], v = h[m], T = this.invertedIndex[m]._index, w, I, M;
+            i[m] === void 0 ? (w = t.idf(this.invertedIndex[m], this.documentCount), i[m] = w) : w = i[m], I = w * ((this._k1 + 1) * v) / (this._k1 * (1 - this._b + this._b * (l / this.averageFieldLength[a])) + v), I *= E, I *= y, M = Math.round(I * 1e3) / 1e3, u.insert(T, M);
+          }
+          e[o] = u;
+        }
+        this.fieldVectors = e;
+      }, t.Builder.prototype.createTokenSet = function() {
+        this.tokenSet = t.TokenSet.fromArray(Object.keys(this.invertedIndex).sort());
+      }, t.Builder.prototype.build = function() {
+        return this.calculateAverageFieldLengths(), this.createFieldVectors(), this.createTokenSet(), new t.Index({ invertedIndex: this.invertedIndex, fieldVectors: this.fieldVectors, tokenSet: this.tokenSet, fields: Object.keys(this._fields), pipeline: this.searchPipeline });
+      }, t.Builder.prototype.use = function(e) {
+        var r = Array.prototype.slice.call(arguments, 1);
+        r.unshift(this), e.apply(this, r);
+      }, t.MatchData = function(e, r, n) {
+        for (var i = /* @__PURE__ */ Object.create(null), s = Object.keys(n || {}), o = 0; o < s.length; o++) {
+          var a = s[o];
+          i[a] = n[a].slice();
+        }
+        this.metadata = /* @__PURE__ */ Object.create(null), e !== void 0 && (this.metadata[e] = /* @__PURE__ */ Object.create(null), this.metadata[e][r] = i);
+      }, t.MatchData.prototype.combine = function(e) {
+        for (var r = Object.keys(e.metadata), n = 0; n < r.length; n++) {
+          var i = r[n], s = Object.keys(e.metadata[i]);
+          this.metadata[i] == null && (this.metadata[i] = /* @__PURE__ */ Object.create(null));
+          for (var o = 0; o < s.length; o++) {
+            var a = s[o], l = Object.keys(e.metadata[i][a]);
+            this.metadata[i][a] == null && (this.metadata[i][a] = /* @__PURE__ */ Object.create(null));
+            for (var u = 0; u < l.length; u++) {
+              var h = l[u];
+              this.metadata[i][a][h] == null ? this.metadata[i][a][h] = e.metadata[i][a][h] : this.metadata[i][a][h] = this.metadata[i][a][h].concat(e.metadata[i][a][h]);
+            }
+          }
+        }
+      }, t.MatchData.prototype.add = function(e, r, n) {
+        if (!(e in this.metadata)) {
+          this.metadata[e] = /* @__PURE__ */ Object.create(null), this.metadata[e][r] = n;
+          return;
+        }
+        if (!(r in this.metadata[e])) {
+          this.metadata[e][r] = n;
+          return;
+        }
+        for (var i = Object.keys(n), s = 0; s < i.length; s++) {
+          var o = i[s];
+          o in this.metadata[e][r] ? this.metadata[e][r][o] = this.metadata[e][r][o].concat(n[o]) : this.metadata[e][r][o] = n[o];
+        }
+      }, t.Query = function(e) {
+        this.clauses = [], this.allFields = e;
+      }, t.Query.wildcard = new String("*"), t.Query.wildcard.NONE = 0, t.Query.wildcard.LEADING = 1, t.Query.wildcard.TRAILING = 2, t.Query.presence = { OPTIONAL: 1, REQUIRED: 2, PROHIBITED: 3 }, t.Query.prototype.clause = function(e) {
+        return "fields" in e || (e.fields = this.allFields), "boost" in e || (e.boost = 1), "usePipeline" in e || (e.usePipeline = true), "wildcard" in e || (e.wildcard = t.Query.wildcard.NONE), e.wildcard & t.Query.wildcard.LEADING && e.term.charAt(0) != t.Query.wildcard && (e.term = "*" + e.term), e.wildcard & t.Query.wildcard.TRAILING && e.term.slice(-1) != t.Query.wildcard && (e.term = "" + e.term + "*"), "presence" in e || (e.presence = t.Query.presence.OPTIONAL), this.clauses.push(e), this;
+      }, t.Query.prototype.isNegated = function() {
+        for (var e = 0; e < this.clauses.length; e++)
+          if (this.clauses[e].presence != t.Query.presence.PROHIBITED)
+            return false;
+        return true;
+      }, t.Query.prototype.term = function(e, r) {
+        if (Array.isArray(e))
+          return e.forEach(function(i) {
+            this.term(i, t.utils.clone(r));
+          }, this), this;
+        var n = r || {};
+        return n.term = e.toString(), this.clause(n), this;
+      }, t.QueryParseError = function(e, r, n) {
+        this.name = "QueryParseError", this.message = e, this.start = r, this.end = n;
+      }, t.QueryParseError.prototype = new Error(), t.QueryLexer = function(e) {
+        this.lexemes = [], this.str = e, this.length = e.length, this.pos = 0, this.start = 0, this.escapeCharPositions = [];
+      }, t.QueryLexer.prototype.run = function() {
+        for (var e = t.QueryLexer.lexText; e; )
+          e = e(this);
+      }, t.QueryLexer.prototype.sliceString = function() {
+        for (var e = [], r = this.start, n = this.pos, i = 0; i < this.escapeCharPositions.length; i++)
+          n = this.escapeCharPositions[i], e.push(this.str.slice(r, n)), r = n + 1;
+        return e.push(this.str.slice(r, this.pos)), this.escapeCharPositions.length = 0, e.join("");
+      }, t.QueryLexer.prototype.emit = function(e) {
+        this.lexemes.push({ type: e, str: this.sliceString(), start: this.start, end: this.pos }), this.start = this.pos;
+      }, t.QueryLexer.prototype.escapeCharacter = function() {
+        this.escapeCharPositions.push(this.pos - 1), this.pos += 1;
+      }, t.QueryLexer.prototype.next = function() {
+        if (this.pos >= this.length)
+          return t.QueryLexer.EOS;
+        var e = this.str.charAt(this.pos);
+        return this.pos += 1, e;
+      }, t.QueryLexer.prototype.width = function() {
+        return this.pos - this.start;
+      }, t.QueryLexer.prototype.ignore = function() {
+        this.start == this.pos && (this.pos += 1), this.start = this.pos;
+      }, t.QueryLexer.prototype.backup = function() {
+        this.pos -= 1;
+      }, t.QueryLexer.prototype.acceptDigitRun = function() {
+        var e, r;
+        do
+          e = this.next(), r = e.charCodeAt(0);
+        while (r > 47 && r < 58);
+        e != t.QueryLexer.EOS && this.backup();
+      }, t.QueryLexer.prototype.more = function() {
+        return this.pos < this.length;
+      }, t.QueryLexer.EOS = "EOS", t.QueryLexer.FIELD = "FIELD", t.QueryLexer.TERM = "TERM", t.QueryLexer.EDIT_DISTANCE = "EDIT_DISTANCE", t.QueryLexer.BOOST = "BOOST", t.QueryLexer.PRESENCE = "PRESENCE", t.QueryLexer.lexField = function(e) {
+        return e.backup(), e.emit(t.QueryLexer.FIELD), e.ignore(), t.QueryLexer.lexText;
+      }, t.QueryLexer.lexTerm = function(e) {
+        if (e.width() > 1 && (e.backup(), e.emit(t.QueryLexer.TERM)), e.ignore(), e.more())
+          return t.QueryLexer.lexText;
+      }, t.QueryLexer.lexEditDistance = function(e) {
+        return e.ignore(), e.acceptDigitRun(), e.emit(t.QueryLexer.EDIT_DISTANCE), t.QueryLexer.lexText;
+      }, t.QueryLexer.lexBoost = function(e) {
+        return e.ignore(), e.acceptDigitRun(), e.emit(t.QueryLexer.BOOST), t.QueryLexer.lexText;
+      }, t.QueryLexer.lexEOS = function(e) {
+        e.width() > 0 && e.emit(t.QueryLexer.TERM);
+      }, t.QueryLexer.termSeparator = t.tokenizer.separator, t.QueryLexer.lexText = function(e) {
+        for (; ; ) {
+          var r = e.next();
+          if (r == t.QueryLexer.EOS)
+            return t.QueryLexer.lexEOS;
+          if (r.charCodeAt(0) == 92) {
+            e.escapeCharacter();
+            continue;
+          }
+          if (r == ":")
+            return t.QueryLexer.lexField;
+          if (r == "~")
+            return e.backup(), e.width() > 0 && e.emit(t.QueryLexer.TERM), t.QueryLexer.lexEditDistance;
+          if (r == "^")
+            return e.backup(), e.width() > 0 && e.emit(t.QueryLexer.TERM), t.QueryLexer.lexBoost;
+          if (r == "+" && e.width() === 1 || r == "-" && e.width() === 1)
+            return e.emit(t.QueryLexer.PRESENCE), t.QueryLexer.lexText;
+          if (r.match(t.QueryLexer.termSeparator))
+            return t.QueryLexer.lexTerm;
+        }
+      }, t.QueryParser = function(e, r) {
+        this.lexer = new t.QueryLexer(e), this.query = r, this.currentClause = {}, this.lexemeIdx = 0;
+      }, t.QueryParser.prototype.parse = function() {
+        this.lexer.run(), this.lexemes = this.lexer.lexemes;
+        for (var e = t.QueryParser.parseClause; e; )
+          e = e(this);
+        return this.query;
+      }, t.QueryParser.prototype.peekLexeme = function() {
+        return this.lexemes[this.lexemeIdx];
+      }, t.QueryParser.prototype.consumeLexeme = function() {
+        var e = this.peekLexeme();
+        return this.lexemeIdx += 1, e;
+      }, t.QueryParser.prototype.nextClause = function() {
+        var e = this.currentClause;
+        this.query.clause(e), this.currentClause = {};
+      }, t.QueryParser.parseClause = function(e) {
+        var r = e.peekLexeme();
+        if (r != null)
+          switch (r.type) {
+            case t.QueryLexer.PRESENCE:
+              return t.QueryParser.parsePresence;
+            case t.QueryLexer.FIELD:
+              return t.QueryParser.parseField;
+            case t.QueryLexer.TERM:
+              return t.QueryParser.parseTerm;
+            default:
+              var n = "expected either a field or a term, found " + r.type;
+              throw r.str.length >= 1 && (n += " with value '" + r.str + "'"), new t.QueryParseError(n, r.start, r.end);
+          }
+      }, t.QueryParser.parsePresence = function(e) {
+        var r = e.consumeLexeme();
+        if (r != null) {
+          switch (r.str) {
+            case "-":
+              e.currentClause.presence = t.Query.presence.PROHIBITED;
+              break;
+            case "+":
+              e.currentClause.presence = t.Query.presence.REQUIRED;
+              break;
+            default:
+              var n = "unrecognised presence operator'" + r.str + "'";
+              throw new t.QueryParseError(n, r.start, r.end);
+          }
+          var i = e.peekLexeme();
+          if (i == null) {
+            var n = "expecting term or field, found nothing";
+            throw new t.QueryParseError(n, r.start, r.end);
+          }
+          switch (i.type) {
+            case t.QueryLexer.FIELD:
+              return t.QueryParser.parseField;
+            case t.QueryLexer.TERM:
+              return t.QueryParser.parseTerm;
+            default:
+              var n = "expecting term or field, found '" + i.type + "'";
+              throw new t.QueryParseError(n, i.start, i.end);
+          }
+        }
+      }, t.QueryParser.parseField = function(e) {
+        var r = e.consumeLexeme();
+        if (r != null) {
+          if (e.query.allFields.indexOf(r.str) == -1) {
+            var n = e.query.allFields.map(function(o) {
+              return "'" + o + "'";
+            }).join(", "), i = "unrecognised field '" + r.str + "', possible fields: " + n;
+            throw new t.QueryParseError(i, r.start, r.end);
+          }
+          e.currentClause.fields = [r.str];
+          var s = e.peekLexeme();
+          if (s == null) {
+            var i = "expecting term, found nothing";
+            throw new t.QueryParseError(i, r.start, r.end);
+          }
+          switch (s.type) {
+            case t.QueryLexer.TERM:
+              return t.QueryParser.parseTerm;
+            default:
+              var i = "expecting term, found '" + s.type + "'";
+              throw new t.QueryParseError(i, s.start, s.end);
+          }
+        }
+      }, t.QueryParser.parseTerm = function(e) {
+        var r = e.consumeLexeme();
+        if (r != null) {
+          e.currentClause.term = r.str.toLowerCase(), r.str.indexOf("*") != -1 && (e.currentClause.usePipeline = false);
+          var n = e.peekLexeme();
+          if (n == null) {
+            e.nextClause();
+            return;
+          }
+          switch (n.type) {
+            case t.QueryLexer.TERM:
+              return e.nextClause(), t.QueryParser.parseTerm;
+            case t.QueryLexer.FIELD:
+              return e.nextClause(), t.QueryParser.parseField;
+            case t.QueryLexer.EDIT_DISTANCE:
+              return t.QueryParser.parseEditDistance;
+            case t.QueryLexer.BOOST:
+              return t.QueryParser.parseBoost;
+            case t.QueryLexer.PRESENCE:
+              return e.nextClause(), t.QueryParser.parsePresence;
+            default:
+              var i = "Unexpected lexeme type '" + n.type + "'";
+              throw new t.QueryParseError(i, n.start, n.end);
+          }
+        }
+      }, t.QueryParser.parseEditDistance = function(e) {
+        var r = e.consumeLexeme();
+        if (r != null) {
+          var n = parseInt(r.str, 10);
+          if (isNaN(n)) {
+            var i = "edit distance must be numeric";
+            throw new t.QueryParseError(i, r.start, r.end);
+          }
+          e.currentClause.editDistance = n;
+          var s = e.peekLexeme();
+          if (s == null) {
+            e.nextClause();
+            return;
+          }
+          switch (s.type) {
+            case t.QueryLexer.TERM:
+              return e.nextClause(), t.QueryParser.parseTerm;
+            case t.QueryLexer.FIELD:
+              return e.nextClause(), t.QueryParser.parseField;
+            case t.QueryLexer.EDIT_DISTANCE:
+              return t.QueryParser.parseEditDistance;
+            case t.QueryLexer.BOOST:
+              return t.QueryParser.parseBoost;
+            case t.QueryLexer.PRESENCE:
+              return e.nextClause(), t.QueryParser.parsePresence;
+            default:
+              var i = "Unexpected lexeme type '" + s.type + "'";
+              throw new t.QueryParseError(i, s.start, s.end);
+          }
+        }
+      }, t.QueryParser.parseBoost = function(e) {
+        var r = e.consumeLexeme();
+        if (r != null) {
+          var n = parseInt(r.str, 10);
+          if (isNaN(n)) {
+            var i = "boost must be numeric";
+            throw new t.QueryParseError(i, r.start, r.end);
+          }
+          e.currentClause.boost = n;
+          var s = e.peekLexeme();
+          if (s == null) {
+            e.nextClause();
+            return;
+          }
+          switch (s.type) {
+            case t.QueryLexer.TERM:
+              return e.nextClause(), t.QueryParser.parseTerm;
+            case t.QueryLexer.FIELD:
+              return e.nextClause(), t.QueryParser.parseField;
+            case t.QueryLexer.EDIT_DISTANCE:
+              return t.QueryParser.parseEditDistance;
+            case t.QueryLexer.BOOST:
+              return t.QueryParser.parseBoost;
+            case t.QueryLexer.PRESENCE:
+              return e.nextClause(), t.QueryParser.parsePresence;
+            default:
+              var i = "Unexpected lexeme type '" + s.type + "'";
+              throw new t.QueryParseError(i, s.start, s.end);
+          }
+        }
+      }, function(e, r) {
+        typeof define == "function" && define.amd ? define(r) : typeof de == "object" ? fe.exports = r() : e.lunr = r();
+      }(this, function() {
+        return t;
+      });
+    })();
+  });
+  var ce = [];
+  function N(t, e) {
+    ce.push({ selector: e, constructor: t });
+  }
+  var Y = class {
+    constructor() {
+      this.createComponents(document.body);
+    }
+    createComponents(e) {
+      ce.forEach((r) => {
+        e.querySelectorAll(r.selector).forEach((n) => {
+          n.dataset.hasInstance || (new r.constructor({ el: n }), n.dataset.hasInstance = String(true));
+        });
+      });
+    }
+  };
+  var k = class {
+    constructor(e) {
+      this.el = e.el;
+    }
+  };
+  var J = class {
+    constructor() {
+      this.listeners = {};
+    }
+    addEventListener(e, r) {
+      e in this.listeners || (this.listeners[e] = []), this.listeners[e].push(r);
+    }
+    removeEventListener(e, r) {
+      if (!(e in this.listeners))
+        return;
+      let n = this.listeners[e];
+      for (let i = 0, s = n.length; i < s; i++)
+        if (n[i] === r) {
+          n.splice(i, 1);
+          return;
+        }
+    }
+    dispatchEvent(e) {
+      if (!(e.type in this.listeners))
+        return true;
+      let r = this.listeners[e.type].slice();
+      for (let n = 0, i = r.length; n < i; n++)
+        r[n].call(this, e);
+      return !e.defaultPrevented;
+    }
+  };
+  var ne = (t, e = 100) => {
+    let r = Date.now();
+    return (...n) => {
+      r + e - Date.now() < 0 && (t(...n), r = Date.now());
+    };
+  };
+  var ie = class extends J {
+    constructor() {
+      super();
+      this.scrollTop = 0;
+      this.lastY = 0;
+      this.width = 0;
+      this.height = 0;
+      this.showToolbar = true;
+      this.toolbar = document.querySelector(".tsd-page-toolbar"), this.secondaryNav = document.querySelector(".tsd-navigation.secondary"), window.addEventListener("scroll", ne(() => this.onScroll(), 10)), window.addEventListener("resize", ne(() => this.onResize(), 10)), this.onResize(), this.onScroll();
+    }
+    triggerResize() {
+      let r = new CustomEvent("resize", { detail: { width: this.width, height: this.height } });
+      this.dispatchEvent(r);
+    }
+    onResize() {
+      this.width = window.innerWidth || 0, this.height = window.innerHeight || 0;
+      let r = new CustomEvent("resize", { detail: { width: this.width, height: this.height } });
+      this.dispatchEvent(r);
+    }
+    onScroll() {
+      this.scrollTop = window.scrollY || 0;
+      let r = new CustomEvent("scroll", { detail: { scrollTop: this.scrollTop } });
+      this.dispatchEvent(r), this.hideShowToolbar();
+    }
+    hideShowToolbar() {
+      var n;
+      let r = this.showToolbar;
+      this.showToolbar = this.lastY >= this.scrollTop || this.scrollTop <= 0, r !== this.showToolbar && (this.toolbar.classList.toggle("tsd-page-toolbar--hide"), (n = this.secondaryNav) == null || n.classList.toggle("tsd-navigation--toolbar-hide")), this.lastY = this.scrollTop;
+    }
+  }, Q = ie;
+  Q.instance = new ie();
+  var X = class extends k {
+    constructor(r) {
+      super(r);
+      this.anchors = [];
+      this.index = -1;
+      Q.instance.addEventListener("resize", () => this.onResize()), Q.instance.addEventListener("scroll", (n) => this.onScroll(n)), this.createAnchors();
+    }
+    createAnchors() {
+      let r = window.location.href;
+      r.indexOf("#") != -1 && (r = r.substr(0, r.indexOf("#"))), this.el.querySelectorAll("a").forEach((n) => {
+        let i = n.href;
+        if (i.indexOf("#") == -1 || i.substr(0, r.length) != r)
+          return;
+        let s = i.substr(i.indexOf("#") + 1), o = document.querySelector("a.tsd-anchor[name=" + s + "]"), a = n.parentNode;
+        !o || !a || this.anchors.push({ link: a, anchor: o, position: 0 });
+      }), this.onResize();
+    }
+    onResize() {
+      let r;
+      for (let i = 0, s = this.anchors.length; i < s; i++) {
+        r = this.anchors[i];
+        let o = r.anchor.getBoundingClientRect();
+        r.position = o.top + document.body.scrollTop;
+      }
+      this.anchors.sort((i, s) => i.position - s.position);
+      let n = new CustomEvent("scroll", { detail: { scrollTop: Q.instance.scrollTop } });
+      this.onScroll(n);
+    }
+    onScroll(r) {
+      let n = r.detail.scrollTop + 5, i = this.anchors, s = i.length - 1, o = this.index;
+      for (; o > -1 && i[o].position > n; )
+        o -= 1;
+      for (; o < s && i[o + 1].position < n; )
+        o += 1;
+      this.index != o && (this.index > -1 && this.anchors[this.index].link.classList.remove("focus"), this.index = o, this.index > -1 && this.anchors[this.index].link.classList.add("focus"));
+    }
+  };
+  var he = (t, e = 100) => {
+    let r;
+    return (...n) => {
+      clearTimeout(r), r = setTimeout(() => t(n), e);
+    };
+  };
+  var ge = Fe(pe());
+  function ye() {
+    let t = document.getElementById("tsd-search");
+    if (!t)
+      return;
+    let e = document.getElementById("search-script");
+    t.classList.add("loading"), e && (e.addEventListener("error", () => {
+      t.classList.remove("loading"), t.classList.add("failure");
+    }), e.addEventListener("load", () => {
+      t.classList.remove("loading"), t.classList.add("ready");
+    }), window.searchData && t.classList.remove("loading"));
+    let r = document.querySelector("#tsd-search input"), n = document.querySelector("#tsd-search .results");
+    if (!r || !n)
+      throw new Error("The input field or the result list wrapper was not found");
+    let i = false;
+    n.addEventListener("mousedown", () => i = true), n.addEventListener("mouseup", () => {
+      i = false, t.classList.remove("has-focus");
+    }), r.addEventListener("focus", () => t.classList.add("has-focus")), r.addEventListener("blur", () => {
+      i || (i = false, t.classList.remove("has-focus"));
+    });
+    let s = { base: t.dataset.base + "/" };
+    Ae(t, n, r, s);
+  }
+  function Ae(t, e, r, n) {
+    r.addEventListener("input", he(() => {
+      He(t, e, r, n);
+    }, 200));
+    let i = false;
+    r.addEventListener("keydown", (s) => {
+      i = true, s.key == "Enter" ? ze(e, r) : s.key == "Escape" ? r.blur() : s.key == "ArrowUp" ? me(e, -1) : s.key === "ArrowDown" ? me(e, 1) : i = false;
+    }), r.addEventListener("keypress", (s) => {
+      i && s.preventDefault();
+    }), document.body.addEventListener("keydown", (s) => {
+      s.altKey || s.ctrlKey || s.metaKey || !r.matches(":focus") && s.key === "/" && (r.focus(), s.preventDefault());
+    });
+  }
+  function Ve(t, e) {
+    t.index || window.searchData && (e.classList.remove("loading"), e.classList.add("ready"), t.data = window.searchData, t.index = ge.Index.load(window.searchData.index));
+  }
+  function He(t, e, r, n) {
+    var o, a;
+    if (Ve(n, t), !n.index || !n.data)
+      return;
+    e.textContent = "";
+    let i = r.value.trim(), s = i ? n.index.search(`*${i}*`) : [];
+    for (let l = 0; l < s.length; l++) {
+      let u = s[l], h = n.data.rows[Number(u.ref)], f = 1;
+      h.name.toLowerCase().startsWith(i.toLowerCase()) && (f *= 1 + 1 / (Math.abs(h.name.length - i.length) * 10)), f *= (o = h.boost) != null ? o : 1, u.score *= f;
+    }
+    s.sort((l, u) => u.score - l.score);
+    for (let l = 0, u = Math.min(10, s.length); l < u; l++) {
+      let h = n.data.rows[Number(s[l].ref)], f = ve(h.name, i);
+      h.parent && (f = `<span class="parent">${ve(h.parent, i)}.</span>${f}`);
+      let p = document.createElement("li");
+      p.classList.value = (a = h.classes) != null ? a : "";
+      let E = document.createElement("a");
+      E.href = n.base + h.url, E.classList.add("tsd-kind-icon"), E.innerHTML = f, p.append(E), e.appendChild(p);
+    }
+  }
+  function me(t, e) {
+    var n, i;
+    let r = t.querySelector(".current");
+    if (!r)
+      r = t.querySelector(e == 1 ? "li:first-child" : "li:last-child"), r && r.classList.add("current");
+    else {
+      let s = r;
+      if (e === 1)
+        do
+          s = (n = s.nextElementSibling) != null ? n : void 0;
+        while (s instanceof HTMLElement && s.offsetParent == null);
+      else
+        do
+          s = (i = s.previousElementSibling) != null ? i : void 0;
+        while (s instanceof HTMLElement && s.offsetParent == null);
+      s && (r.classList.remove("current"), s.classList.add("current"));
+    }
+  }
+  function ze(t, e) {
+    let r = t.querySelector(".current");
+    if (r || (r = t.querySelector("li:first-child")), r) {
+      let n = r.querySelector("a");
+      n && (window.location.href = n.href), e.blur();
+    }
+  }
+  function ve(t, e) {
+    if (e === "")
+      return t;
+    let r = t.toLocaleLowerCase(), n = e.toLocaleLowerCase(), i = [], s = 0, o = r.indexOf(n);
+    for (; o != -1; )
+      i.push(se(t.substring(s, o)), `<b>${se(t.substring(o, o + n.length))}</b>`), s = o + n.length, o = r.indexOf(n, s);
+    return i.push(se(t.substring(s))), i.join("");
+  }
+  var Ne = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&#039;", '"': "&quot;" };
+  function se(t) {
+    return t.replace(/[&<>"'"]/g, (e) => Ne[e]);
+  }
+  var oe = class {
+    constructor(e, r) {
+      this.signature = e, this.description = r;
+    }
+    addClass(e) {
+      return this.signature.classList.add(e), this.description.classList.add(e), this;
+    }
+    removeClass(e) {
+      return this.signature.classList.remove(e), this.description.classList.remove(e), this;
+    }
+  }, Z = class extends k {
+    constructor(r) {
+      super(r);
+      this.groups = [];
+      this.index = -1;
+      this.createGroups(), this.container && (this.el.classList.add("active"), Array.from(this.el.children).forEach((n) => {
+        n.addEventListener("touchstart", (i) => this.onClick(i)), n.addEventListener("click", (i) => this.onClick(i));
+      }), this.container.classList.add("active"), this.setIndex(0));
+    }
+    setIndex(r) {
+      if (r < 0 && (r = 0), r > this.groups.length - 1 && (r = this.groups.length - 1), this.index == r)
+        return;
+      let n = this.groups[r];
+      if (this.index > -1) {
+        let i = this.groups[this.index];
+        i.removeClass("current").addClass("fade-out"), n.addClass("current"), n.addClass("fade-in"), Q.instance.triggerResize(), setTimeout(() => {
+          i.removeClass("fade-out"), n.removeClass("fade-in");
+        }, 300);
+      } else
+        n.addClass("current"), Q.instance.triggerResize();
+      this.index = r;
+    }
+    createGroups() {
+      let r = this.el.children;
+      if (r.length < 2)
+        return;
+      this.container = this.el.nextElementSibling;
+      let n = this.container.children;
+      this.groups = [];
+      for (let i = 0; i < r.length; i++)
+        this.groups.push(new oe(r[i], n[i]));
+    }
+    onClick(r) {
+      this.groups.forEach((n, i) => {
+        n.signature === r.currentTarget && this.setIndex(i);
+      });
+    }
+  };
+  var C = "mousedown", Le = "mousemove", _ = "mouseup", K = { x: 0, y: 0 }, xe = false, ae = false, je = false, A = false, Ee = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+  document.documentElement.classList.add(Ee ? "is-mobile" : "not-mobile");
+  Ee && "ontouchstart" in document.documentElement && (je = true, C = "touchstart", Le = "touchmove", _ = "touchend");
+  document.addEventListener(C, (t) => {
+    ae = true, A = false;
+    let e = C == "touchstart" ? t.targetTouches[0] : t;
+    K.y = e.pageY || 0, K.x = e.pageX || 0;
+  });
+  document.addEventListener(Le, (t) => {
+    if (!!ae && !A) {
+      let e = C == "touchstart" ? t.targetTouches[0] : t, r = K.x - (e.pageX || 0), n = K.y - (e.pageY || 0);
+      A = Math.sqrt(r * r + n * n) > 10;
+    }
+  });
+  document.addEventListener(_, () => {
+    ae = false;
+  });
+  document.addEventListener("click", (t) => {
+    xe && (t.preventDefault(), t.stopImmediatePropagation(), xe = false);
+  });
+  var ee = class extends k {
+    constructor(r) {
+      super(r);
+      this.className = this.el.dataset.toggle || "", this.el.addEventListener(_, (n) => this.onPointerUp(n)), this.el.addEventListener("click", (n) => n.preventDefault()), document.addEventListener(C, (n) => this.onDocumentPointerDown(n)), document.addEventListener(_, (n) => this.onDocumentPointerUp(n));
+    }
+    setActive(r) {
+      if (this.active == r)
+        return;
+      this.active = r, document.documentElement.classList.toggle("has-" + this.className, r), this.el.classList.toggle("active", r);
+      let n = (this.active ? "to-has-" : "from-has-") + this.className;
+      document.documentElement.classList.add(n), setTimeout(() => document.documentElement.classList.remove(n), 500);
+    }
+    onPointerUp(r) {
+      A || (this.setActive(true), r.preventDefault());
+    }
+    onDocumentPointerDown(r) {
+      if (this.active) {
+        if (r.target.closest(".col-menu, .tsd-filter-group"))
+          return;
+        this.setActive(false);
+      }
+    }
+    onDocumentPointerUp(r) {
+      if (!A && this.active && r.target.closest(".col-menu")) {
+        let n = r.target.closest("a");
+        if (n) {
+          let i = window.location.href;
+          i.indexOf("#") != -1 && (i = i.substr(0, i.indexOf("#"))), n.href.substr(0, i.length) == i && setTimeout(() => this.setActive(false), 250);
+        }
+      }
+    }
+  };
+  var te = class {
+    constructor(e, r) {
+      this.key = e, this.value = r, this.defaultValue = r, this.initialize(), window.localStorage[this.key] && this.setValue(this.fromLocalStorage(window.localStorage[this.key]));
+    }
+    initialize() {
+    }
+    setValue(e) {
+      if (this.value == e)
+        return;
+      let r = this.value;
+      this.value = e, window.localStorage[this.key] = this.toLocalStorage(e), this.handleValueChange(r, e);
+    }
+  }, re = class extends te {
+    initialize() {
+      let r = document.querySelector("#tsd-filter-" + this.key);
+      !r || (this.checkbox = r, this.checkbox.addEventListener("change", () => {
+        this.setValue(this.checkbox.checked);
+      }));
+    }
+    handleValueChange(r, n) {
+      !this.checkbox || (this.checkbox.checked = this.value, document.documentElement.classList.toggle("toggle-" + this.key, this.value != this.defaultValue));
+    }
+    fromLocalStorage(r) {
+      return r == "true";
+    }
+    toLocalStorage(r) {
+      return r ? "true" : "false";
+    }
+  }, le = class extends te {
+    initialize() {
+      document.documentElement.classList.add("toggle-" + this.key + this.value);
+      let r = document.querySelector("#tsd-filter-" + this.key);
+      if (!r)
+        return;
+      this.select = r;
+      let n = () => {
+        this.select.classList.add("active");
+      }, i = () => {
+        this.select.classList.remove("active");
+      };
+      this.select.addEventListener(C, n), this.select.addEventListener("mouseover", n), this.select.addEventListener("mouseleave", i), this.select.querySelectorAll("li").forEach((s) => {
+        s.addEventListener(_, (o) => {
+          r.classList.remove("active"), this.setValue(o.target.dataset.value || "");
+        });
+      }), document.addEventListener(C, (s) => {
+        this.select.contains(s.target) || this.select.classList.remove("active");
+      });
+    }
+    handleValueChange(r, n) {
+      this.select.querySelectorAll("li.selected").forEach((o) => {
+        o.classList.remove("selected");
+      });
+      let i = this.select.querySelector('li[data-value="' + n + '"]'), s = this.select.querySelector(".tsd-select-label");
+      i && s && (i.classList.add("selected"), s.textContent = i.textContent), document.documentElement.classList.remove("toggle-" + r), document.documentElement.classList.add("toggle-" + n);
+    }
+    fromLocalStorage(r) {
+      return r;
+    }
+    toLocalStorage(r) {
+      return r;
+    }
+  }, j = class extends k {
+    constructor(r) {
+      super(r);
+      this.optionVisibility = new le("visibility", "private"), this.optionInherited = new re("inherited", true), this.optionExternals = new re("externals", true);
+    }
+    static isSupported() {
+      try {
+        return typeof window.localStorage != "undefined";
+      } catch {
+        return false;
+      }
+    }
+  };
+  function we(t) {
+    let e = localStorage.getItem("tsd-theme") || "os";
+    t.value = e, be(e), t.addEventListener("change", () => {
+      localStorage.setItem("tsd-theme", t.value), be(t.value);
+    });
+  }
+  function be(t) {
+    switch (t) {
+      case "os":
+        document.body.classList.remove("light", "dark");
+        break;
+      case "light":
+        document.body.classList.remove("dark"), document.body.classList.add("light");
+        break;
+      case "dark":
+        document.body.classList.remove("light"), document.body.classList.add("dark");
+        break;
+    }
+  }
+  ye();
+  N(X, ".menu-highlight");
+  N(Z, ".tsd-signatures");
+  N(ee, "a[data-toggle]");
+  j.isSupported() ? N(j, "#tsd-filter") : document.documentElement.classList.add("no-filter");
+  var Te = document.getElementById("theme");
+  Te && we(Te);
+  var Be = new Y();
+  Object.defineProperty(window, "app", { value: Be });
+})();
+/*!
+ * lunr.Builder
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.Index
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.Pipeline
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.Set
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.TokenSet
+ * 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.tokenizer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.trimmer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/*!
+ * lunr.utils
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+/**
+ * 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
+ */