/**
 * 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
 */
!(function () {
  var e = function (t) {
    var r = new e.Builder();
    return (
      r.pipeline.add(e.trimmer, e.stopWordFilter, e.stemmer),
      r.searchPipeline.add(e.stemmer),
      t.call(r, r),
      r.build()
    );
  };
  ((e.version = "2.3.9"),
    (e.utils = {}),
    (e.utils.warn = (function (e) {
      return function (t) {
        e.console && console.warn && console.warn(t);
      };
    })(this)),
    (e.utils.asString = function (e) {
      return void 0 === e || null === e ? "" : e.toString();
    }),
    (e.utils.clone = function (e) {
      if (null === e || void 0 === e) return e;
      for (
        var t = Object.create(null), r = Object.keys(e), i = 0;
        i < r.length;
        i++
      ) {
        var n = r[i],
          s = e[n];
        if (Array.isArray(s)) t[n] = s.slice();
        else {
          if (
            "string" != typeof s &&
            "number" != typeof s &&
            "boolean" != typeof s
          )
            throw new TypeError(
              "clone is not deep and does not support nested objects",
            );
          t[n] = s;
        }
      }
      return t;
    }),
    (e.FieldRef = function (e, t, r) {
      ((this.docRef = e), (this.fieldName = t), (this._stringValue = r));
    }),
    (e.FieldRef.joiner = "/"),
    (e.FieldRef.fromString = function (t) {
      var r = t.indexOf(e.FieldRef.joiner);
      if (r === -1) throw "malformed field ref string";
      var i = t.slice(0, r),
        n = t.slice(r + 1);
      return new e.FieldRef(n, i, t);
    }),
    (e.FieldRef.prototype.toString = function () {
      return (
        void 0 == this._stringValue &&
          (this._stringValue =
            this.fieldName + e.FieldRef.joiner + this.docRef),
        this._stringValue
      );
    }),
    (e.Set = function (e) {
      if (((this.elements = Object.create(null)), e)) {
        this.length = e.length;
        for (var t = 0; t < this.length; t++) this.elements[e[t]] = !0;
      } else this.length = 0;
    }),
    (e.Set.complete = {
      intersect: function (e) {
        return e;
      },
      union: function () {
        return this;
      },
      contains: function () {
        return !0;
      },
    }),
    (e.Set.empty = {
      intersect: function () {
        return this;
      },
      union: function (e) {
        return e;
      },
      contains: function () {
        return !1;
      },
    }),
    (e.Set.prototype.contains = function (e) {
      return !!this.elements[e];
    }),
    (e.Set.prototype.intersect = function (t) {
      var r,
        i,
        n,
        s = [];
      if (t === e.Set.complete) return this;
      if (t === e.Set.empty) return t;
      (this.length < t.length ? ((r = this), (i = t)) : ((r = t), (i = this)),
        (n = Object.keys(r.elements)));
      for (var o = 0; o < n.length; o++) {
        var a = n[o];
        a in i.elements && s.push(a);
      }
      return new e.Set(s);
    }),
    (e.Set.prototype.union = function (t) {
      return t === e.Set.complete
        ? e.Set.complete
        : t === e.Set.empty
          ? this
          : new e.Set(
              Object.keys(this.elements).concat(Object.keys(t.elements)),
            );
    }),
    (e.idf = function (e, t) {
      var r = 0;
      for (var i in e) "_index" != i && (r += Object.keys(e[i]).length);
      var n = (t - r + 0.5) / (r + 0.5);
      return Math.log(1 + Math.abs(n));
    }),
    (e.Token = function (e, t) {
      ((this.str = e || ""), (this.metadata = t || {}));
    }),
    (e.Token.prototype.toString = function () {
      return this.str;
    }),
    (e.Token.prototype.update = function (e) {
      return ((this.str = e(this.str, this.metadata)), this);
    }),
    (e.Token.prototype.clone = function (t) {
      return (
        (t =
          t ||
          function (e) {
            return e;
          }),
        new e.Token(t(this.str, this.metadata), this.metadata)
      );
    }),
    (e.tokenizer = function (t, r) {
      if (null == t || void 0 == t) return [];
      if (Array.isArray(t))
        return t.map(function (t) {
          return new e.Token(
            e.utils.asString(t).toLowerCase(),
            e.utils.clone(r),
          );
        });
      for (
        var i = t.toString().toLowerCase(), n = i.length, s = [], o = 0, a = 0;
        o <= n;
        o++
      ) {
        var u = i.charAt(o),
          l = o - a;
        if (u.match(e.tokenizer.separator) || o == n) {
          if (l > 0) {
            var c = e.utils.clone(r) || {};
            ((c.position = [a, l]),
              (c.index = s.length),
              s.push(new e.Token(i.slice(a, o), c)));
          }
          a = o + 1;
        }
      }
      return s;
    }),
    (e.tokenizer.separator = /[\s\-]+/),
    (e.Pipeline = function () {
      this._stack = [];
    }),
    (e.Pipeline.registeredFunctions = Object.create(null)),
    (e.Pipeline.registerFunction = function (t, r) {
      (r in this.registeredFunctions &&
        e.utils.warn("Overwriting existing registered function: " + r),
        (t.label = r),
        (e.Pipeline.registeredFunctions[t.label] = t));
    }),
    (e.Pipeline.warnIfFunctionNotRegistered = function (t) {
      var r = t.label && t.label in this.registeredFunctions;
      r ||
        e.utils.warn(
          "Function is not registered with pipeline. This may cause problems when serialising the index.\n",
          t,
        );
    }),
    (e.Pipeline.load = function (t) {
      var r = new e.Pipeline();
      return (
        t.forEach(function (t) {
          var i = e.Pipeline.registeredFunctions[t];
          if (!i) throw new Error("Cannot load unregistered function: " + t);
          r.add(i);
        }),
        r
      );
    }),
    (e.Pipeline.prototype.add = function () {
      var t = Array.prototype.slice.call(arguments);
      t.forEach(function (t) {
        (e.Pipeline.warnIfFunctionNotRegistered(t), this._stack.push(t));
      }, this);
    }),
    (e.Pipeline.prototype.after = function (t, r) {
      e.Pipeline.warnIfFunctionNotRegistered(r);
      var i = this._stack.indexOf(t);
      if (i == -1) throw new Error("Cannot find existingFn");
      ((i += 1), this._stack.splice(i, 0, r));
    }),
    (e.Pipeline.prototype.before = function (t, r) {
      e.Pipeline.warnIfFunctionNotRegistered(r);
      var i = this._stack.indexOf(t);
      if (i == -1) throw new Error("Cannot find existingFn");
      this._stack.splice(i, 0, r);
    }),
    (e.Pipeline.prototype.remove = function (e) {
      var t = this._stack.indexOf(e);
      t != -1 && this._stack.splice(t, 1);
    }),
    (e.Pipeline.prototype.run = function (e) {
      for (var t = this._stack.length, r = 0; r < t; r++) {
        for (var i = this._stack[r], n = [], s = 0; s < e.length; s++) {
          var o = i(e[s], s, e);
          if (null !== o && void 0 !== o && "" !== o)
            if (Array.isArray(o))
              for (var a = 0; a < o.length; a++) n.push(o[a]);
            else n.push(o);
        }
        e = n;
      }
      return e;
    }),
    (e.Pipeline.prototype.runString = function (t, r) {
      var i = new e.Token(t, r);
      return this.run([i]).map(function (e) {
        return e.toString();
      });
    }),
    (e.Pipeline.prototype.reset = function () {
      this._stack = [];
    }),
    (e.Pipeline.prototype.toJSON = function () {
      return this._stack.map(function (t) {
        return (e.Pipeline.warnIfFunctionNotRegistered(t), t.label);
      });
    }),
    (e.Vector = function (e) {
      ((this._magnitude = 0), (this.elements = e || []));
    }),
    (e.Vector.prototype.positionForIndex = function (e) {
      if (0 == this.elements.length) return 0;
      for (
        var t = 0,
          r = this.elements.length / 2,
          i = r - t,
          n = Math.floor(i / 2),
          s = this.elements[2 * n];
        i > 1 && (s < e && (t = n), s > e && (r = n), s != e);
      )
        ((i = r - t), (n = t + Math.floor(i / 2)), (s = this.elements[2 * n]));
      return s == e ? 2 * n : s > e ? 2 * n : s < e ? 2 * (n + 1) : void 0;
    }),
    (e.Vector.prototype.insert = function (e, t) {
      this.upsert(e, t, function () {
        throw "duplicate index";
      });
    }),
    (e.Vector.prototype.upsert = function (e, t, r) {
      this._magnitude = 0;
      var i = this.positionForIndex(e);
      this.elements[i] == e
        ? (this.elements[i + 1] = r(this.elements[i + 1], t))
        : this.elements.splice(i, 0, e, t);
    }),
    (e.Vector.prototype.magnitude = function () {
      if (this._magnitude) return this._magnitude;
      for (var e = 0, t = this.elements.length, r = 1; r < t; r += 2) {
        var i = this.elements[r];
        e += i * i;
      }
      return (this._magnitude = Math.sqrt(e));
    }),
    (e.Vector.prototype.dot = function (e) {
      for (
        var t = 0,
          r = this.elements,
          i = e.elements,
          n = r.length,
          s = i.length,
          o = 0,
          a = 0,
          u = 0,
          l = 0;
        u < n && l < s;
      )
        ((o = r[u]),
          (a = i[l]),
          o < a
            ? (u += 2)
            : o > a
              ? (l += 2)
              : o == a && ((t += r[u + 1] * i[l + 1]), (u += 2), (l += 2)));
      return t;
    }),
    (e.Vector.prototype.similarity = function (e) {
      return this.dot(e) / this.magnitude() || 0;
    }),
    (e.Vector.prototype.toArray = function () {
      for (
        var e = new Array(this.elements.length / 2), t = 1, r = 0;
        t < this.elements.length;
        t += 2, r++
      )
        e[r] = this.elements[t];
      return e;
    }),
    (e.Vector.prototype.toJSON = function () {
      return this.elements;
    }),
    (e.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",
        },
        t = {
          icate: "ic",
          ative: "",
          alize: "al",
          iciti: "ic",
          ical: "ic",
          ful: "",
          ness: "",
        },
        r = "[^aeiou]",
        i = "[aeiouy]",
        n = r + "[^aeiouy]*",
        s = i + "[aeiou]*",
        o = "^(" + n + ")?" + s + n,
        a = "^(" + n + ")?" + s + n + "(" + s + ")?$",
        u = "^(" + n + ")?" + s + n + s + n,
        l = "^(" + n + ")?" + i,
        c = new RegExp(o),
        h = new RegExp(u),
        d = new RegExp(a),
        f = new RegExp(l),
        p = /^(.+?)(ss|i)es$/,
        y = /^(.+?)([^s])s$/,
        m = /^(.+?)eed$/,
        v = /^(.+?)(ed|ing)$/,
        g = /.$/,
        x = /(at|bl|iz)$/,
        w = new RegExp("([^aeiouylsz])\\1$"),
        Q = new RegExp("^" + n + i + "[^aeiouwxy]$"),
        k = /^(.+?[^aeiou])y$/,
        S =
          /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,
        E = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,
        L =
          /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,
        b = /^(.+?)(s|t)(ion)$/,
        P = /^(.+?)e$/,
        T = /ll$/,
        O = new RegExp("^" + n + i + "[^aeiouwxy]$"),
        I = function (r) {
          var i, n, s, o, a, u, l;
          if (r.length < 3) return r;
          if (
            ((s = r.substr(0, 1)),
            "y" == s && (r = s.toUpperCase() + r.substr(1)),
            (o = p),
            (a = y),
            o.test(r)
              ? (r = r.replace(o, "$1$2"))
              : a.test(r) && (r = r.replace(a, "$1$2")),
            (o = m),
            (a = v),
            o.test(r))
          ) {
            var I = o.exec(r);
            ((o = c), o.test(I[1]) && ((o = g), (r = r.replace(o, ""))));
          } else if (a.test(r)) {
            var I = a.exec(r);
            ((i = I[1]),
              (a = f),
              a.test(i) &&
                ((r = i),
                (a = x),
                (u = w),
                (l = Q),
                a.test(r)
                  ? (r += "e")
                  : u.test(r)
                    ? ((o = g), (r = r.replace(o, "")))
                    : l.test(r) && (r += "e")));
          }
          if (((o = k), o.test(r))) {
            var I = o.exec(r);
            ((i = I[1]), (r = i + "i"));
          }
          if (((o = S), o.test(r))) {
            var I = o.exec(r);
            ((i = I[1]), (n = I[2]), (o = c), o.test(i) && (r = i + e[n]));
          }
          if (((o = E), o.test(r))) {
            var I = o.exec(r);
            ((i = I[1]), (n = I[2]), (o = c), o.test(i) && (r = i + t[n]));
          }
          if (((o = L), (a = b), o.test(r))) {
            var I = o.exec(r);
            ((i = I[1]), (o = h), o.test(i) && (r = i));
          } else if (a.test(r)) {
            var I = a.exec(r);
            ((i = I[1] + I[2]), (a = h), a.test(i) && (r = i));
          }
          if (((o = P), o.test(r))) {
            var I = o.exec(r);
            ((i = I[1]),
              (o = h),
              (a = d),
              (u = O),
              (o.test(i) || (a.test(i) && !u.test(i))) && (r = i));
          }
          return (
            (o = T),
            (a = h),
            o.test(r) && a.test(r) && ((o = g), (r = r.replace(o, ""))),
            "y" == s && (r = s.toLowerCase() + r.substr(1)),
            r
          );
        };
      return function (e) {
        return e.update(I);
      };
    })()),
    e.Pipeline.registerFunction(e.stemmer, "stemmer"),
    (e.generateStopWordFilter = function (e) {
      var t = e.reduce(function (e, t) {
        return ((e[t] = t), e);
      }, {});
      return function (e) {
        if (e && t[e.toString()] !== e.toString()) return e;
      };
    }),
    (e.stopWordFilter = e.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",
    ])),
    e.Pipeline.registerFunction(e.stopWordFilter, "stopWordFilter"),
    (e.trimmer = function (e) {
      return e.update(function (e) {
        return e.replace(/^\W+/, "").replace(/\W+$/, "");
      });
    }),
    e.Pipeline.registerFunction(e.trimmer, "trimmer"),
    (e.TokenSet = function () {
      ((this["final"] = !1),
        (this.edges = {}),
        (this.id = e.TokenSet._nextId),
        (e.TokenSet._nextId += 1));
    }),
    (e.TokenSet._nextId = 1),
    (e.TokenSet.fromArray = function (t) {
      for (var r = new e.TokenSet.Builder(), i = 0, n = t.length; i < n; i++)
        r.insert(t[i]);
      return (r.finish(), r.root);
    }),
    (e.TokenSet.fromClause = function (t) {
      return "editDistance" in t
        ? e.TokenSet.fromFuzzyString(t.term, t.editDistance)
        : e.TokenSet.fromString(t.term);
    }),
    (e.TokenSet.fromFuzzyString = function (t, r) {
      for (
        var i = new e.TokenSet(), n = [{ node: i, editsRemaining: r, str: t }];
        n.length;
      ) {
        var s = n.pop();
        if (s.str.length > 0) {
          var o,
            a = s.str.charAt(0);
          (a in s.node.edges
            ? (o = s.node.edges[a])
            : ((o = new e.TokenSet()), (s.node.edges[a] = o)),
            1 == s.str.length && (o["final"] = !0),
            n.push({
              node: o,
              editsRemaining: s.editsRemaining,
              str: s.str.slice(1),
            }));
        }
        if (0 != s.editsRemaining) {
          if ("*" in s.node.edges) var u = s.node.edges["*"];
          else {
            var u = new e.TokenSet();
            s.node.edges["*"] = u;
          }
          if (
            (0 == s.str.length && (u["final"] = !0),
            n.push({
              node: u,
              editsRemaining: s.editsRemaining - 1,
              str: s.str,
            }),
            s.str.length > 1 &&
              n.push({
                node: s.node,
                editsRemaining: s.editsRemaining - 1,
                str: s.str.slice(1),
              }),
            1 == s.str.length && (s.node["final"] = !0),
            s.str.length >= 1)
          ) {
            if ("*" in s.node.edges) var l = s.node.edges["*"];
            else {
              var l = new e.TokenSet();
              s.node.edges["*"] = l;
            }
            (1 == s.str.length && (l["final"] = !0),
              n.push({
                node: l,
                editsRemaining: s.editsRemaining - 1,
                str: s.str.slice(1),
              }));
          }
          if (s.str.length > 1) {
            var c,
              h = s.str.charAt(0),
              d = s.str.charAt(1);
            (d in s.node.edges
              ? (c = s.node.edges[d])
              : ((c = new e.TokenSet()), (s.node.edges[d] = c)),
              1 == s.str.length && (c["final"] = !0),
              n.push({
                node: c,
                editsRemaining: s.editsRemaining - 1,
                str: h + s.str.slice(2),
              }));
          }
        }
      }
      return i;
    }),
    (e.TokenSet.fromString = function (t) {
      for (var r = new e.TokenSet(), i = r, n = 0, s = t.length; n < s; n++) {
        var o = t[n],
          a = n == s - 1;
        if ("*" == o) ((r.edges[o] = r), (r["final"] = a));
        else {
          var u = new e.TokenSet();
          ((u["final"] = a), (r.edges[o] = u), (r = u));
        }
      }
      return i;
    }),
    (e.TokenSet.prototype.toArray = function () {
      for (var e = [], t = [{ prefix: "", node: this }]; t.length; ) {
        var r = t.pop(),
          i = Object.keys(r.node.edges),
          n = i.length;
        r.node["final"] && (r.prefix.charAt(0), e.push(r.prefix));
        for (var s = 0; s < n; s++) {
          var o = i[s];
          t.push({ prefix: r.prefix.concat(o), node: r.node.edges[o] });
        }
      }
      return e;
    }),
    (e.TokenSet.prototype.toString = function () {
      if (this._str) return this._str;
      for (
        var e = this["final"] ? "1" : "0",
          t = Object.keys(this.edges).sort(),
          r = t.length,
          i = 0;
        i < r;
        i++
      ) {
        var n = t[i],
          s = this.edges[n];
        e = e + n + s.id;
      }
      return e;
    }),
    (e.TokenSet.prototype.intersect = function (t) {
      for (
        var r = new e.TokenSet(),
          i = void 0,
          n = [{ qNode: t, output: r, node: this }];
        n.length;
      ) {
        i = n.pop();
        for (
          var s = Object.keys(i.qNode.edges),
            o = s.length,
            a = Object.keys(i.node.edges),
            u = a.length,
            l = 0;
          l < o;
          l++
        )
          for (var c = s[l], h = 0; h < u; h++) {
            var d = a[h];
            if (d == c || "*" == c) {
              var f = i.node.edges[d],
                p = i.qNode.edges[c],
                y = f["final"] && p["final"],
                m = void 0;
              (d in i.output.edges
                ? ((m = i.output.edges[d]), (m["final"] = m["final"] || y))
                : ((m = new e.TokenSet()),
                  (m["final"] = y),
                  (i.output.edges[d] = m)),
                n.push({ qNode: p, output: m, node: f }));
            }
          }
      }
      return r;
    }),
    (e.TokenSet.Builder = function () {
      ((this.previousWord = ""),
        (this.root = new e.TokenSet()),
        (this.uncheckedNodes = []),
        (this.minimizedNodes = {}));
    }),
    (e.TokenSet.Builder.prototype.insert = function (t) {
      var r,
        i = 0;
      if (t < this.previousWord) throw new Error("Out of order word insertion");
      for (
        var n = 0;
        n < t.length &&
        n < this.previousWord.length &&
        t[n] == this.previousWord[n];
        n++
      )
        i++;
      (this.minimize(i),
        (r =
          0 == this.uncheckedNodes.length
            ? this.root
            : this.uncheckedNodes[this.uncheckedNodes.length - 1].child));
      for (var n = i; n < t.length; n++) {
        var s = new e.TokenSet(),
          o = t[n];
        ((r.edges[o] = s),
          this.uncheckedNodes.push({ parent: r, char: o, child: s }),
          (r = s));
      }
      ((r["final"] = !0), (this.previousWord = t));
    }),
    (e.TokenSet.Builder.prototype.finish = function () {
      this.minimize(0);
    }),
    (e.TokenSet.Builder.prototype.minimize = function (e) {
      for (var t = this.uncheckedNodes.length - 1; t >= e; t--) {
        var r = this.uncheckedNodes[t],
          i = r.child.toString();
        (i in this.minimizedNodes
          ? (r.parent.edges[r["char"]] = this.minimizedNodes[i])
          : ((r.child._str = i), (this.minimizedNodes[i] = r.child)),
          this.uncheckedNodes.pop());
      }
    }),
    (e.Index = function (e) {
      ((this.invertedIndex = e.invertedIndex),
        (this.fieldVectors = e.fieldVectors),
        (this.tokenSet = e.tokenSet),
        (this.fields = e.fields),
        (this.pipeline = e.pipeline));
    }),
    (e.Index.prototype.search = function (t) {
      return this.query(function (r) {
        var i = new e.QueryParser(t, r);
        i.parse();
      });
    }),
    (e.Index.prototype.query = function (t) {
      for (
        var r = new e.Query(this.fields),
          i = Object.create(null),
          n = Object.create(null),
          s = Object.create(null),
          o = Object.create(null),
          a = Object.create(null),
          u = 0;
        u < this.fields.length;
        u++
      )
        n[this.fields[u]] = new e.Vector();
      t.call(r, r);
      for (var u = 0; u < r.clauses.length; u++) {
        var l = r.clauses[u],
          c = null,
          h = e.Set.empty;
        c = l.usePipeline
          ? this.pipeline.runString(l.term, { fields: l.fields })
          : [l.term];
        for (var d = 0; d < c.length; d++) {
          var f = c[d];
          l.term = f;
          var p = e.TokenSet.fromClause(l),
            y = this.tokenSet.intersect(p).toArray();
          if (0 === y.length && l.presence === e.Query.presence.REQUIRED) {
            for (var m = 0; m < l.fields.length; m++) {
              var v = l.fields[m];
              o[v] = e.Set.empty;
            }
            break;
          }
          for (var g = 0; g < y.length; g++)
            for (
              var x = y[g], w = this.invertedIndex[x], Q = w._index, m = 0;
              m < l.fields.length;
              m++
            ) {
              var v = l.fields[m],
                k = w[v],
                S = Object.keys(k),
                E = x + "/" + v,
                L = new e.Set(S);
              if (
                (l.presence == e.Query.presence.REQUIRED &&
                  ((h = h.union(L)),
                  void 0 === o[v] && (o[v] = e.Set.complete)),
                l.presence != e.Query.presence.PROHIBITED)
              ) {
                if (
                  (n[v].upsert(Q, l.boost, function (e, t) {
                    return e + t;
                  }),
                  !s[E])
                ) {
                  for (var b = 0; b < S.length; b++) {
                    var P,
                      T = S[b],
                      O = new e.FieldRef(T, v),
                      I = k[T];
                    void 0 === (P = i[O])
                      ? (i[O] = new e.MatchData(x, v, I))
                      : P.add(x, v, I);
                  }
                  s[E] = !0;
                }
              } else
                (void 0 === a[v] && (a[v] = e.Set.empty),
                  (a[v] = a[v].union(L)));
            }
        }
        if (l.presence === e.Query.presence.REQUIRED)
          for (var m = 0; m < l.fields.length; m++) {
            var v = l.fields[m];
            o[v] = o[v].intersect(h);
          }
      }
      for (
        var R = e.Set.complete, F = e.Set.empty, u = 0;
        u < this.fields.length;
        u++
      ) {
        var v = this.fields[u];
        (o[v] && (R = R.intersect(o[v])), a[v] && (F = F.union(a[v])));
      }
      var C = Object.keys(i),
        N = [],
        _ = Object.create(null);
      if (r.isNegated()) {
        C = Object.keys(this.fieldVectors);
        for (var u = 0; u < C.length; u++) {
          var O = C[u],
            j = e.FieldRef.fromString(O);
          i[O] = new e.MatchData();
        }
      }
      for (var u = 0; u < C.length; u++) {
        var j = e.FieldRef.fromString(C[u]),
          D = j.docRef;
        if (R.contains(D) && !F.contains(D)) {
          var A,
            B = this.fieldVectors[j],
            V = n[j.fieldName].similarity(B);
          if (void 0 !== (A = _[D]))
            ((A.score += V), A.matchData.combine(i[j]));
          else {
            var z = { ref: D, score: V, matchData: i[j] };
            ((_[D] = z), N.push(z));
          }
        }
      }
      return N.sort(function (e, t) {
        return t.score - e.score;
      });
    }),
    (e.Index.prototype.toJSON = function () {
      var t = Object.keys(this.invertedIndex)
          .sort()
          .map(function (e) {
            return [e, this.invertedIndex[e]];
          }, this),
        r = Object.keys(this.fieldVectors).map(function (e) {
          return [e, this.fieldVectors[e].toJSON()];
        }, this);
      return {
        version: e.version,
        fields: this.fields,
        fieldVectors: r,
        invertedIndex: t,
        pipeline: this.pipeline.toJSON(),
      };
    }),
    (e.Index.load = function (t) {
      var r = {},
        i = {},
        n = t.fieldVectors,
        s = Object.create(null),
        o = t.invertedIndex,
        a = new e.TokenSet.Builder(),
        u = e.Pipeline.load(t.pipeline);
      t.version != e.version &&
        e.utils.warn(
          "Version mismatch when loading serialised index. Current version of lunr '" +
            e.version +
            "' does not match serialized index '" +
            t.version +
            "'",
        );
      for (var l = 0; l < n.length; l++) {
        var c = n[l],
          h = c[0],
          d = c[1];
        i[h] = new e.Vector(d);
      }
      for (var l = 0; l < o.length; l++) {
        var c = o[l],
          f = c[0],
          p = c[1];
        (a.insert(f), (s[f] = p));
      }
      return (
        a.finish(),
        (r.fields = t.fields),
        (r.fieldVectors = i),
        (r.invertedIndex = s),
        (r.tokenSet = a.root),
        (r.pipeline = u),
        new e.Index(r)
      );
    }),
    (e.Builder = function () {
      ((this._ref = "id"),
        (this._fields = Object.create(null)),
        (this._documents = Object.create(null)),
        (this.invertedIndex = Object.create(null)),
        (this.fieldTermFrequencies = {}),
        (this.fieldLengths = {}),
        (this.tokenizer = e.tokenizer),
        (this.pipeline = new e.Pipeline()),
        (this.searchPipeline = new e.Pipeline()),
        (this.documentCount = 0),
        (this._b = 0.75),
        (this._k1 = 1.2),
        (this.termIndex = 0),
        (this.metadataWhitelist = []));
    }),
    (e.Builder.prototype.ref = function (e) {
      this._ref = e;
    }),
    (e.Builder.prototype.field = function (e, t) {
      if (/\//.test(e))
        throw new RangeError(
          "Field '" + e + "' contains illegal character '/'",
        );
      this._fields[e] = t || {};
    }),
    (e.Builder.prototype.b = function (e) {
      e < 0 ? (this._b = 0) : e > 1 ? (this._b = 1) : (this._b = e);
    }),
    (e.Builder.prototype.k1 = function (e) {
      this._k1 = e;
    }),
    (e.Builder.prototype.add = function (t, r) {
      var i = t[this._ref],
        n = Object.keys(this._fields);
      ((this._documents[i] = r || {}), (this.documentCount += 1));
      for (var s = 0; s < n.length; s++) {
        var o = n[s],
          a = this._fields[o].extractor,
          u = a ? a(t) : t[o],
          l = this.tokenizer(u, { fields: [o] }),
          c = this.pipeline.run(l),
          h = new e.FieldRef(i, o),
          d = Object.create(null);
        ((this.fieldTermFrequencies[h] = d),
          (this.fieldLengths[h] = 0),
          (this.fieldLengths[h] += c.length));
        for (var f = 0; f < c.length; f++) {
          var p = c[f];
          if (
            (void 0 == d[p] && (d[p] = 0),
            (d[p] += 1),
            void 0 == this.invertedIndex[p])
          ) {
            var y = Object.create(null);
            ((y._index = this.termIndex), (this.termIndex += 1));
            for (var m = 0; m < n.length; m++) y[n[m]] = Object.create(null);
            this.invertedIndex[p] = y;
          }
          void 0 == this.invertedIndex[p][o][i] &&
            (this.invertedIndex[p][o][i] = Object.create(null));
          for (var v = 0; v < this.metadataWhitelist.length; v++) {
            var g = this.metadataWhitelist[v],
              x = p.metadata[g];
            (void 0 == this.invertedIndex[p][o][i][g] &&
              (this.invertedIndex[p][o][i][g] = []),
              this.invertedIndex[p][o][i][g].push(x));
          }
        }
      }
    }),
    (e.Builder.prototype.calculateAverageFieldLengths = function () {
      for (
        var t = Object.keys(this.fieldLengths),
          r = t.length,
          i = {},
          n = {},
          s = 0;
        s < r;
        s++
      ) {
        var o = e.FieldRef.fromString(t[s]),
          a = o.fieldName;
        (n[a] || (n[a] = 0),
          (n[a] += 1),
          i[a] || (i[a] = 0),
          (i[a] += this.fieldLengths[o]));
      }
      for (var u = Object.keys(this._fields), s = 0; s < u.length; s++) {
        var l = u[s];
        i[l] = i[l] / n[l];
      }
      this.averageFieldLength = i;
    }),
    (e.Builder.prototype.createFieldVectors = function () {
      for (
        var t = {},
          r = Object.keys(this.fieldTermFrequencies),
          i = r.length,
          n = Object.create(null),
          s = 0;
        s < i;
        s++
      ) {
        for (
          var o = e.FieldRef.fromString(r[s]),
            a = o.fieldName,
            u = this.fieldLengths[o],
            l = new e.Vector(),
            c = this.fieldTermFrequencies[o],
            h = Object.keys(c),
            d = h.length,
            f = this._fields[a].boost || 1,
            p = this._documents[o.docRef].boost || 1,
            y = 0;
          y < d;
          y++
        ) {
          var m,
            v,
            g,
            x = h[y],
            w = c[x],
            Q = this.invertedIndex[x]._index;
          (void 0 === n[x]
            ? ((m = e.idf(this.invertedIndex[x], this.documentCount)),
              (n[x] = m))
            : (m = n[x]),
            (v =
              (m * ((this._k1 + 1) * w)) /
              (this._k1 *
                (1 - this._b + this._b * (u / this.averageFieldLength[a])) +
                w)),
            (v *= f),
            (v *= p),
            (g = Math.round(1e3 * v) / 1e3),
            l.insert(Q, g));
        }
        t[o] = l;
      }
      this.fieldVectors = t;
    }),
    (e.Builder.prototype.createTokenSet = function () {
      this.tokenSet = e.TokenSet.fromArray(
        Object.keys(this.invertedIndex).sort(),
      );
    }),
    (e.Builder.prototype.build = function () {
      return (
        this.calculateAverageFieldLengths(),
        this.createFieldVectors(),
        this.createTokenSet(),
        new e.Index({
          invertedIndex: this.invertedIndex,
          fieldVectors: this.fieldVectors,
          tokenSet: this.tokenSet,
          fields: Object.keys(this._fields),
          pipeline: this.searchPipeline,
        })
      );
    }),
    (e.Builder.prototype.use = function (e) {
      var t = Array.prototype.slice.call(arguments, 1);
      (t.unshift(this), e.apply(this, t));
    }),
    (e.MatchData = function (e, t, r) {
      for (
        var i = Object.create(null), n = Object.keys(r || {}), s = 0;
        s < n.length;
        s++
      ) {
        var o = n[s];
        i[o] = r[o].slice();
      }
      ((this.metadata = Object.create(null)),
        void 0 !== e &&
          ((this.metadata[e] = Object.create(null)),
          (this.metadata[e][t] = i)));
    }),
    (e.MatchData.prototype.combine = function (e) {
      for (var t = Object.keys(e.metadata), r = 0; r < t.length; r++) {
        var i = t[r],
          n = Object.keys(e.metadata[i]);
        void 0 == this.metadata[i] && (this.metadata[i] = Object.create(null));
        for (var s = 0; s < n.length; s++) {
          var o = n[s],
            a = Object.keys(e.metadata[i][o]);
          void 0 == this.metadata[i][o] &&
            (this.metadata[i][o] = Object.create(null));
          for (var u = 0; u < a.length; u++) {
            var l = a[u];
            void 0 == this.metadata[i][o][l]
              ? (this.metadata[i][o][l] = e.metadata[i][o][l])
              : (this.metadata[i][o][l] = this.metadata[i][o][l].concat(
                  e.metadata[i][o][l],
                ));
          }
        }
      }
    }),
    (e.MatchData.prototype.add = function (e, t, r) {
      if (!(e in this.metadata))
        return (
          (this.metadata[e] = Object.create(null)),
          void (this.metadata[e][t] = r)
        );
      if (!(t in this.metadata[e])) return void (this.metadata[e][t] = r);
      for (var i = Object.keys(r), n = 0; n < i.length; n++) {
        var s = i[n];
        s in this.metadata[e][t]
          ? (this.metadata[e][t][s] = this.metadata[e][t][s].concat(r[s]))
          : (this.metadata[e][t][s] = r[s]);
      }
    }),
    (e.Query = function (e) {
      ((this.clauses = []), (this.allFields = e));
    }),
    (e.Query.wildcard = new String("*")),
    (e.Query.wildcard.NONE = 0),
    (e.Query.wildcard.LEADING = 1),
    (e.Query.wildcard.TRAILING = 2),
    (e.Query.presence = { OPTIONAL: 1, REQUIRED: 2, PROHIBITED: 3 }),
    (e.Query.prototype.clause = function (t) {
      return (
        "fields" in t || (t.fields = this.allFields),
        "boost" in t || (t.boost = 1),
        "usePipeline" in t || (t.usePipeline = !0),
        "wildcard" in t || (t.wildcard = e.Query.wildcard.NONE),
        t.wildcard & e.Query.wildcard.LEADING &&
          t.term.charAt(0) != e.Query.wildcard &&
          (t.term = "*" + t.term),
        t.wildcard & e.Query.wildcard.TRAILING &&
          t.term.slice(-1) != e.Query.wildcard &&
          (t.term = "" + t.term + "*"),
        "presence" in t || (t.presence = e.Query.presence.OPTIONAL),
        this.clauses.push(t),
        this
      );
    }),
    (e.Query.prototype.isNegated = function () {
      for (var t = 0; t < this.clauses.length; t++)
        if (this.clauses[t].presence != e.Query.presence.PROHIBITED) return !1;
      return !0;
    }),
    (e.Query.prototype.term = function (t, r) {
      if (Array.isArray(t))
        return (
          t.forEach(function (t) {
            this.term(t, e.utils.clone(r));
          }, this),
          this
        );
      var i = r || {};
      return ((i.term = t.toString()), this.clause(i), this);
    }),
    (e.QueryParseError = function (e, t, r) {
      ((this.name = "QueryParseError"),
        (this.message = e),
        (this.start = t),
        (this.end = r));
    }),
    (e.QueryParseError.prototype = new Error()),
    (e.QueryLexer = function (e) {
      ((this.lexemes = []),
        (this.str = e),
        (this.length = e.length),
        (this.pos = 0),
        (this.start = 0),
        (this.escapeCharPositions = []));
    }),
    (e.QueryLexer.prototype.run = function () {
      for (var t = e.QueryLexer.lexText; t; ) t = t(this);
    }),
    (e.QueryLexer.prototype.sliceString = function () {
      for (
        var e = [], t = this.start, r = this.pos, i = 0;
        i < this.escapeCharPositions.length;
        i++
      )
        ((r = this.escapeCharPositions[i]),
          e.push(this.str.slice(t, r)),
          (t = r + 1));
      return (
        e.push(this.str.slice(t, this.pos)),
        (this.escapeCharPositions.length = 0),
        e.join("")
      );
    }),
    (e.QueryLexer.prototype.emit = function (e) {
      (this.lexemes.push({
        type: e,
        str: this.sliceString(),
        start: this.start,
        end: this.pos,
      }),
        (this.start = this.pos));
    }),
    (e.QueryLexer.prototype.escapeCharacter = function () {
      (this.escapeCharPositions.push(this.pos - 1), (this.pos += 1));
    }),
    (e.QueryLexer.prototype.next = function () {
      if (this.pos >= this.length) return e.QueryLexer.EOS;
      var t = this.str.charAt(this.pos);
      return ((this.pos += 1), t);
    }),
    (e.QueryLexer.prototype.width = function () {
      return this.pos - this.start;
    }),
    (e.QueryLexer.prototype.ignore = function () {
      (this.start == this.pos && (this.pos += 1), (this.start = this.pos));
    }),
    (e.QueryLexer.prototype.backup = function () {
      this.pos -= 1;
    }),
    (e.QueryLexer.prototype.acceptDigitRun = function () {
      var t, r;
      do ((t = this.next()), (r = t.charCodeAt(0)));
      while (r > 47 && r < 58);
      t != e.QueryLexer.EOS && this.backup();
    }),
    (e.QueryLexer.prototype.more = function () {
      return this.pos < this.length;
    }),
    (e.QueryLexer.EOS = "EOS"),
    (e.QueryLexer.FIELD = "FIELD"),
    (e.QueryLexer.TERM = "TERM"),
    (e.QueryLexer.EDIT_DISTANCE = "EDIT_DISTANCE"),
    (e.QueryLexer.BOOST = "BOOST"),
    (e.QueryLexer.PRESENCE = "PRESENCE"),
    (e.QueryLexer.lexField = function (t) {
      return (
        t.backup(),
        t.emit(e.QueryLexer.FIELD),
        t.ignore(),
        e.QueryLexer.lexText
      );
    }),
    (e.QueryLexer.lexTerm = function (t) {
      if (
        (t.width() > 1 && (t.backup(), t.emit(e.QueryLexer.TERM)),
        t.ignore(),
        t.more())
      )
        return e.QueryLexer.lexText;
    }),
    (e.QueryLexer.lexEditDistance = function (t) {
      return (
        t.ignore(),
        t.acceptDigitRun(),
        t.emit(e.QueryLexer.EDIT_DISTANCE),
        e.QueryLexer.lexText
      );
    }),
    (e.QueryLexer.lexBoost = function (t) {
      return (
        t.ignore(),
        t.acceptDigitRun(),
        t.emit(e.QueryLexer.BOOST),
        e.QueryLexer.lexText
      );
    }),
    (e.QueryLexer.lexEOS = function (t) {
      t.width() > 0 && t.emit(e.QueryLexer.TERM);
    }),
    (e.QueryLexer.termSeparator = e.tokenizer.separator),
    (e.QueryLexer.lexText = function (t) {
      for (;;) {
        var r = t.next();
        if (r == e.QueryLexer.EOS) return e.QueryLexer.lexEOS;
        if (92 != r.charCodeAt(0)) {
          if (":" == r) return e.QueryLexer.lexField;
          if ("~" == r)
            return (
              t.backup(),
              t.width() > 0 && t.emit(e.QueryLexer.TERM),
              e.QueryLexer.lexEditDistance
            );
          if ("^" == r)
            return (
              t.backup(),
              t.width() > 0 && t.emit(e.QueryLexer.TERM),
              e.QueryLexer.lexBoost
            );
          if ("+" == r && 1 === t.width())
            return (t.emit(e.QueryLexer.PRESENCE), e.QueryLexer.lexText);
          if ("-" == r && 1 === t.width())
            return (t.emit(e.QueryLexer.PRESENCE), e.QueryLexer.lexText);
          if (r.match(e.QueryLexer.termSeparator)) return e.QueryLexer.lexTerm;
        } else t.escapeCharacter();
      }
    }),
    (e.QueryParser = function (t, r) {
      ((this.lexer = new e.QueryLexer(t)),
        (this.query = r),
        (this.currentClause = {}),
        (this.lexemeIdx = 0));
    }),
    (e.QueryParser.prototype.parse = function () {
      (this.lexer.run(), (this.lexemes = this.lexer.lexemes));
      for (var t = e.QueryParser.parseClause; t; ) t = t(this);
      return this.query;
    }),
    (e.QueryParser.prototype.peekLexeme = function () {
      return this.lexemes[this.lexemeIdx];
    }),
    (e.QueryParser.prototype.consumeLexeme = function () {
      var e = this.peekLexeme();
      return ((this.lexemeIdx += 1), e);
    }),
    (e.QueryParser.prototype.nextClause = function () {
      var e = this.currentClause;
      (this.query.clause(e), (this.currentClause = {}));
    }),
    (e.QueryParser.parseClause = function (t) {
      var r = t.peekLexeme();
      if (void 0 != r)
        switch (r.type) {
          case e.QueryLexer.PRESENCE:
            return e.QueryParser.parsePresence;
          case e.QueryLexer.FIELD:
            return e.QueryParser.parseField;
          case e.QueryLexer.TERM:
            return e.QueryParser.parseTerm;
          default:
            var i = "expected either a field or a term, found " + r.type;
            throw (
              r.str.length >= 1 && (i += " with value '" + r.str + "'"),
              new e.QueryParseError(i, r.start, r.end)
            );
        }
    }),
    (e.QueryParser.parsePresence = function (t) {
      var r = t.consumeLexeme();
      if (void 0 != r) {
        switch (r.str) {
          case "-":
            t.currentClause.presence = e.Query.presence.PROHIBITED;
            break;
          case "+":
            t.currentClause.presence = e.Query.presence.REQUIRED;
            break;
          default:
            var i = "unrecognised presence operator'" + r.str + "'";
            throw new e.QueryParseError(i, r.start, r.end);
        }
        var n = t.peekLexeme();
        if (void 0 == n) {
          var i = "expecting term or field, found nothing";
          throw new e.QueryParseError(i, r.start, r.end);
        }
        switch (n.type) {
          case e.QueryLexer.FIELD:
            return e.QueryParser.parseField;
          case e.QueryLexer.TERM:
            return e.QueryParser.parseTerm;
          default:
            var i = "expecting term or field, found '" + n.type + "'";
            throw new e.QueryParseError(i, n.start, n.end);
        }
      }
    }),
    (e.QueryParser.parseField = function (t) {
      var r = t.consumeLexeme();
      if (void 0 != r) {
        if (t.query.allFields.indexOf(r.str) == -1) {
          var i = t.query.allFields
              .map(function (e) {
                return "'" + e + "'";
              })
              .join(", "),
            n = "unrecognised field '" + r.str + "', possible fields: " + i;
          throw new e.QueryParseError(n, r.start, r.end);
        }
        t.currentClause.fields = [r.str];
        var s = t.peekLexeme();
        if (void 0 == s) {
          var n = "expecting term, found nothing";
          throw new e.QueryParseError(n, r.start, r.end);
        }
        switch (s.type) {
          case e.QueryLexer.TERM:
            return e.QueryParser.parseTerm;
          default:
            var n = "expecting term, found '" + s.type + "'";
            throw new e.QueryParseError(n, s.start, s.end);
        }
      }
    }),
    (e.QueryParser.parseTerm = function (t) {
      var r = t.consumeLexeme();
      if (void 0 != r) {
        ((t.currentClause.term = r.str.toLowerCase()),
          r.str.indexOf("*") != -1 && (t.currentClause.usePipeline = !1));
        var i = t.peekLexeme();
        if (void 0 == i) return void t.nextClause();
        switch (i.type) {
          case e.QueryLexer.TERM:
            return (t.nextClause(), e.QueryParser.parseTerm);
          case e.QueryLexer.FIELD:
            return (t.nextClause(), e.QueryParser.parseField);
          case e.QueryLexer.EDIT_DISTANCE:
            return e.QueryParser.parseEditDistance;
          case e.QueryLexer.BOOST:
            return e.QueryParser.parseBoost;
          case e.QueryLexer.PRESENCE:
            return (t.nextClause(), e.QueryParser.parsePresence);
          default:
            var n = "Unexpected lexeme type '" + i.type + "'";
            throw new e.QueryParseError(n, i.start, i.end);
        }
      }
    }),
    (e.QueryParser.parseEditDistance = function (t) {
      var r = t.consumeLexeme();
      if (void 0 != r) {
        var i = parseInt(r.str, 10);
        if (isNaN(i)) {
          var n = "edit distance must be numeric";
          throw new e.QueryParseError(n, r.start, r.end);
        }
        t.currentClause.editDistance = i;
        var s = t.peekLexeme();
        if (void 0 == s) return void t.nextClause();
        switch (s.type) {
          case e.QueryLexer.TERM:
            return (t.nextClause(), e.QueryParser.parseTerm);
          case e.QueryLexer.FIELD:
            return (t.nextClause(), e.QueryParser.parseField);
          case e.QueryLexer.EDIT_DISTANCE:
            return e.QueryParser.parseEditDistance;
          case e.QueryLexer.BOOST:
            return e.QueryParser.parseBoost;
          case e.QueryLexer.PRESENCE:
            return (t.nextClause(), e.QueryParser.parsePresence);
          default:
            var n = "Unexpected lexeme type '" + s.type + "'";
            throw new e.QueryParseError(n, s.start, s.end);
        }
      }
    }),
    (e.QueryParser.parseBoost = function (t) {
      var r = t.consumeLexeme();
      if (void 0 != r) {
        var i = parseInt(r.str, 10);
        if (isNaN(i)) {
          var n = "boost must be numeric";
          throw new e.QueryParseError(n, r.start, r.end);
        }
        t.currentClause.boost = i;
        var s = t.peekLexeme();
        if (void 0 == s) return void t.nextClause();
        switch (s.type) {
          case e.QueryLexer.TERM:
            return (t.nextClause(), e.QueryParser.parseTerm);
          case e.QueryLexer.FIELD:
            return (t.nextClause(), e.QueryParser.parseField);
          case e.QueryLexer.EDIT_DISTANCE:
            return e.QueryParser.parseEditDistance;
          case e.QueryLexer.BOOST:
            return e.QueryParser.parseBoost;
          case e.QueryLexer.PRESENCE:
            return (t.nextClause(), e.QueryParser.parsePresence);
          default:
            var n = "Unexpected lexeme type '" + s.type + "'";
            throw new e.QueryParseError(n, s.start, s.end);
        }
      }
    }),
    (function (e, t) {
      "function" == typeof define && define.amd
        ? define(t)
        : "object" == typeof exports
          ? (module.exports = t())
          : (e.lunr = t());
    })(this, function () {
      return e;
    }));
})();