This is an automated email from the ASF dual-hosted git repository.
ctubbsii pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/accumulo-website.git
The following commit(s) were added to refs/heads/main by this push:
new 01e65fb15 Adds the lunr script to the local resources (#451)
01e65fb15 is described below
commit 01e65fb15a32080d8bb3dd7647687652c3685ed3
Author: Daniel Roberts <[email protected]>
AuthorDate: Tue Mar 4 13:03:32 2025 -0500
Adds the lunr script to the local resources (#451)
ASF started blocking external resources as of March 1st.
This policy breaks the ability to pull the lunr script from the
external hosting location.
---
js/lunr/2.3.9/lunr.min.js | 1429 +++++++++++++++++++++++++++++++++++++++++++++
pages/search.md | 2 +-
2 files changed, 1430 insertions(+), 1 deletion(-)
diff --git a/js/lunr/2.3.9/lunr.min.js b/js/lunr/2.3.9/lunr.min.js
new file mode 100644
index 000000000..dabbb894c
--- /dev/null
+++ b/js/lunr/2.3.9/lunr.min.js
@@ -0,0 +1,1429 @@
+/**
+ * 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 + .5) / (r + .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" [...]
+ 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 = .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
+ })
+}();
diff --git a/pages/search.md b/pages/search.md
index 41bd95154..2357dabe6 100644
--- a/pages/search.md
+++ b/pages/search.md
@@ -22,5 +22,5 @@ Search results are limited to blog posts, release notes, and
the 2.x documentati
<table class="table table-striped"><tbody id="search_results"></tbody></table>
-<script src="https://unpkg.com/[email protected]/lunr.min.js";></script>
+<script src="/js/lunr/2.3.9/lunr.min.js"></script>
<script src="/js/search.js"></script>
