diff options
Diffstat (limited to 'static/js/searchElasticlunr.js')
| -rw-r--r-- | static/js/searchElasticlunr.js | 3201 |
1 files changed, 3201 insertions, 0 deletions
diff --git a/static/js/searchElasticlunr.js b/static/js/searchElasticlunr.js new file mode 100644 index 0000000..9ad09e1 --- /dev/null +++ b/static/js/searchElasticlunr.js @@ -0,0 +1,3201 @@ +/** + * elasticlunr - http://weixsong.github.io + * Lightweight full-text search engine in Javascript for browser search and offline search. - 0.9.5 + * + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + * MIT Licensed + * @license + */ +(function () { + /*! + * elasticlunr.js + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * Convenience function for instantiating a new elasticlunr index and configuring it + * with the default pipeline functions and the passed config function. + * + * When using this convenience function a new index will be created with the + * following functions already in the pipeline: + * + * 1. elasticlunr.trimmer - trim non-word character + * 2. elasticlunr.StopWordFilter - filters out any stop words before they enter the + * index + * 3. elasticlunr.stemmer - stems the tokens before entering the index. + * + * + * Example: + * + * var idx = elasticlunr(function () { + * this.addField('id'); + * this.addField('title'); + * this.addField('body'); + * + * //this.setRef('id'); // default ref is 'id' + * + * this.pipeline.add(function () { + * // some custom pipeline function + * }); + * }); + * + * idx.addDoc({ + * id: 1, + * title: 'Oracle released database 12g', + * body: 'Yestaday, Oracle has released their latest database, named 12g, more robust. this product will increase Oracle profit.' + * }); + * + * idx.addDoc({ + * id: 2, + * title: 'Oracle released annual profit report', + * body: 'Yestaday, Oracle has released their annual profit report of 2015, total profit is 12.5 Billion.' + * }); + * + * # simple search + * idx.search('oracle database'); + * + * # search with query-time boosting + * idx.search('oracle database', {fields: {title: {boost: 2}, body: {boost: 1}}}); + * + * @param {Function} config A function that will be called with the new instance + * of the elasticlunr.Index as both its context and first parameter. It can be used to + * customize the instance of new elasticlunr.Index. + * @namespace + * @module + * @return {elasticlunr.Index} + * + */ + const elasticlunr = function (config) { + const idx = new elasticlunr.Index(); + + idx.pipeline.add( + elasticlunr.trimmer, + elasticlunr.stopWordFilter, + elasticlunr.stemmer + ); + + if (config) config.call(idx, idx); + + return idx; + }; + + elasticlunr.version = '0.9.5'; + + // only used this to make elasticlunr.js compatible with lunr-languages + // this is a trick to define a global alias of elasticlunr + lunr = elasticlunr; + + /*! + * elasticlunr.utils + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * A namespace containing utils for the rest of the elasticlunr library + */ + elasticlunr.utils = {}; + + /** + * Print a warning message to the console. + * + * @param {String} message The message to be printed. + * @memberOf Utils + */ + elasticlunr.utils.warn = (function (global) { + return function (message) { + if (global.console && console.warn) { + console.warn(message); + } + }; + })(this); + + /** + * Convert an object to string. + * + * In the case of `null` and `undefined` the function returns + * an empty string, in all other cases the result of calling + * `toString` on the passed object is returned. + * + * @param {object} obj The object to convert to a string. + * @return {String} string representation of the passed object. + * @memberOf Utils + */ + elasticlunr.utils.toString = function (obj) { + if (obj === void 0 || obj === null) { + return ''; + } + + return obj.toString(); + }; + /*! + * elasticlunr.EventEmitter + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.EventEmitter is an event emitter for elasticlunr. + * It manages adding and removing event handlers and triggering events and their handlers. + * + * Each event could has multiple corresponding functions, + * these functions will be called as the sequence that they are added into the event. + * + * @constructor + */ + elasticlunr.EventEmitter = function () { + this.events = {}; + }; + + /** + * Binds a handler function to a specific event(s). + * + * Can bind a single function to many different events in one call. + * + * @param {String} [eventName] The name(s) of events to bind this function to. + * @param {Function} fn The function to call when an event is fired. + * @memberOf EventEmitter + */ + elasticlunr.EventEmitter.prototype.addListener = function () { + const args = Array.prototype.slice.call(arguments); + const fn = args.pop(); + const names = args; + + if (typeof fn !== 'function') + throw new TypeError('last argument must be a function'); + + names.forEach(function (name) { + if (!this.hasHandler(name)) this.events[name] = []; + this.events[name].push(fn); + }, this); + }; + + /** + * Removes a handler function from a specific event. + * + * @param {String} eventName The name of the event to remove this function from. + * @param {Function} fn The function to remove from an event. + * @memberOf EventEmitter + */ + elasticlunr.EventEmitter.prototype.removeListener = function (name, fn) { + if (!this.hasHandler(name)) return; + + const fnIndex = this.events[name].indexOf(fn); + if (fnIndex === -1) return; + + this.events[name].splice(fnIndex, 1); + + if (this.events[name].length === 0) delete this.events[name]; + }; + + /** + * Call all functions that bounded to the given event. + * + * Additional data can be passed to the event handler as arguments to `emit` + * after the event name. + * + * @param {String} eventName The name of the event to emit. + * @memberOf EventEmitter + */ + elasticlunr.EventEmitter.prototype.emit = function (name) { + if (!this.hasHandler(name)) return; + + const args = Array.prototype.slice.call(arguments, 1); + + this.events[name].forEach(function (fn) { + fn.apply(undefined, args); + }, this); + }; + + /** + * Checks whether a handler has ever been stored against an event. + * + * @param {String} eventName The name of the event to check. + * @private + * @memberOf EventEmitter + */ + elasticlunr.EventEmitter.prototype.hasHandler = function (name) { + return name in this.events; + }; + /*! + * elasticlunr.tokenizer + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * A function for splitting a string into tokens. + * Currently English is supported as default. + * Uses `elasticlunr.tokenizer.seperator` to split strings, you could change + * the value of this property to set how you want strings are split into tokens. + * IMPORTANT: use elasticlunr.tokenizer.seperator carefully, if you are not familiar with + * text process, then you'd better not change it. + * + * @module + * @param {String} str The string that you want to tokenize. + * @see elasticlunr.tokenizer.seperator + * @return {Array} + */ + elasticlunr.tokenizer = function (str) { + if (!arguments.length || str === null || str === undefined) return []; + if (Array.isArray(str)) { + let arr = str.filter(function (token) { + if (token === null || token === undefined) { + return false; + } + + return true; + }); + + arr = arr.map(function (t) { + return elasticlunr.utils.toString(t).toLowerCase(); + }); + + let out = []; + arr.forEach(function (item) { + const tokens = item.split(elasticlunr.tokenizer.seperator); + out = out.concat(tokens); + }, this); + + return out; + } + + return str + .toString() + .trim() + .toLowerCase() + .split(elasticlunr.tokenizer.seperator); + }; + + /** + * Default string seperator. + */ + elasticlunr.tokenizer.defaultSeperator = /[\s-]+/; + + /** + * The sperator used to split a string into tokens. Override this property to change the behaviour of + * `elasticlunr.tokenizer` behaviour when tokenizing strings. By default this splits on whitespace and hyphens. + * + * @static + * @see elasticlunr.tokenizer + */ + elasticlunr.tokenizer.seperator = elasticlunr.tokenizer.defaultSeperator; + + /** + * Set up customized string seperator + * + * @param {Object} sep The customized seperator that you want to use to tokenize a string. + */ + elasticlunr.tokenizer.setSeperator = function (sep) { + if (sep !== null && sep !== undefined && typeof sep === 'object') { + elasticlunr.tokenizer.seperator = sep; + } + }; + + /** + * Reset string seperator + * + */ + elasticlunr.tokenizer.resetSeperator = function () { + elasticlunr.tokenizer.seperator = elasticlunr.tokenizer.defaultSeperator; + }; + + /** + * Get string seperator + * + */ + elasticlunr.tokenizer.getSeperator = function () { + return elasticlunr.tokenizer.seperator; + }; + /*! + * elasticlunr.Pipeline + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.Pipelines maintain an ordered list of functions to be applied to + * both documents tokens and query tokens. + * + * An instance of elasticlunr.Index will contain a pipeline + * with a trimmer, a stop word filter, an English stemmer. Extra + * functions can be added before or after either of these functions or these + * default functions can be removed. + * + * When run the pipeline, it will call each function in turn. + * + * The output of the functions in the pipeline will be passed to the next function + * in the pipeline. To exclude a token from entering the index the function + * should return undefined, the rest of the pipeline will not be called with + * this token. + * + * For serialisation of pipelines to work, all functions used in an instance of + * a pipeline should be registered with elasticlunr.Pipeline. Registered functions can + * then be loaded. If trying to load a serialised pipeline that uses functions + * that are not registered an error will be thrown. + * + * If not planning on serialising the pipeline then registering pipeline functions + * is not necessary. + * + * @constructor + */ + elasticlunr.Pipeline = function () { + this._queue = []; + }; + + elasticlunr.Pipeline.registeredFunctions = {}; + + /** + * Register a function in the pipeline. + * + * Functions that are used in the pipeline should be registered if the pipeline + * needs to be serialised, or a serialised pipeline needs to be loaded. + * + * Registering a function does not add it to a pipeline, functions must still be + * added to instances of the pipeline for them to be used when running a pipeline. + * + * @param {Function} fn The function to register. + * @param {String} label The label to register this function with + * @memberOf Pipeline + */ + elasticlunr.Pipeline.registerFunction = function (fn, label) { + if (label in elasticlunr.Pipeline.registeredFunctions) { + elasticlunr.utils.warn( + 'Overwriting existing registered function: ' + label + ); + } + + fn.label = label; + elasticlunr.Pipeline.registeredFunctions[label] = fn; + }; + + /** + * Get a registered function in the pipeline. + * + * @param {String} label The label of registered function. + * @return {Function} + * @memberOf Pipeline + */ + elasticlunr.Pipeline.getRegisteredFunction = function (label) { + if (label in elasticlunr.Pipeline.registeredFunctions !== true) { + return null; + } + + return elasticlunr.Pipeline.registeredFunctions[label]; + }; + + /** + * Warns if the function is not registered as a Pipeline function. + * + * @param {Function} fn The function to check for. + * @private + * @memberOf Pipeline + */ + elasticlunr.Pipeline.warnIfFunctionNotRegistered = function (fn) { + const isRegistered = fn.label && fn.label in this.registeredFunctions; + + if (!isRegistered) { + elasticlunr.utils.warn( + 'Function is not registered with pipeline. This may cause problems when serialising the index.\n', + fn + ); + } + }; + + /** + * Loads a previously serialised pipeline. + * + * All functions to be loaded must already be registered with elasticlunr.Pipeline. + * If any function from the serialised data has not been registered then an + * error will be thrown. + * + * @param {Object} serialised The serialised pipeline to load. + * @return {elasticlunr.Pipeline} + * @memberOf Pipeline + */ + elasticlunr.Pipeline.load = function (serialised) { + const pipeline = new elasticlunr.Pipeline(); + + serialised.forEach(function (fnName) { + const fn = elasticlunr.Pipeline.getRegisteredFunction(fnName); + + if (fn) { + pipeline.add(fn); + } else { + throw new Error('Cannot load un-registered function: ' + fnName); + } + }); + + return pipeline; + }; + + /** + * Adds new functions to the end of the pipeline. + * + * Logs a warning if the function has not been registered. + * + * @param {Function} functions Any number of functions to add to the pipeline. + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.add = function () { + const fns = Array.prototype.slice.call(arguments); + + fns.forEach(function (fn) { + elasticlunr.Pipeline.warnIfFunctionNotRegistered(fn); + this._queue.push(fn); + }, this); + }; + + /** + * Adds a single function after a function that already exists in the + * pipeline. + * + * Logs a warning if the function has not been registered. + * If existingFn is not found, throw an Exception. + * + * @param {Function} existingFn A function that already exists in the pipeline. + * @param {Function} newFn The new function to add to the pipeline. + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.after = function (existingFn, newFn) { + elasticlunr.Pipeline.warnIfFunctionNotRegistered(newFn); + + const pos = this._queue.indexOf(existingFn); + if (pos === -1) { + throw new Error('Cannot find existingFn'); + } + + this._queue.splice(pos + 1, 0, newFn); + }; + + /** + * Adds a single function before a function that already exists in the + * pipeline. + * + * Logs a warning if the function has not been registered. + * If existingFn is not found, throw an Exception. + * + * @param {Function} existingFn A function that already exists in the pipeline. + * @param {Function} newFn The new function to add to the pipeline. + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.before = function (existingFn, newFn) { + elasticlunr.Pipeline.warnIfFunctionNotRegistered(newFn); + + const pos = this._queue.indexOf(existingFn); + if (pos === -1) { + throw new Error('Cannot find existingFn'); + } + + this._queue.splice(pos, 0, newFn); + }; + + /** + * Removes a function from the pipeline. + * + * @param {Function} fn The function to remove from the pipeline. + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.remove = function (fn) { + const pos = this._queue.indexOf(fn); + if (pos === -1) { + return; + } + + this._queue.splice(pos, 1); + }; + + /** + * Runs the current list of functions that registered in the pipeline against the + * input tokens. + * + * @param {Array} tokens The tokens to run through the pipeline. + * @return {Array} + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.run = function (tokens) { + const out = []; + const tokenLength = tokens.length; + const pipelineLength = this._queue.length; + + for (let i = 0; i < tokenLength; i++) { + let token = tokens[i]; + + for (let j = 0; j < pipelineLength; j++) { + token = this._queue[j](token, i, tokens); + if (token === void 0 || token === null) break; + } + + if (token !== void 0 && token !== null) out.push(token); + } + + return out; + }; + + /** + * Resets the pipeline by removing any existing processors. + * + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.reset = function () { + this._queue = []; + }; + + /** + * Get the pipeline if user want to check the pipeline. + * + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.get = function () { + return this._queue; + }; + + /** + * Returns a representation of the pipeline ready for serialisation. + * Only serialize pipeline function's name. Not storing function, so when + * loading the archived JSON index file, corresponding pipeline function is + * added by registered function of elasticlunr.Pipeline.registeredFunctions + * + * Logs a warning if the function has not been registered. + * + * @return {Array} + * @memberOf Pipeline + */ + elasticlunr.Pipeline.prototype.toJSON = function () { + return this._queue.map(function (fn) { + elasticlunr.Pipeline.warnIfFunctionNotRegistered(fn); + return fn.label; + }); + }; + /*! + * elasticlunr.Index + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.Index is object that manages a search index. It contains the indexes + * and stores all the tokens and document lookups. It also provides the main + * user facing API for the library. + * + * @constructor + */ + elasticlunr.Index = function () { + this._fields = []; + this._ref = 'id'; + this.pipeline = new elasticlunr.Pipeline(); + this.documentStore = new elasticlunr.DocumentStore(); + this.index = {}; + this.eventEmitter = new elasticlunr.EventEmitter(); + this._idfCache = {}; + + this.on( + 'add', + 'remove', + 'update', + function () { + this._idfCache = {}; + }.bind(this) + ); + }; + + /** + * Bind a handler to events being emitted by the index. + * + * The handler can be bound to many events at the same time. + * + * @param {String} [eventName] The name(s) of events to bind the function to. + * @param {Function} fn The serialised set to load. + * @memberOf Index + */ + elasticlunr.Index.prototype.on = function () { + const args = Array.prototype.slice.call(arguments); + return this.eventEmitter.addListener.apply(this.eventEmitter, args); + }; + + /** + * Removes a handler from an event being emitted by the index. + * + * @param {String} eventName The name of events to remove the function from. + * @param {Function} fn The serialised set to load. + * @memberOf Index + */ + elasticlunr.Index.prototype.off = function (name, fn) { + return this.eventEmitter.removeListener(name, fn); + }; + + /** + * Loads a previously serialised index. + * + * Issues a warning if the index being imported was serialised + * by a different version of elasticlunr. + * + * @param {Object} serialisedData The serialised set to load. + * @return {elasticlunr.Index} + * @memberOf Index + */ + elasticlunr.Index.load = function (serialisedData) { + if (serialisedData.version !== elasticlunr.version) { + elasticlunr.utils.warn( + 'version mismatch: current ' + + elasticlunr.version + + ' importing ' + + serialisedData.version + ); + } + + const idx = new this(); + + idx._fields = serialisedData.fields; + idx._ref = serialisedData.ref; + idx.documentStore = elasticlunr.DocumentStore.load( + serialisedData.documentStore + ); + idx.pipeline = elasticlunr.Pipeline.load(serialisedData.pipeline); + idx.index = {}; + for (const field in serialisedData.index) { + idx.index[field] = elasticlunr.InvertedIndex.load( + serialisedData.index[field] + ); + } + + return idx; + }; + + /** + * Adds a field to the list of fields that will be searchable within documents in the index. + * + * Remember that inner index is build based on field, which means each field has one inverted index. + * + * Fields should be added before any documents are added to the index, fields + * that are added after documents are added to the index will only apply to new + * documents added to the index. + * + * @param {String} fieldName The name of the field within the document that should be indexed + * @return {elasticlunr.Index} + * @memberOf Index + */ + elasticlunr.Index.prototype.addField = function (fieldName) { + this._fields.push(fieldName); + this.index[fieldName] = new elasticlunr.InvertedIndex(); + return this; + }; + + /** + * Sets the property used to uniquely identify documents added to the index, + * by default this property is 'id'. + * + * This should only be changed before adding documents to the index, changing + * the ref property without resetting the index can lead to unexpected results. + * + * @param {String} refName The property to use to uniquely identify the + * documents in the index. + * @param {Boolean} emitEvent Whether to emit add events, defaults to true + * @return {elasticlunr.Index} + * @memberOf Index + */ + elasticlunr.Index.prototype.setRef = function (refName) { + this._ref = refName; + return this; + }; + + /** + * + * Set if the JSON format original documents are save into elasticlunr.DocumentStore + * + * Defaultly save all the original JSON documents. + * + * @param {Boolean} save Whether to save the original JSON documents. + * @return {elasticlunr.Index} + * @memberOf Index + */ + elasticlunr.Index.prototype.saveDocument = function (save) { + this.documentStore = new elasticlunr.DocumentStore(save); + return this; + }; + + /** + * Add a JSON format document to the index. + * + * This is the way new documents enter the index, this function will run the + * fields from the document through the index's pipeline and then add it to + * the index, it will then show up in search results. + * + * An 'add' event is emitted with the document that has been added and the index + * the document has been added to. This event can be silenced by passing false + * as the second argument to add. + * + * @param {Object} doc The JSON format document to add to the index. + * @param {Boolean} emitEvent Whether or not to emit events, default true. + * @memberOf Index + */ + elasticlunr.Index.prototype.addDoc = function (doc, emitEvent) { + if (!doc) return; + var emitEvent = emitEvent === undefined ? true : emitEvent; + + const docRef = doc[this._ref]; + + this.documentStore.addDoc(docRef, doc); + this._fields.forEach(function (field) { + const fieldTokens = this.pipeline.run(elasticlunr.tokenizer(doc[field])); + this.documentStore.addFieldLength(docRef, field, fieldTokens.length); + + const tokenCount = {}; + fieldTokens.forEach(function (token) { + if (token in tokenCount) tokenCount[token] += 1; + else tokenCount[token] = 1; + }, this); + + for (const token in tokenCount) { + let termFrequency = tokenCount[token]; + termFrequency = Math.sqrt(termFrequency); + this.index[field].addToken(token, { ref: docRef, tf: termFrequency }); + } + }, this); + + if (emitEvent) this.eventEmitter.emit('add', doc, this); + }; + + /** + * Removes a document from the index by doc ref. + * + * To make sure documents no longer show up in search results they can be + * removed from the index using this method. + * + * A 'remove' event is emitted with the document that has been removed and the index + * the document has been removed from. This event can be silenced by passing false + * as the second argument to remove. + * + * If user setting DocumentStore not storing the documents, then remove doc by docRef is not allowed. + * + * @param {String|Integer} docRef The document ref to remove from the index. + * @param {Boolean} emitEvent Whether to emit remove events, defaults to true + * @memberOf Index + */ + elasticlunr.Index.prototype.removeDocByRef = function (docRef, emitEvent) { + if (!docRef) return; + if (this.documentStore.isDocStored() === false) { + return; + } + + if (!this.documentStore.hasDoc(docRef)) return; + const doc = this.documentStore.getDoc(docRef); + this.removeDoc(doc, false); + }; + + /** + * Removes a document from the index. + * This remove operation could work even the original doc is not store in the DocumentStore. + * + * To make sure documents no longer show up in search results they can be + * removed from the index using this method. + * + * A 'remove' event is emitted with the document that has been removed and the index + * the document has been removed from. This event can be silenced by passing false + * as the second argument to remove. + * + * + * @param {Object} doc The document ref to remove from the index. + * @param {Boolean} emitEvent Whether to emit remove events, defaults to true + * @memberOf Index + */ + elasticlunr.Index.prototype.removeDoc = function (doc, emitEvent) { + if (!doc) return; + + var emitEvent = emitEvent === undefined ? true : emitEvent; + + const docRef = doc[this._ref]; + if (!this.documentStore.hasDoc(docRef)) return; + + this.documentStore.removeDoc(docRef); + + this._fields.forEach(function (field) { + const fieldTokens = this.pipeline.run(elasticlunr.tokenizer(doc[field])); + fieldTokens.forEach(function (token) { + this.index[field].removeToken(token, docRef); + }, this); + }, this); + + if (emitEvent) this.eventEmitter.emit('remove', doc, this); + }; + + /** + * Updates a document in the index. + * + * When a document contained within the index gets updated, fields changed, + * added or removed, to make sure it correctly matched against search queries, + * it should be updated in the index. + * + * This method is just a wrapper around `remove` and `add` + * + * An 'update' event is emitted with the document that has been updated and the index. + * This event can be silenced by passing false as the second argument to update. Only + * an update event will be fired, the 'add' and 'remove' events of the underlying calls + * are silenced. + * + * @param {Object} doc The document to update in the index. + * @param {Boolean} emitEvent Whether to emit update events, defaults to true + * @see Index.prototype.remove + * @see Index.prototype.add + * @memberOf Index + */ + elasticlunr.Index.prototype.updateDoc = function (doc, emitEvent) { + var emitEvent = emitEvent === undefined ? true : emitEvent; + + this.removeDocByRef(doc[this._ref], false); + this.addDoc(doc, false); + + if (emitEvent) this.eventEmitter.emit('update', doc, this); + }; + + /** + * Calculates the inverse document frequency for a token within the index of a field. + * + * @param {String} token The token to calculate the idf of. + * @param {String} field The field to compute idf. + * @see Index.prototype.idf + * @private + * @memberOf Index + */ + elasticlunr.Index.prototype.idf = function (term, field) { + const cacheKey = '@' + field + '/' + term; + if (Object.prototype.hasOwnProperty.call(this._idfCache, cacheKey)) + return this._idfCache[cacheKey]; + + const df = this.index[field].getDocFreq(term); + const idf = 1 + Math.log(this.documentStore.length / (df + 1)); + this._idfCache[cacheKey] = idf; + + return idf; + }; + + /** + * get fields of current index instance + * + * @return {Array} + */ + elasticlunr.Index.prototype.getFields = function () { + return this._fields.slice(); + }; + + /** + * Searches the index using the passed query. + * Queries should be a string, multiple words are allowed. + * + * If config is null, will search all fields defaultly, and lead to OR based query. + * If config is specified, will search specified with query time boosting. + * + * All query tokens are passed through the same pipeline that document tokens + * are passed through, so any language processing involved will be run on every + * query term. + * + * Each query term is expanded, so that the term 'he' might be expanded to + * 'hello' and 'help' if those terms were already included in the index. + * + * Matching documents are returned as an array of objects, each object contains + * the matching document ref, as set for this index, and the similarity score + * for this document against the query. + * + * @param {String} query The query to search the index with. + * @param {JSON} userConfig The user query config, JSON format. + * @return {Object} + * @see Index.prototype.idf + * @see Index.prototype.documentVector + * @memberOf Index + */ + elasticlunr.Index.prototype.search = function (query, userConfig) { + if (!query) return []; + if (typeof query === 'string') { + query = { any: query }; + } else { + query = JSON.parse(JSON.stringify(query)); + } + + let configStr = null; + if (userConfig != null) { + configStr = JSON.stringify(userConfig); + } + + const config = new elasticlunr.Configuration(configStr, this.getFields()).get(); + + const queryTokens = {}; + const queryFields = Object.keys(query); + + for (let i = 0; i < queryFields.length; i++) { + const key = queryFields[i]; + + queryTokens[key] = this.pipeline.run(elasticlunr.tokenizer(query[key])); + } + + const queryResults = {}; + + for (const field in config) { + const tokens = queryTokens[field] || queryTokens.any; + if (!tokens) { + continue; + } + + const fieldSearchResults = this.fieldSearch(tokens, field, config); + const fieldBoost = config[field].boost; + + for (var docRef in fieldSearchResults) { + fieldSearchResults[docRef] = fieldSearchResults[docRef] * fieldBoost; + } + + for (var docRef in fieldSearchResults) { + if (docRef in queryResults) { + queryResults[docRef] += fieldSearchResults[docRef]; + } else { + queryResults[docRef] = fieldSearchResults[docRef]; + } + } + } + + const results = []; + let result; + for (var docRef in queryResults) { + result = { ref: docRef, score: queryResults[docRef] }; + if (this.documentStore.hasDoc(docRef)) { + result.doc = this.documentStore.getDoc(docRef); + } + results.push(result); + } + + results.sort(function (a, b) { + return b.score - a.score; + }); + return results; + }; + + /** + * search queryTokens in specified field. + * + * @param {Array} queryTokens The query tokens to query in this field. + * @param {String} field Field to query in. + * @param {elasticlunr.Configuration} config The user query config, JSON format. + * @return {Object} + */ + elasticlunr.Index.prototype.fieldSearch = function ( + queryTokens, + fieldName, + config + ) { + const booleanType = config[fieldName].bool; + const expand = config[fieldName].expand; + const boost = config[fieldName].boost; + let scores = null; + const docTokens = {}; + + // Do nothing if the boost is 0 + if (boost === 0) { + return; + } + + queryTokens.forEach(function (token) { + let tokens = [token]; + if (expand === true) { + tokens = this.index[fieldName].expandToken(token); + } + // Consider every query token in turn. If expanded, each query token + // corresponds to a set of tokens, which is all tokens in the + // index matching the pattern queryToken* . + // For the set of tokens corresponding to a query token, find and score + // all matching documents. Store those scores in queryTokenScores, + // keyed by docRef. + // Then, depending on the value of booleanType, combine the scores + // for this query token with previous scores. If booleanType is OR, + // then merge the scores by summing into the accumulated total, adding + // new document scores are required (effectively a union operator). + // If booleanType is AND, accumulate scores only if the document + // has previously been scored by another query token (an intersection + // operation0. + // Furthermore, since when booleanType is AND, additional + // query tokens can't add new documents to the result set, use the + // current document set to limit the processing of each new query + // token for efficiency (i.e., incremental intersection). + + const queryTokenScores = {}; + tokens.forEach(function (key) { + let docs = this.index[fieldName].getDocs(key); + const idf = this.idf(key, fieldName); + + if (scores && booleanType === 'AND') { + // special case, we can rule out documents that have been + // already been filtered out because they weren't scored + // by previous query token passes. + const filteredDocs = {}; + for (var docRef in scores) { + if (docRef in docs) { + filteredDocs[docRef] = docs[docRef]; + } + } + docs = filteredDocs; + } + // only record appeared token for retrieved documents for the + // original token, not for expaned token. + // beause for doing coordNorm for a retrieved document, coordNorm only care how many + // query token appear in that document. + // so expanded token should not be added into docTokens, if added, this will pollute the + // coordNorm + if (key === token) { + this.fieldSearchStats(docTokens, key, docs); + } + + for (var docRef in docs) { + const tf = this.index[fieldName].getTermFrequency(key, docRef); + const fieldLength = this.documentStore.getFieldLength( + docRef, + fieldName + ); + let fieldLengthNorm = 1; + if (fieldLength !== 0) { + fieldLengthNorm = 1 / Math.sqrt(fieldLength); + } + + let penality = 1; + if (key !== token) { + // currently I'm not sure if this penality is enough, + // need to do verification + penality = + (1 - (key.length - token.length) / key.length) * 0.15; + } + + const score = tf * idf * fieldLengthNorm * penality; + + if (docRef in queryTokenScores) { + queryTokenScores[docRef] += score; + } else { + queryTokenScores[docRef] = score; + } + } + }, this); + + scores = this.mergeScores(scores, queryTokenScores, booleanType); + }, this); + + scores = this.coordNorm(scores, docTokens, queryTokens.length); + return scores; + }; + + /** + * Merge the scores from one set of tokens into an accumulated score table. + * Exact operation depends on the op parameter. If op is 'AND', then only the + * intersection of the two score lists is retained. Otherwise, the union of + * the two score lists is returned. For internal use only. + * + * @param {Object} bool accumulated scores. Should be null on first call. + * @param {String} scores new scores to merge into accumScores. + * @param {Object} op merge operation (should be 'AND' or 'OR'). + * + */ + + elasticlunr.Index.prototype.mergeScores = function (accumScores, scores, op) { + if (!accumScores) { + return scores; + } + if (op === 'AND') { + const intersection = {}; + for (var docRef in scores) { + if (docRef in accumScores) { + intersection[docRef] = accumScores[docRef] + scores[docRef]; + } + } + return intersection; + } else { + for (var docRef in scores) { + if (docRef in accumScores) { + accumScores[docRef] += scores[docRef]; + } else { + accumScores[docRef] = scores[docRef]; + } + } + return accumScores; + } + }; + + /** + * Record the occuring query token of retrieved doc specified by doc field. + * Only for inner user. + * + * @param {Object} docTokens a data structure stores which token appears in the retrieved doc. + * @param {String} token query token + * @param {Object} docs the retrieved documents of the query token + * + */ + elasticlunr.Index.prototype.fieldSearchStats = function (docTokens, token, docs) { + for (const doc in docs) { + if (doc in docTokens) { + docTokens[doc].push(token); + } else { + docTokens[doc] = [token]; + } + } + }; + + /** + * coord norm the score of a doc. + * if a doc contain more query tokens, then the score will larger than the doc + * contains less query tokens. + * + * only for inner use. + * + * @param {Object} results first results + * @param {Object} docs field search results of a token + * @param {Integer} n query token number + * @return {Object} + */ + elasticlunr.Index.prototype.coordNorm = function (scores, docTokens, n) { + for (const doc in scores) { + if (!(doc in docTokens)) continue; + const tokens = docTokens[doc].length; + scores[doc] = (scores[doc] * tokens) / n; + } + + return scores; + }; + + /** + * Returns a representation of the index ready for serialisation. + * + * @return {Object} + * @memberOf Index + */ + elasticlunr.Index.prototype.toJSON = function () { + const indexJson = {}; + this._fields.forEach(function (field) { + indexJson[field] = this.index[field].toJSON(); + }, this); + + return { + version: elasticlunr.version, + fields: this._fields, + ref: this._ref, + documentStore: this.documentStore.toJSON(), + index: indexJson, + pipeline: this.pipeline.toJSON(), + }; + }; + + /** + * Applies a plugin to the current index. + * + * A plugin is a function that is called with the index as its context. + * Plugins can be used to customise or extend the behaviour the index + * in some way. A plugin is just a function, that encapsulated the custom + * behaviour that should be applied to the index. + * + * The plugin function will be called with the index as its argument, additional + * arguments can also be passed when calling use. The function will be called + * with the index as its context. + * + * Example: + * + * var myPlugin = function (idx, arg1, arg2) { + * // `this` is the index to be extended + * // apply any extensions etc here. + * } + * + * var idx = elasticlunr(function () { + * this.use(myPlugin, 'arg1', 'arg2') + * }) + * + * @param {Function} plugin The plugin to apply. + * @memberOf Index + */ + elasticlunr.Index.prototype.use = function (plugin) { + const args = Array.prototype.slice.call(arguments, 1); + args.unshift(this); + plugin.apply(this, args); + }; + /*! + * elasticlunr.DocumentStore + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.DocumentStore is a simple key-value document store used for storing sets of tokens for + * documents stored in index. + * + * elasticlunr.DocumentStore store original JSON format documents that you could build search snippet by this original JSON document. + * + * user could choose whether original JSON format document should be store, if no configuration then document will be stored defaultly. + * If user care more about the index size, user could select not store JSON documents, then this will has some defects, such as user + * could not use JSON document to generate snippets of search results. + * + * @param {Boolean} save If the original JSON document should be stored. + * @constructor + * @module + */ + elasticlunr.DocumentStore = function (save) { + if (save === null || save === undefined) { + this._save = true; + } else { + this._save = save; + } + + this.docs = {}; + this.docInfo = {}; + this.length = 0; + }; + + /** + * Loads a previously serialised document store + * + * @param {Object} serialisedData The serialised document store to load. + * @return {elasticlunr.DocumentStore} + */ + elasticlunr.DocumentStore.load = function (serialisedData) { + const store = new this(); + + store.length = serialisedData.length; + store.docs = serialisedData.docs; + store.docInfo = serialisedData.docInfo; + store._save = serialisedData.save; + + return store; + }; + + /** + * check if current instance store the original doc + * + * @return {Boolean} + */ + elasticlunr.DocumentStore.prototype.isDocStored = function () { + return this._save; + }; + + /** + * Stores the given doc in the document store against the given id. + * If docRef already exist, then update doc. + * + * Document is store by original JSON format, then you could use original document to generate search snippets. + * + * @param {Integer|String} docRef The key used to store the JSON format doc. + * @param {Object} doc The JSON format doc. + */ + elasticlunr.DocumentStore.prototype.addDoc = function (docRef, doc) { + if (!this.hasDoc(docRef)) this.length++; + + if (this._save === true) { + this.docs[docRef] = clone(doc); + } else { + this.docs[docRef] = null; + } + }; + + /** + * Retrieves the JSON doc from the document store for a given key. + * + * If docRef not found, return null. + * If user set not storing the documents, return null. + * + * @param {Integer|String} docRef The key to lookup and retrieve from the document store. + * @return {Object} + * @memberOf DocumentStore + */ + elasticlunr.DocumentStore.prototype.getDoc = function (docRef) { + if (this.hasDoc(docRef) === false) return null; + return this.docs[docRef]; + }; + + /** + * Checks whether the document store contains a key (docRef). + * + * @param {Integer|String} docRef The id to look up in the document store. + * @return {Boolean} + * @memberOf DocumentStore + */ + elasticlunr.DocumentStore.prototype.hasDoc = function (docRef) { + return docRef in this.docs; + }; + + /** + * Removes the value for a key in the document store. + * + * @param {Integer|String} docRef The id to remove from the document store. + * @memberOf DocumentStore + */ + elasticlunr.DocumentStore.prototype.removeDoc = function (docRef) { + if (!this.hasDoc(docRef)) return; + + delete this.docs[docRef]; + delete this.docInfo[docRef]; + this.length--; + }; + + /** + * Add field length of a document's field tokens from pipeline results. + * The field length of a document is used to do field length normalization even without the original JSON document stored. + * + * @param {Integer|String} docRef document's id or reference + * @param {String} fieldName field name + * @param {Integer} length field length + */ + elasticlunr.DocumentStore.prototype.addFieldLength = function ( + docRef, + fieldName, + length + ) { + if (docRef === null || docRef === undefined) return; + if (this.hasDoc(docRef) == false) return; + + if (!this.docInfo[docRef]) this.docInfo[docRef] = {}; + this.docInfo[docRef][fieldName] = length; + }; + + /** + * Update field length of a document's field tokens from pipeline results. + * The field length of a document is used to do field length normalization even without the original JSON document stored. + * + * @param {Integer|String} docRef document's id or reference + * @param {String} fieldName field name + * @param {Integer} length field length + */ + elasticlunr.DocumentStore.prototype.updateFieldLength = function ( + docRef, + fieldName, + length + ) { + if (docRef === null || docRef === undefined) return; + if (this.hasDoc(docRef) == false) return; + + this.addFieldLength(docRef, fieldName, length); + }; + + /** + * get field length of a document by docRef + * + * @param {Integer|String} docRef document id or reference + * @param {String} fieldName field name + * @return {Integer} field length + */ + elasticlunr.DocumentStore.prototype.getFieldLength = function (docRef, fieldName) { + if (docRef === null || docRef === undefined) return 0; + + if (!(docRef in this.docs)) return 0; + if (!(fieldName in this.docInfo[docRef])) return 0; + return this.docInfo[docRef][fieldName]; + }; + + /** + * Returns a JSON representation of the document store used for serialisation. + * + * @return {Object} JSON format + * @memberOf DocumentStore + */ + elasticlunr.DocumentStore.prototype.toJSON = function () { + return { + docs: this.docs, + docInfo: this.docInfo, + length: this.length, + save: this._save, + }; + }; + + /** + * Cloning object + * + * @param {Object} object in JSON format + * @return {Object} copied object + */ + function clone(obj) { + if (obj === null || typeof obj !== 'object') return obj; + + const copy = obj.constructor(); + + for (const attr in obj) { + if (obj.hasOwnProperty(attr)) copy[attr] = obj[attr]; + } + + return copy; + } + /*! + * elasticlunr.stemmer + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt + */ + + /** + * elasticlunr.stemmer is an english language stemmer, this is a JavaScript + * implementation of the PorterStemmer taken from http://tartarus.org/~martin + * + * @module + * @param {String} str The string to stem + * @return {String} + * @see elasticlunr.Pipeline + */ + elasticlunr.stemmer = (function () { + const step2list = { + ational: 'ate', + tional: 'tion', + enci: 'ence', + anci: 'ance', + izer: 'ize', + bli: 'ble', + alli: 'al', + entli: 'ent', + eli: 'e', + ousli: 'ous', + ization: 'ize', + ation: 'ate', + ator: 'ate', + alism: 'al', + iveness: 'ive', + fulness: 'ful', + ousness: 'ous', + aliti: 'al', + iviti: 'ive', + biliti: 'ble', + logi: 'log', + }; + + const step3list = { + icate: 'ic', + ative: '', + alize: 'al', + iciti: 'ic', + ical: 'ic', + ful: '', + ness: '', + }; + + const c = '[^aeiou]'; // consonant + const v = '[aeiouy]'; // vowel + const C = c + '[^aeiouy]*'; // consonant sequence + const V = v + '[aeiou]*'; // vowel sequence + + const mgr0 = '^(' + C + ')?' + V + C; // [C]VC... is m>0 + const meq1 = '^(' + C + ')?' + V + C + '(' + V + ')?$'; // [C]VC[V] is m=1 + const mgr1 = '^(' + C + ')?' + V + C + V + C; // [C]VCVC... is m>1 + const s_v = '^(' + C + ')?' + v; // vowel in stem + + const re_mgr0 = new RegExp(mgr0); + const re_mgr1 = new RegExp(mgr1); + const re_meq1 = new RegExp(meq1); + const re_s_v = new RegExp(s_v); + + const re_1a = /^(.+?)(ss|i)es$/; + const re2_1a = /^(.+?)([^s])s$/; + const re_1b = /^(.+?)eed$/; + const re2_1b = /^(.+?)(ed|ing)$/; + const re_1b_2 = /.$/; + const re2_1b_2 = /(at|bl|iz)$/; + const re3_1b_2 = new RegExp('([^aeiouylsz])\\1$'); + const re4_1b_2 = new RegExp('^' + C + v + '[^aeiouwxy]$'); + + const re_1c = /^(.+?[^aeiou])y$/; + const re_2 = + /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + + const re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + + const re_4 = + /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + const re2_4 = /^(.+?)(s|t)(ion)$/; + + const re_5 = /^(.+?)e$/; + const re_5_1 = /ll$/; + const re3_5 = new RegExp('^' + C + v + '[^aeiouwxy]$'); + + const porterStemmer = function porterStemmer(w) { + let stem, suffix, firstch, re, re2, re3, re4; + + if (w.length < 3) { + return w; + } + + firstch = w.substr(0, 1); + if (firstch == 'y') { + w = firstch.toUpperCase() + w.substr(1); + } + + // Step 1a + re = re_1a; + re2 = re2_1a; + + if (re.test(w)) { + w = w.replace(re, '$1$2'); + } else if (re2.test(w)) { + w = w.replace(re2, '$1$2'); + } + + // Step 1b + re = re_1b; + re2 = re2_1b; + if (re.test(w)) { + var fp = re.exec(w); + re = re_mgr0; + if (re.test(fp[1])) { + re = re_1b_2; + w = w.replace(re, ''); + } + } else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = re_s_v; + if (re2.test(stem)) { + w = stem; + re2 = re2_1b_2; + re3 = re3_1b_2; + re4 = re4_1b_2; + if (re2.test(w)) { + w = w + 'e'; + } else if (re3.test(w)) { + re = re_1b_2; + w = w.replace(re, ''); + } else if (re4.test(w)) { + w = w + 'e'; + } + } + } + + // Step 1c - replace suffix y or Y by i if preceded by a non-vowel which is not the first letter of the word (so cry -> cri, by -> by, say -> say) + re = re_1c; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + w = stem + 'i'; + } + + // Step 2 + re = re_2; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = re_mgr0; + if (re.test(stem)) { + w = stem + step2list[suffix]; + } + } + + // Step 3 + re = re_3; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = re_mgr0; + if (re.test(stem)) { + w = stem + step3list[suffix]; + } + } + + // Step 4 + re = re_4; + re2 = re2_4; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = re_mgr1; + if (re.test(stem)) { + w = stem; + } + } else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = re_mgr1; + if (re2.test(stem)) { + w = stem; + } + } + + // Step 5 + re = re_5; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = re_mgr1; + re2 = re_meq1; + re3 = re3_5; + if (re.test(stem) || (re2.test(stem) && !re3.test(stem))) { + w = stem; + } + } + + re = re_5_1; + re2 = re_mgr1; + if (re.test(w) && re2.test(w)) { + re = re_1b_2; + w = w.replace(re, ''); + } + + // and turn initial Y back to y + + if (firstch == 'y') { + w = firstch.toLowerCase() + w.substr(1); + } + + return w; + }; + + return porterStemmer; + })(); + + elasticlunr.Pipeline.registerFunction(elasticlunr.stemmer, 'stemmer'); + /*! + * elasticlunr.stopWordFilter + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.stopWordFilter is an English language stop words filter, any words + * contained in the stop word list will not be passed through the filter. + * + * This is intended to be used in the Pipeline. If the token does not pass the + * filter then undefined will be returned. + * Currently this StopwordFilter using dictionary to do O(1) time complexity stop word filtering. + * + * @module + * @param {String} token The token to pass through the filter + * @return {String} + * @see elasticlunr.Pipeline + */ + elasticlunr.stopWordFilter = function (token) { + if (token && elasticlunr.stopWordFilter.stopWords[token] !== true) { + return token; + } + }; + + /** + * Remove predefined stop words + * if user want to use customized stop words, user could use this function to delete + * all predefined stopwords. + * + * @return {null} + */ + elasticlunr.clearStopWords = function () { + elasticlunr.stopWordFilter.stopWords = {}; + }; + + /** + * Add customized stop words + * user could use this function to add customized stop words + * + * @params {Array} words customized stop words + * @return {null} + */ + elasticlunr.addStopWords = function (words) { + if (words == null || Array.isArray(words) === false) return; + + words.forEach(function (word) { + elasticlunr.stopWordFilter.stopWords[word] = true; + }, this); + }; + + /** + * Reset to default stop words + * user could use this function to restore default stop words + * + * @return {null} + */ + elasticlunr.resetStopWords = function () { + elasticlunr.stopWordFilter.stopWords = elasticlunr.defaultStopWords; + }; + + elasticlunr.defaultStopWords = { + '': true, + a: true, + able: true, + about: true, + across: true, + after: true, + all: true, + almost: true, + also: true, + am: true, + among: true, + an: true, + and: true, + any: true, + are: true, + as: true, + at: true, + be: true, + because: true, + been: true, + but: true, + by: true, + can: true, + cannot: true, + could: true, + dear: true, + did: true, + do: true, + does: true, + either: true, + else: true, + ever: true, + every: true, + for: true, + from: true, + get: true, + got: true, + had: true, + has: true, + have: true, + he: true, + her: true, + hers: true, + him: true, + his: true, + how: true, + however: true, + i: true, + if: true, + in: true, + into: true, + is: true, + it: true, + its: true, + just: true, + least: true, + let: true, + like: true, + likely: true, + may: true, + me: true, + might: true, + most: true, + must: true, + my: true, + neither: true, + no: true, + nor: true, + not: true, + of: true, + off: true, + often: true, + on: true, + only: true, + or: true, + other: true, + our: true, + own: true, + rather: true, + said: true, + say: true, + says: true, + she: true, + should: true, + since: true, + so: true, + some: true, + than: true, + that: true, + the: true, + their: true, + them: true, + then: true, + there: true, + these: true, + they: true, + this: true, + tis: true, + to: true, + too: true, + twas: true, + us: true, + wants: true, + was: true, + we: true, + were: true, + what: true, + when: true, + where: true, + which: true, + while: true, + who: true, + whom: true, + why: true, + will: true, + with: true, + would: true, + yet: true, + you: true, + your: true, + }; + + elasticlunr.stopWordFilter.stopWords = elasticlunr.defaultStopWords; + + elasticlunr.Pipeline.registerFunction(elasticlunr.stopWordFilter, 'stopWordFilter'); + /*! + * elasticlunr.trimmer + * Copyright (C) 2017 Oliver Nightingale + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.trimmer is a pipeline function for trimming non word + * characters from the begining and end of tokens before they + * enter the index. + * + * This implementation may not work correctly for non latin + * characters and should either be removed or adapted for use + * with languages with non-latin characters. + * + * @module + * @param {String} token The token to pass through the filter + * @return {String} + * @see elasticlunr.Pipeline + */ + elasticlunr.trimmer = function (token) { + if (token === null || token === undefined) { + throw new Error('token should not be undefined'); + } + + return token.replace(/^\W+/, '').replace(/\W+$/, ''); + }; + + elasticlunr.Pipeline.registerFunction(elasticlunr.trimmer, 'trimmer'); + /*! + * elasticlunr.InvertedIndex + * Copyright (C) 2017 Wei Song + * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt + */ + + /** + * elasticlunr.InvertedIndex is used for efficiently storing and + * lookup of documents that contain a given token. + * + * @constructor + */ + elasticlunr.InvertedIndex = function () { + this.root = { docs: {}, df: 0 }; + }; + + /** + * Loads a previously serialised inverted index. + * + * @param {Object} serialisedData The serialised inverted index to load. + * @return {elasticlunr.InvertedIndex} + */ + elasticlunr.InvertedIndex.load = function (serialisedData) { + const idx = new this(); + idx.root = serialisedData.root; + + return idx; + }; + + /** + * Adds a {token: tokenInfo} pair to the inverted index. + * If the token already exist, then update the tokenInfo. + * + * tokenInfo format: { ref: 1, tf: 2} + * tokenInfor should contains the document's ref and the tf(token frequency) of that token in + * the document. + * + * By default this function starts at the root of the current inverted index, however + * it can start at any node of the inverted index if required. + * + * @param {String} token + * @param {Object} tokenInfo format: { ref: 1, tf: 2} + * @param {Object} root An optional node at which to start looking for the + * correct place to enter the doc, by default the root of this elasticlunr.InvertedIndex + * is used. + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.addToken = function (token, tokenInfo, root) { + var root = root || this.root; + let idx = 0; + + while (idx <= token.length - 1) { + const key = token[idx]; + + if (!(key in root)) root[key] = { docs: {}, df: 0 }; + idx += 1; + root = root[key]; + } + + const docRef = tokenInfo.ref; + if (!root.docs[docRef]) { + // if this doc not exist, then add this doc + root.docs[docRef] = { tf: tokenInfo.tf }; + root.df += 1; + } else { + // if this doc already exist, then update tokenInfo + root.docs[docRef] = { tf: tokenInfo.tf }; + } + }; + + /** + * Checks whether a token is in this elasticlunr.InvertedIndex. + * + * + * @param {String} token The token to be checked + * @return {Boolean} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.hasToken = function (token) { + if (!token) return false; + + let node = this.root; + + for (let i = 0; i < token.length; i++) { + if (!node[token[i]]) return false; + node = node[token[i]]; + } + + return true; + }; + + /** + * Retrieve a node from the inverted index for a given token. + * If token not found in this InvertedIndex, return null. + * + * + * @param {String} token The token to get the node for. + * @return {Object} + * @see InvertedIndex.prototype.get + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.getNode = function (token) { + if (!token) return null; + + let node = this.root; + + for (let i = 0; i < token.length; i++) { + if (!node[token[i]]) return null; + node = node[token[i]]; + } + + return node; + }; + + /** + * Retrieve the documents of a given token. + * If token not found, return {}. + * + * + * @param {String} token The token to get the documents for. + * @return {Object} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.getDocs = function (token) { + const node = this.getNode(token); + if (node == null) { + return {}; + } + + return node.docs; + }; + + /** + * Retrieve term frequency of given token in given docRef. + * If token or docRef not found, return 0. + * + * + * @param {String} token The token to get the documents for. + * @param {String|Integer} docRef + * @return {Integer} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.getTermFrequency = function (token, docRef) { + const node = this.getNode(token); + + if (node == null) { + return 0; + } + + if (!(docRef in node.docs)) { + return 0; + } + + return node.docs[docRef].tf; + }; + + /** + * Retrieve the document frequency of given token. + * If token not found, return 0. + * + * + * @param {String} token The token to get the documents for. + * @return {Object} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.getDocFreq = function (token) { + const node = this.getNode(token); + + if (node == null) { + return 0; + } + + return node.df; + }; + + /** + * Remove the document identified by document's ref from the token in the inverted index. + * + * + * @param {String} token Remove the document from which token. + * @param {String} ref The ref of the document to remove from given token. + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.removeToken = function (token, ref) { + if (!token) return; + const node = this.getNode(token); + + if (node == null) return; + + if (ref in node.docs) { + delete node.docs[ref]; + node.df -= 1; + } + }; + + /** + * Find all the possible suffixes of given token using tokens currently in the inverted index. + * If token not found, return empty Array. + * + * @param {String} token The token to expand. + * @return {Array} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.expandToken = function (token, memo, root) { + if (token == null || token == '') return []; + var memo = memo || []; + + if (root == void 0) { + root = this.getNode(token); + if (root == null) return memo; + } + + if (root.df > 0) memo.push(token); + + for (const key in root) { + if (key === 'docs') continue; + if (key === 'df') continue; + this.expandToken(token + key, memo, root[key]); + } + + return memo; + }; + + /** + * Returns a representation of the inverted index ready for serialisation. + * + * @return {Object} + * @memberOf InvertedIndex + */ + elasticlunr.InvertedIndex.prototype.toJSON = function () { + return { + root: this.root, + }; + }; + + /*! + * elasticlunr.Configuration + * Copyright (C) 2017 Wei Song + */ + + /** + * elasticlunr.Configuration is used to analyze the user search configuration. + * + * By elasticlunr.Configuration user could set query-time boosting, boolean model in each field. + * + * Currently configuration supports: + * 1. query-time boosting, user could set how to boost each field. + * 2. boolean model chosing, user could choose which boolean model to use for each field. + * 3. token expandation, user could set token expand to True to improve Recall. Default is False. + * + * Query time boosting must be configured by field category, "boolean" model could be configured + * by both field category or globally as the following example. Field configuration for "boolean" + * will overwrite global configuration. + * Token expand could be configured both by field category or golbally. Local field configuration will + * overwrite global configuration. + * + * configuration example: + * { + * fields:{ + * title: {boost: 2}, + * body: {boost: 1} + * }, + * bool: "OR" + * } + * + * "bool" field configuation overwrite global configuation example: + * { + * fields:{ + * title: {boost: 2, bool: "AND"}, + * body: {boost: 1} + * }, + * bool: "OR" + * } + * + * "expand" example: + * { + * fields:{ + * title: {boost: 2, bool: "AND"}, + * body: {boost: 1} + * }, + * bool: "OR", + * expand: true + * } + * + * "expand" example for field category: + * { + * fields:{ + * title: {boost: 2, bool: "AND", expand: true}, + * body: {boost: 1} + * }, + * bool: "OR" + * } + * + * setting the boost to 0 ignores the field (this will only search the title): + * { + * fields:{ + * title: {boost: 1}, + * body: {boost: 0} + * } + * } + * + * then, user could search with configuration to do query-time boosting. + * idx.search('oracle database', {fields: {title: {boost: 2}, body: {boost: 1}}}); + * + * + * @constructor + * + * @param {String} config user configuration + * @param {Array} fields fields of index instance + * @module + */ + elasticlunr.Configuration = function (config, fields) { + var config = config || ''; + + if (fields == undefined || fields == null) { + throw new Error('fields should not be null'); + } + + this.config = {}; + + let userConfig; + try { + userConfig = JSON.parse(config); + this.buildUserConfig(userConfig, fields); + } catch (error) { + elasticlunr.utils.warn( + 'user configuration parse failed, will use default configuration' + ); + this.buildDefaultConfig(fields); + } + }; + + /** + * Build default search configuration. + * + * @param {Array} fields fields of index instance + */ + elasticlunr.Configuration.prototype.buildDefaultConfig = function (fields) { + this.reset(); + fields.forEach(function (field) { + this.config[field] = { + boost: 1, + bool: 'OR', + expand: false, + }; + }, this); + }; + + /** + * Build user configuration. + * + * @param {JSON} config User JSON configuratoin + * @param {Array} fields fields of index instance + */ + elasticlunr.Configuration.prototype.buildUserConfig = function (config, fields) { + let global_bool = 'OR'; + let global_expand = false; + + this.reset(); + if ('bool' in config) { + global_bool = config.bool || global_bool; + } + + if ('expand' in config) { + global_expand = config.expand || global_expand; + } + + if ('fields' in config) { + for (const field in config.fields) { + if (fields.indexOf(field) > -1) { + const field_config = config.fields[field]; + let field_expand = global_expand; + if (field_config.expand != undefined) { + field_expand = field_config.expand; + } + + this.config[field] = { + boost: + field_config.boost || field_config.boost === 0 + ? field_config.boost + : 1, + bool: field_config.bool || global_bool, + expand: field_expand, + }; + } else { + elasticlunr.utils.warn( + 'field name in user configuration not found in index instance fields' + ); + } + } + } else { + this.addAllFields2UserConfig(global_bool, global_expand, fields); + } + }; + + /** + * Add all fields to user search configuration. + * + * @param {String} bool Boolean model + * @param {String} expand Expand model + * @param {Array} fields fields of index instance + */ + elasticlunr.Configuration.prototype.addAllFields2UserConfig = function ( + bool, + expand, + fields + ) { + fields.forEach(function (field) { + this.config[field] = { + boost: 1, + bool, + expand, + }; + }, this); + }; + + /** + * get current user configuration + */ + elasticlunr.Configuration.prototype.get = function () { + return this.config; + }; + + /** + * reset user search configuration. + */ + elasticlunr.Configuration.prototype.reset = function () { + this.config = {}; + }; + /** + * sorted_set.js is added only to make elasticlunr.js compatible with lunr-languages. + * if elasticlunr.js support different languages by default, this will make elasticlunr.js + * much bigger that not good for browser usage. + * + */ + + /*! + * lunr.SortedSet + * Copyright (C) 2017 Oliver Nightingale + */ + + /** + * lunr.SortedSets are used to maintain an array of uniq values in a sorted + * order. + * + * @constructor + */ + lunr.SortedSet = function () { + this.length = 0; + this.elements = []; + }; + + /** + * Loads a previously serialised sorted set. + * + * @param {Array} serialisedData The serialised set to load. + * @returns {lunr.SortedSet} + * @memberOf SortedSet + */ + lunr.SortedSet.load = function (serialisedData) { + const set = new this(); + + set.elements = serialisedData; + set.length = serialisedData.length; + + return set; + }; + + /** + * Inserts new items into the set in the correct position to maintain the + * order. + * + * @param {Object} The objects to add to this set. + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.add = function () { + let i, element; + + for (i = 0; i < arguments.length; i++) { + element = arguments[i]; + if (~this.indexOf(element)) continue; + this.elements.splice(this.locationFor(element), 0, element); + } + + this.length = this.elements.length; + }; + + /** + * Converts this sorted set into an array. + * + * @returns {Array} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.toArray = function () { + return this.elements.slice(); + }; + + /** + * Creates a new array with the results of calling a provided function on every + * element in this sorted set. + * + * Delegates to Array.prototype.map and has the same signature. + * + * @param {Function} fn The function that is called on each element of the + * set. + * @param {Object} ctx An optional object that can be used as the context + * for the function fn. + * @returns {Array} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.map = function (fn, ctx) { + return this.elements.map(fn, ctx); + }; + + /** + * Executes a provided function once per sorted set element. + * + * Delegates to Array.prototype.forEach and has the same signature. + * + * @param {Function} fn The function that is called on each element of the + * set. + * @param {Object} ctx An optional object that can be used as the context + * @memberOf SortedSet + * for the function fn. + */ + lunr.SortedSet.prototype.forEach = function (fn, ctx) { + return this.elements.forEach(fn, ctx); + }; + + /** + * Returns the index at which a given element can be found in the + * sorted set, or -1 if it is not present. + * + * @param {Object} elem The object to locate in the sorted set. + * @returns {Number} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.indexOf = function (elem) { + let start = 0; + let end = this.elements.length; + let sectionLength = end - start; + let pivot = start + Math.floor(sectionLength / 2); + let pivotElem = this.elements[pivot]; + + while (sectionLength > 1) { + if (pivotElem === elem) return pivot; + + if (pivotElem < elem) start = pivot; + if (pivotElem > elem) end = pivot; + + sectionLength = end - start; + pivot = start + Math.floor(sectionLength / 2); + pivotElem = this.elements[pivot]; + } + + if (pivotElem === elem) return pivot; + + return -1; + }; + + /** + * Returns the position within the sorted set that an element should be + * inserted at to maintain the current order of the set. + * + * This function assumes that the element to search for does not already exist + * in the sorted set. + * + * @param {Object} elem The elem to find the position for in the set + * @returns {Number} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.locationFor = function (elem) { + let start = 0; + let end = this.elements.length; + let sectionLength = end - start; + let pivot = start + Math.floor(sectionLength / 2); + let pivotElem = this.elements[pivot]; + + while (sectionLength > 1) { + if (pivotElem < elem) start = pivot; + if (pivotElem > elem) end = pivot; + + sectionLength = end - start; + pivot = start + Math.floor(sectionLength / 2); + pivotElem = this.elements[pivot]; + } + + if (pivotElem > elem) return pivot; + if (pivotElem < elem) return pivot + 1; + }; + + /** + * Creates a new lunr.SortedSet that contains the elements in the intersection + * of this set and the passed set. + * + * @param {lunr.SortedSet} otherSet The set to intersect with this set. + * @returns {lunr.SortedSet} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.intersect = function (otherSet) { + const intersectSet = new lunr.SortedSet(); + let i = 0; + let j = 0; + const a_len = this.length; + const b_len = otherSet.length; + const a = this.elements; + const b = otherSet.elements; + + while (true) { + if (i > a_len - 1 || j > b_len - 1) break; + + if (a[i] === b[j]) { + intersectSet.add(a[i]); + i++, j++; + continue; + } + + if (a[i] < b[j]) { + i++; + continue; + } + + if (a[i] > b[j]) { + j++; + continue; + } + } + + return intersectSet; + }; + + /** + * Makes a copy of this set + * + * @returns {lunr.SortedSet} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.clone = function () { + const clone = new lunr.SortedSet(); + + clone.elements = this.toArray(); + clone.length = clone.elements.length; + + return clone; + }; + + /** + * Creates a new lunr.SortedSet that contains the elements in the union + * of this set and the passed set. + * + * @param {lunr.SortedSet} otherSet The set to union with this set. + * @returns {lunr.SortedSet} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.union = function (otherSet) { + let longSet, shortSet, unionSet; + + if (this.length >= otherSet.length) { + (longSet = this), (shortSet = otherSet); + } else { + (longSet = otherSet), (shortSet = this); + } + + unionSet = longSet.clone(); + + for ( + let i = 0, shortSetElements = shortSet.toArray(); + i < shortSetElements.length; + i++ + ) { + unionSet.add(shortSetElements[i]); + } + + return unionSet; + }; + + /** + * Returns a representation of the sorted set ready for serialisation. + * + * @returns {Array} + * @memberOf SortedSet + */ + lunr.SortedSet.prototype.toJSON = function () { + return this.toArray(); + }; + /** + * export the module via AMD, CommonJS or as a browser global + * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js + */ + (function (root, factory) { + if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define(factory); + } else if (typeof exports === 'object') { + /** + * Node. Does not work with strict CommonJS, but + * only CommonJS-like enviroments that support module.exports, + * like Node. + */ + module.exports = factory(); + } else { + // Browser globals (root is window) + root.elasticlunr = factory(); + } + })(this, function () { + /** + * Just return a value to define the module export. + * This example returns an object, but the module + * can return a function as the exported value. + */ + return elasticlunr; + }); +})(); + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // +// End of elasticlunr code (http://elasticlunr.com/elasticlunr.js) // +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // + +window.onload = function () { + if (!document.body.contains(document.getElementById('searchModal'))) { + return; + } + + const lang = document.documentElement.lang; + const searchInput = document.getElementById('searchInput'); + const searchModal = document.getElementById('searchModal'); + const searchButton = document.getElementById('search-button'); + const clearSearchButton = document.getElementById('clear-search'); + const resultsContainer = document.getElementById('results-container'); + const results = document.getElementById('results'); + // Get all spans holding the translated strings, even if they are only used on one language. + const zeroResultsSpan = document.getElementById('zero_results'); + const oneResultsSpan = document.getElementById('one_results'); + const twoResultsSpan = document.getElementById('two_results'); + const fewResultsSpan = document.getElementById('few_results'); + const manyResultsSpan = document.getElementById('many_results'); + + // Static mapping of keys to spans. + const resultSpans = { + zero_results: zeroResultsSpan, + one_results: oneResultsSpan, + two_results: twoResultsSpan, + few_results: fewResultsSpan, + many_results: manyResultsSpan, + }; + + // Replace $SHORTCUT in search icon title with actual OS-specific shortcut. + function getShortcut() { + const userAgent = window.navigator.userAgent.toLowerCase(); + if (userAgent.includes('mac')) { + return 'Cmd + K'; + } else { + return 'Ctrl + K'; + } + } + + function setAttributes(element, attributeNames) { + const shortcut = getShortcut(); + attributeNames.forEach((attributeName) => { + let attributeValue = element.getAttribute(attributeName); + if (attributeValue) { + attributeValue = attributeValue.replace('$SHORTCUT', shortcut); + element.setAttribute(attributeName, attributeValue); + } + }); + } + setAttributes(searchButton, ['title', 'aria-label']); + + // Make search button keyboard accessible. + searchButton.addEventListener('keydown', function (event) { + if (event.key === 'Enter' || event.key === ' ') { + searchButton.click(); + } + }); + + let lastFocusedElement; + function openSearchModal() { + lastFocusedElement = document.activeElement; + loadSearchIndex(); + searchModal.style.display = 'block'; + searchInput.focus(); + } + + function closeModal() { + searchModal.style.display = 'none'; + clearSearch(); + if (lastFocusedElement && document.body.contains(lastFocusedElement)) { + lastFocusedElement.focus(); + } + } + + function toggleModalVisibility() { + const isModalOpen = searchModal.style.display === 'block'; + if (isModalOpen) { + closeModal(); + } else { + openSearchModal(); + } + } + + // Function to remove 'selected' class from all divs except the one passed. + function clearSelected(exceptDiv = null) { + const divs = results.querySelectorAll('#results > div'); + divs.forEach((div) => { + if (div !== exceptDiv) { + div.setAttribute('aria-selected', 'false'); + } + }); + } + + function updateSelection(div) { + if (div.getAttribute('aria-selected') !== 'true') { + clearSelected(div); + div.setAttribute('aria-selected', 'true'); + } + searchInput.setAttribute('aria-activedescendant', div.id); + } + + function clearSearch() { + searchInput.value = ''; + results.innerHTML = ''; + resultsContainer.style.display = 'none'; + searchInput.removeAttribute('aria-activedescendant'); + clearSearchButton.style.display = 'none'; + } + + // Close modal when clicking/tapping outside. + function handleModalInteraction(event) { + if (event.target === searchModal) { + closeModal(); + } + event.stopPropagation(); // Prevents tapping through the modal. + } + searchModal.addEventListener('click', handleModalInteraction); + searchModal.addEventListener('touchend', handleModalInteraction, { passive: true }); + + // Close modal when pressing escape. + document.addEventListener('keydown', function (event) { + if (event.key === 'Escape') { + closeModal(); + } + }); + + clearSearchButton.addEventListener('click', function () { + clearSearch(); + searchInput.focus(); + }); + clearSearchButton.addEventListener('keydown', function (event) { + if (event.key === 'Enter' || event.key === ' ') { + clearSearch(); + searchInput.focus(); + event.preventDefault(); + } + }); + + // The index loads on mouseover/tap. + // Clicking/tapping the search button opens the modal. + searchButton.addEventListener('mouseover', loadSearchIndex); + searchButton.addEventListener('click', openSearchModal); + searchButton.addEventListener('touchstart', openSearchModal, { passive: true }); + + let searchIndexPromise = null; + function loadSearchIndex() { + if (!searchIndexPromise) { + // Check if the search index is already loaded in the window object + if (window.searchIndex) { + // If the index is pre-loaded, use it directly. + searchIndexPromise = Promise.resolve( + elasticlunr.Index.load(window.searchIndex) + ); + } else { + // If the index is not pre-loaded, fetch it from the JSON file. + const language = document.documentElement + .getAttribute('lang') + .substring(0, 2); + let basePath = document + .querySelector("meta[name='base']") + .getAttribute('content'); + if (basePath.endsWith('/')) { + basePath = basePath.slice(0, -1); + } + + searchIndexPromise = fetch( + basePath + '/search_index.' + language + '.json' + ) + .then((response) => response.json()) + .then((json) => elasticlunr.Index.load(json)); + } + } + } + + function getByteByBinary(binaryCode) { + // Binary system, starts with `0b` in ES6 + // Octal number system, starts with `0` in ES5 and starts with `0o` in ES6 + // Hexadecimal, starts with `0x` in both ES5 and ES6 + var byteLengthDatas = [0, 1, 2, 3, 4]; + var len = byteLengthDatas[Math.ceil(binaryCode.length / 8)]; + return len; + } + + function getByteByHex(hexCode) { + return getByteByBinary(parseInt(hexCode, 16).toString(2)); + } + + function substringByByte(str, maxLength) { + let result = ''; + let flag = false; + let len = 0; + let length = 0; + let length2 = 0; + for (let i = 0; i < str.length; i++) { + const code = str.codePointAt(i).toString(16); + if (code.length > 4) { + i++; + if (i + 1 < str.length) { + flag = str.codePointAt(i + 1).toString(16) === '200d'; + } + } + if (flag) { + len += getByteByHex(code); + if (i == str.length - 1) { + length += len; + if (length <= maxLength) { + result += str.substr(length2, i - length2 + 1); + } else { + break; + } + } + } else { + if (len != 0) { + length += len; + length += getByteByHex(code); + if (length <= maxLength) { + result += str.substr(length2, i - length2 + 1); + length2 = i + 1; + } else { + break; + } + len = 0; + continue; + } + length += getByteByHex(code); + if (length <= maxLength) { + if (code.length <= 4) { + result += str[i]; + } else { + result += str[i - 1] + str[i]; + } + length2 = i + 1; + } else { + break; + } + } + } + return result; + } + + function generateSnippet(text, searchTerms) { + const BASE_SCORE = 2; + const FIRST_WORD_SCORE = 8; + const HIGHLIGHT_SCORE = 40; + const PRE_MATCH_CONTEXT_WORDS = 4; + const SNIPPET_LENGTH = 150; + const WINDOW_SIZE = 30; + + const stemmedTerms = searchTerms.map(function (term) { + return elasticlunr.stemmer(term.toLowerCase()); + }); + + let totalLength = 0; + const tokenScores = []; + const sentences = text.toLowerCase().split('. '); + + for (const sentence of sentences) { + const words = sentence.split(/[\s\n]/); + let isFirstWord = true; + + for (const word of words) { + if (word.length > 0) { + let score = isFirstWord ? FIRST_WORD_SCORE : BASE_SCORE; + for (const stemmedTerm of stemmedTerms) { + if (elasticlunr.stemmer(word).startsWith(stemmedTerm)) { + score = HIGHLIGHT_SCORE; + } + } + tokenScores.push([word, score, totalLength]); + isFirstWord = false; + } + totalLength += word.length + 1; + } + totalLength += 1; + } + + if (tokenScores.length === 0) { + return text.length > SNIPPET_LENGTH + ? text.substring(0, SNIPPET_LENGTH) + '…' + : text; + } + + const scores = []; + let windowScore = 0; + + for (var i = 0; i < Math.min(tokenScores.length, WINDOW_SIZE); i++) { + windowScore += tokenScores[i][1]; + } + scores.push(windowScore); + + // Slide the window and update the score. + for (var i = 1; i <= tokenScores.length - WINDOW_SIZE; i++) { + windowScore -= tokenScores[i - 1][1]; + windowScore += tokenScores[i + WINDOW_SIZE - 1][1]; + scores.push(windowScore); + } + + let maxScoreIndex = 0; + let maxScore = 0; + for (var i = scores.length - 1; i >= 0; i--) { + if (maxScore < scores[i]) { + maxScore = scores[i]; + maxScoreIndex = i; + } + } + + const snippet = []; + // From my testing, the context is more clear if we start a few words back. + let start = adjustStartPos( + text, + tokenScores[maxScoreIndex][2], + PRE_MATCH_CONTEXT_WORDS + ); + + function adjustStartPos(text, matchStartIndex, numWordsBack) { + let spaceCount = 0; + let index = matchStartIndex - 1; + while (index >= 0 && spaceCount < numWordsBack) { + if (text[index] === ' ' && text[index - 1] !== '.') { + spaceCount++; + } else if (text[index] === '.' && text[index + 1] === ' ') { + // Stop if the match is at the start of a sentence. + break; + } + index--; + } + return spaceCount === numWordsBack ? index + 1 : matchStartIndex; + } + const re = /^[\x00-\xff]+$/; // Regular expression for ASCII check. + for ( + var i = maxScoreIndex; + i < maxScoreIndex + WINDOW_SIZE && i < tokenScores.length; + i++ + ) { + const wordData = tokenScores[i]; + if (start < wordData[2]) { + snippet.push(text.substring(start, wordData[2])); + start = wordData[2]; + } + + if (wordData[1] === HIGHLIGHT_SCORE) { + snippet.push('<b>'); + } + const end = wordData[2] + wordData[0].length; + // Handle non-ASCII characters. + if (!re.test(wordData[0]) && wordData[0].length >= 12) { + const strBefore = text.substring(wordData[2], end); + const strAfter = substringByByte(strBefore, 12); + snippet.push(strAfter); + } else { + snippet.push(text.substring(wordData[2], end)); + } + + if (wordData[1] === HIGHLIGHT_SCORE) { + snippet.push('</b>'); + } + start = end; + } + + snippet.push('…'); + const joinedSnippet = snippet.join(''); + let truncatedSnippet = joinedSnippet; + if (joinedSnippet.replace(/<[^>]+>/g, '').length > SNIPPET_LENGTH) { + truncatedSnippet = joinedSnippet.substring(0, SNIPPET_LENGTH) + '…'; + } + + return truncatedSnippet; + } + + // Handle input in the search box. + searchInput.addEventListener( + 'input', + async function () { + const inputValue = this.value; + const searchTerm = inputValue.trim(); + const searchIndex = await searchIndexPromise; + results.innerHTML = ''; + + // Use the raw input so the "clear" button appears even if there's only spaces. + clearSearchButton.style.display = inputValue.length > 0 ? 'block' : 'none'; + resultsContainer.style.display = searchTerm.length > 0 ? 'block' : 'none'; + + // Perform the search and store the results. + const searchResults = searchIndex.search(searchTerm, { + bool: 'OR', + fields: { + title: { boost: 3 }, + body: { boost: 2 }, + description: { boost: 1 }, + path: { boost: 1 }, + }, + }); + + // Update the number of results. + updateResultText(searchResults.length); + + // Display the results. + let resultIdCounter = 0; // Counter to generate unique IDs. + searchResults.forEach(function (result) { + if (result.doc.title || result.doc.path || result.doc.id) { + const resultDiv = document.createElement('div'); + resultDiv.setAttribute('role', 'option'); + resultDiv.id = 'result-' + resultIdCounter++; + resultDiv.innerHTML = '<a href><span></span><span></span></a>'; + const linkElement = resultDiv.querySelector('a'); + const titleElement = resultDiv.querySelector('span:first-child'); + const snippetElement = resultDiv.querySelector('span:nth-child(2)'); + + // Determine the text for the title. + titleElement.textContent = + result.doc.title || result.doc.path || result.doc.id; + + // Determine if the body or description is available for the snippet. + let snippetText = result.doc.body + ? generateSnippet(result.doc.body, searchTerm.split(/\s+/)) + : result.doc.description + ? result.doc.description + : ''; + snippetElement.innerHTML = snippetText; + + // Create the hyperlink. + let href = result.ref; + if (result.doc.body) { + // Include text fragment if body is available. + const encodedSearchTerm = encodeURIComponent(searchTerm); + href += `#:~:text=${encodedSearchTerm}`; + } + linkElement.href = href; + + results.appendChild(resultDiv); + } + }); + + searchInput.setAttribute( + 'aria-expanded', + resultIdCounter > 0 ? 'true' : 'false' + ); + + if (results.firstChild) { + updateSelection(results.firstChild); + } + + results.addEventListener('mouseover', function (event) { + if (event.target.closest('div[role="option"]')) { + updateSelection(event.target.closest('div[role="option"]')); + } + }); + + results.addEventListener('click', function(event) { + const clickedElement = event.target.closest('a'); + if (clickedElement) { + const clickedHref = clickedElement.getAttribute('href'); + const currentPageUrl = window.location.href; + + // Normalise URLs by removing the text fragment and trailing slash. + const normalizeUrl = (url) => url.split('#')[0].replace(/\/$/, ''); + + // Check if the clicked link matches the current page. + // If using Ctrl+click or Cmd+click, don't close the modal. + if (normalizeUrl(clickedHref) === normalizeUrl(currentPageUrl) && + !event.ctrlKey && !event.metaKey) { + closeModal(); + } + } + }); + + // Add touch events to the results. + setupTouchEvents(); + }, + true + ); + + function updateResultText(count) { + // Determine the correct pluralization key based on count and language. + const pluralizationKey = getPluralizationKey(count, lang); + + // Hide all result text spans. + Object.values(resultSpans).forEach((span) => { + if (span) span.style.display = 'none'; + }); + + // Show the relevant result text span, replacing $NUMBER with the actual count. + const activeSpan = resultSpans[pluralizationKey]; + if (activeSpan) { + activeSpan.style.display = 'inline'; + activeSpan.textContent = activeSpan.textContent.replace( + '$NUMBER', + count.toString() + ); + } + } + + function getPluralizationKey(count, lang) { + let key = ''; + const slavicLangs = ['uk', 'be', 'bs', 'hr', 'ru', 'sr']; + + // Common cases: zero, one. + if (count === 0) { + key = 'zero_results'; + } else if (count === 1) { + key = 'one_results'; + } else { + // Arabic. + if (lang === 'ar') { + let modulo = count % 100; + if (count === 2) { + key = 'two_results'; + } else if (modulo >= 3 && modulo <= 10) { + key = 'few_results'; + } else { + key = 'many_results'; + } + } else if (slavicLangs.includes(lang)) { + // Slavic languages. + let modulo10 = count % 10; + let modulo100 = count % 100; + if (modulo10 === 1 && modulo100 !== 11) { + key = 'one_results'; + } else if ( + modulo10 >= 2 && + modulo10 <= 4 && + !(modulo100 >= 12 && modulo100 <= 14) + ) { + key = 'few_results'; + } else { + key = 'many_results'; + } + } else { + key = 'many_results'; // Default plural. + } + } + + return key; + } + + function setupTouchEvents() { + const resultDivs = document.querySelectorAll('#results > div'); + resultDivs.forEach((div) => { + // Remove existing listener to avoid duplicates. + div.removeEventListener('touchstart', handleTouchStart); + div.addEventListener('touchstart', handleTouchStart, { passive: true }); + }); + } + + function handleTouchStart() { + updateSelection(this); + } + + // Handle keyboard navigation. + document.addEventListener('keydown', function (event) { + // Add handling for the modal open/close shortcut. + const isMac = navigator.userAgent.toLowerCase().includes('mac'); + const MODAL_SHORTCUT_KEY = 'k'; + const modalShortcutModifier = isMac ? event.metaKey : event.ctrlKey; + + if (event.key === MODAL_SHORTCUT_KEY && modalShortcutModifier) { + event.preventDefault(); + toggleModalVisibility(); + return; + } + + const activeElement = document.activeElement; + if ( + event.key === 'Tab' && + (activeElement === searchInput || activeElement === clearSearchButton) + ) { + event.preventDefault(); + const nextFocusableElement = + activeElement === searchInput ? clearSearchButton : searchInput; + nextFocusableElement.focus(); + return; + } + + function updateResultSelection(newIndex, divsArray) { + updateSelection(divsArray[newIndex]); + divsArray[newIndex].scrollIntoView({ block: 'nearest', inline: 'start' }); + } + + const resultDivs = results.querySelectorAll('#results > div'); + if (resultDivs.length === 0) return; + + const divsArray = Array.from(resultDivs); + let activeDiv = results.querySelector('[aria-selected="true"]'); + let activeDivIndex = divsArray.indexOf(activeDiv); + + if ( + ['ArrowUp', 'ArrowDown', 'Home', 'End', 'PageUp', 'PageDown'].includes( + event.key + ) + ) { + event.preventDefault(); + let newIndex = activeDivIndex; + + switch (event.key) { + case 'ArrowUp': + newIndex = Math.max(activeDivIndex - 1, 0); + break; + case 'ArrowDown': + newIndex = Math.min(activeDivIndex + 1, divsArray.length - 1); + break; + case 'Home': + newIndex = 0; + break; + case 'End': + newIndex = divsArray.length - 1; + break; + case 'PageUp': + newIndex = Math.max(activeDivIndex - 3, 0); + break; + case 'PageDown': + newIndex = Math.min(activeDivIndex + 3, divsArray.length - 1); + break; + } + + if (newIndex !== activeDivIndex) { + updateResultSelection(newIndex, divsArray); + } + } + + if (event.key === 'Enter' && activeDiv) { + event.preventDefault(); + event.stopImmediatePropagation(); + const anchorTag = activeDiv.querySelector('a'); + if (anchorTag) { + window.location.href = anchorTag.getAttribute('href'); + } + closeModal(); // Necessary when linking to the current page. + } + }); +}; |