diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-03-09 13:19:48 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-03-09 13:20:02 +0000 |
commit | 58daab21cd043e1dc37024a7f99b396788372918 (patch) | |
tree | 96771e43bb69f7c1c2b0b4f7374cb74d7866d0cb /web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static | |
parent | Releasing debian version 1.43.2-1. (diff) | |
download | netdata-58daab21cd043e1dc37024a7f99b396788372918.tar.xz netdata-58daab21cd043e1dc37024a7f99b396788372918.zip |
Merging upstream version 1.44.3.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static')
3 files changed, 7490 insertions, 0 deletions
diff --git a/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-jquery-ui.js b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-jquery-ui.js new file mode 100644 index 000000000..bd1efb8c5 --- /dev/null +++ b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-jquery-ui.js @@ -0,0 +1,521 @@ +/** + * @fileOverview + * A UI script that creates search form, loads an index files and show search results. + * It needs jQuery and <tt>oktavia-search.js</tt> or <tt>oktavia-*-search.js</tt> + * (stemming library supported versions). + * @author Yoshiki Shibukawa, yoshiki@shibu.jp + */ + +(function ($) +{ + var logosrc; + /** + * @name SearchView + * @class + * Provides searching feature to your website. + * @constructor + * @param {jQeury} node Target node it has a search form and a search result window. + * @param {string} documentRoot Document root folder like '.', '../', '/' + * @param {string} index Index file path. + */ + function SearchView(node, documentRoot, index) + { + var OktaviaSearch = JSX.require("tool/web/oktavia-search.jsx").OktaviaSearch$I; + + /** + * Target node it contains a search form and a search result window. + * @type jQuery + */ + this.node = node; + /** + * Search engine core + * @type OktaviaSearch + */ + this.engine = new OktaviaSearch(5); + if (documentRoot === '') + { + /** + * Document root path + * @type string[] + */ + this.documentRoot = []; + } + else if (documentRoot.slice(-1) === '/') + { + this.documentRoot = documentRoot.slice(0, -1).split(/\//g); + } + else + { + this.documentRoot = documentRoot.split(/\//g); + } + + /** + * It is true if an index file is loaded. + * @type boolean + */ + this.initialized = false; + /** + * It is true if an user search before loading an index. + * @type boolean + */ + this.reserveSearch = false; + + var indexURL; + switch (index.charAt(0)) + { + case '.': + case '/': + indexURL = index; + break; + default: + indexURL = this.getDocumentPath(index); + break; + } + var self = this; + function loadIndex() + { + self.engine.loadIndex$S(window.searchIndex); + self.initialized = true; + window.searchIndex = null; + if (self.reserveSearch) + { + self.search(); + } + self.reserveSearch = false; + } + if (window.searchIndex) + { + loadIndex() + } + else + { + this.loadJavaScript(indexURL, loadIndex); + } + } + + /** + * Changes result page. + * @param {integer} page Page number + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.changePage = function (page) + { + this.engine.setCurrentPage$I(page); + this.updateResult(); + }; + + /** + * Clears a search form and a reult window. + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.clearResult = function () + { + $('.oktavia_search', this.node).val(''); + $('.oktavia_searchresult_box', this.node).hide(); + }; + + /** + * Loads an external JavaScript file. + * + * This code is based on: http://os0x.hatenablog.com/entry/20080827/1219815828 + * @param {string} src A JavaScript source file path + * @param {function} callback It is called when the target JavaScript file is loaded + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.loadJavaScript = function (src, callback) + { + var sc = document.createElement('script'); + sc.type = 'text/javascript'; + if (window.ActiveXObject) + { + sc.onreadystatechange = function () + { + if (sc.readyState === 'complete' || sc.readyState === 'loaded') + { + callback(sc.readyState); + } + }; + } + else + { + sc.onload = function () + { + callback('onload'); + }; + } + sc.src = src; + document.body.appendChild(sc); + }; + + /** + * Updates page navigation list. + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.updatePageList = function () + { + var self = this; + function createCallback(i) + { + return function () { + self.changePage(i); + }; + } + + var currentPage = String(this.engine.currentPage$()); + var nav = $('.oktavia_searchresult_nav', this.node); + nav.empty(); + var pages = this.engine.pageIndexes$(); + for (var i = 0; i < pages.length; i++) + { + var pageItem = $('<span/>').text(pages[i]); + if (pages[i] === '...') + { + pageItem.addClass('leader'); + } + else + { + pageItem.addClass('page'); + if (pages[i] !== currentPage) + { + pageItem.bind('click', createCallback(Number(pages[i]))); + } + else + { + pageItem.addClass('selected'); + } + } + nav.append(pageItem); + } + }; + + /** + * Updates result list in a result window. + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.updateResult = function () + { + var totalPages = this.engine.totalPages$(); + var resultslot = $('.oktavia_searchresult', this.node); + resultslot.empty(); + var self = this; + function clearCallback() + { + self.clearResult(); + } + var results = this.engine.getResult$(); + var searchInput = $('.oktavia_search', this.node); + var queryWord = searchInput.val() + for (var i = 0; i < results.length; i++) + { + var result = results[i]; + var url = this.getDocumentPath(result.url.slice(1)) + var entry = $('<div/>', { "class": "entry" }); + var link = $('<a/>', { "href": url + this.engine.getHighlight$() }).text(result.title); + link.bind('click', clearCallback); + entry.append($('<div/>', { "class": "title" }).append(link)); + entry.append($('<div/>', { "class": "url" }).text(url)); + entry.append($('<div/>', { "class": "resultcontent" }).html(result.content)); + resultslot.append(entry); + } + this.updatePageList(); + }; + + /** + * Searchs again by using proposal search words. + * @param {string} option Proposal search words + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.searchProposal = function (option) + { + $('.oktavia_search', this.node).val(option); + this.search(); + }; + + /** + * Shows proposals when no result. + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.updateProposal = function () + { + var nav = $('.oktavia_searchresult_nav', this.node); + var resultslot = $('.oktavia_searchresult', this.node); + nav.empty(); + resultslot.empty(); + var proposals = this.engine.getProposals$(); + var self = this; + function createCallback(option) + { + return function () + { + self.searchProposal(option); + }; + } + for (var i = 0; i < proposals.length; i++) + { + var proposal = proposals[i]; + var listitem = $('<div/>', {"class": "proposal"}); + listitem.append('<span>Search with: </span>'); + var option = $('<span/>', {"class": "option"}); + option.html(proposal.label); + option.bind('click', createCallback(proposal.options)); + listitem.append(option); + listitem.append('<span> → ' + proposal.count + ' results.</span>'); + resultslot.append(listitem); + } + }; + + /** + * Performs search and shows results. + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.search = function () + { + if (!this.initialized) + { + this.reserveSearch = true; + return; + } + var searchInput = $('.oktavia_search', this.node); + var queryWord = searchInput.val(); + searchInput.blur(); + var self = this; + this.engine.search$SF$IIV$(queryWord, function (total, pages) + { + $('.oktavia_searchresult_box', self.node).fadeIn(); + var summaryNode = $('.oktavia_searchresult_summary', self.node); + if (total === 0) + { + summaryNode.text("No result."); + self.updateProposal(); + } + else + { + summaryNode.text(total + ' results.'); + self.updateResult(); + } + }); + }; + + /** + * Converts file path in index. + * @param {string} filePath Source filepath + * @returns {string} Result filepath + * @memberOf SearchView.prototype + * @method + */ + SearchView.prototype.getDocumentPath = function (filePath) + { + var resultFilePath; + if (filePath.charAt(0) === '/') + { + resultFilePath = filePath; + } + else + { + var elements = filePath.split(/\//g); + var result = this.documentRoot.slice(); + for (var i = 0; i < elements.length; i++) + { + var element = elements[i]; + switch (element) + { + case '.': + break; + case '..': + result = result.slice(0, -1); + break; + default: + result.push(element); + break; + } + } + resultFilePath = result.join('/'); + } + return resultFilePath; + }; + + /** + * Hides all result windows. + * @function + */ + function eraseResultWindow() + { + $('.oktavia_searchresult_box:visible').hide(); + } + + /** + * jQuery plug-in to create search form and window. + * It can receive options from data attributes or an <tt>option</tt> parameter. + * @param {object} [option] Option + * @param {string} [option.index='search/searchindex.js'] Index file path. + * @param {string} [option.documentRoot='.'] Document root folder. + * @param {string} [option.logo='true'] Show logo in result windows. <tt>'false'</tt> or <tt>'disable'</tt> or falsy value disable logo. + * @name oktaviaSearch + * @function + */ + jQuery.fn.oktaviaSearch = function (option) + { + var data = { + 'index': 'search/searchindex.js', + 'documentRoot': '.', + 'logo': 'true' + }; + if (window.DOCUMENTATION_OPTIONS) // Sphinx + { + if (window.DOCUMENTATION_OPTIONS.URL_ROOT === '#') + { + data.documentRoot = ''; + } + else + { + data.documentRoot = window.DOCUMENTATION_OPTIONS.URL_ROOT; + } + } + var userData = this.data(); + var key; + for (key in userData) + { + if (userData.hasOwnProperty(key)) + { + data[key] = userData[key]; + } + } + for (key in option) + { + if (option.hasOwnProperty(key)) + { + data[key] = option[key]; + } + } + if (data.logo === 'false' || data.logo === 'disable' || !data.logo) + { + data.logo = false; + } + else + { + data.logo = true; + } + var view = new SearchView(this, data.documentRoot, data.index); + + var form = $('<form class="oktavia_form"><input class="oktavia_search" result="10" type="search" name="search" value="" placeholder="Search" /></form>'); + form.submit(function (event) { + event.stopPropagation(); + setTimeout(function () { + view.search(); + }, 10); + return false; + }); + this.append(form); + var resultForm = $([ + '<div class="oktavia_searchresult_box">', + '<div class="oktavia_close_search_box">×</div>', + '<div class="oktavia_searchresult_summary"></div>', + '<div class="oktavia_searchresult"></div>', + '<div class="oktavia_searchresult_nav"></div>', + '</div>' + ].join('')); + if (data.logo) + { + resultForm.append($('<span class="pr">Powered by <a href="http://oktavia.info"><img src="' + logosrc + '" width="86px" height="25px" alt="Oktavia"></img></a></span>')); + } + this.append(resultForm); + $('.oktavia_close_search_box', this.node).bind('click', function (event) { + view.clearResult(); + }); + + // Click outside of the result window, close it + resultForm.bind('click', function (event) { + event.stopPropagation(); + }); + }; + + /** + * Global initailization. + * It add some event handlers. + * @name initialize + * @function + */ + function initialize() + { + + function onClick() { + eraseResultWindow(); + return true; + } + function onKeyDown(event) + { + switch (event.keyCode) + { + case 191: // / : focus form + eraseResultWindow(); + var form = $('form.oktavia_form:first input.search'); + if ($(':focus', form).size() === 0) + { + form.focus(); + } + break; + case 74: // j : down + case 75: // k : up + case 72: // h : before page + case 76: // l : next page + case 13: // enter : select + var result = $('.oktavia_searchresult_box:visible:first'); + if (result.size() === 1) + { + switch (event.keyCode) + { + case 74: // j : down + console.log('down'); + break; + case 75: // k : up + console.log('up'); + break; + case 72: // h : before page + console.log('before'); + break; + case 76: // l : next page + console.log('next'); + break; + case 13: // enter : select + console.log('select'); + break; + } + } + break; + } + return true; + } + var version = $.fn.jquery.split(/\./g); + var major = Number(version[0]); + var minor = Number(version[1]); + if (major === 1 && minor < 7) + { + $(document).live('click', onClick); + $(document).live('keydown', onKeyDown); + } + else + { + $(document).on('click', onClick); + $(document).on('keydown', onKeyDown); + } + } + + var logosrc = "data:image/jpeg;base64, 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"; + initialize(); +})(jQuery); + +jQuery(document).ready(function () { + var form = jQuery('#oktavia_search_form'); + if (form.size() > 0) + { + form.oktaviaSearch(); + } +}); diff --git a/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-search.js b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-search.js new file mode 100644 index 000000000..fce9732a7 --- /dev/null +++ b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/oktavia-search.js @@ -0,0 +1,6795 @@ +// generatedy by JSX compiler 0.9.24 (2013-04-05 13:45:00 +0900; 1b229cc6a411f674f0f7cf7a79b7a8b3f8eb7414) +var JSX = {}; +(function (JSX) { +/** + * copies the implementations from source interface to target + */ +function $__jsx_merge_interface(target, source) { + for (var k in source.prototype) + if (source.prototype.hasOwnProperty(k)) + target.prototype[k] = source.prototype[k]; +} + +/** + * defers the initialization of the property + */ +function $__jsx_lazy_init(obj, prop, func) { + function reset(obj, prop, value) { + delete obj[prop]; + obj[prop] = value; + return value; + } + + Object.defineProperty(obj, prop, { + get: function () { + return reset(obj, prop, func()); + }, + set: function (v) { + reset(obj, prop, v); + }, + enumerable: true, + configurable: true + }); +} + +/** + * sideeffect().a /= b + */ +function $__jsx_div_assign(obj, prop, divisor) { + return obj[prop] = (obj[prop] / divisor) | 0; +} + +/* + * global functions, renamed to avoid conflict with local variable names + */ +var $__jsx_parseInt = parseInt; +var $__jsx_parseFloat = parseFloat; +var $__jsx_isNaN = isNaN; +var $__jsx_isFinite = isFinite; + +var $__jsx_encodeURIComponent = encodeURIComponent; +var $__jsx_decodeURIComponent = decodeURIComponent; +var $__jsx_encodeURI = encodeURI; +var $__jsx_decodeURI = decodeURI; + +var $__jsx_ObjectToString = Object.prototype.toString; +var $__jsx_ObjectHasOwnProperty = Object.prototype.hasOwnProperty; + +/* + * profiler object, initialized afterwards + */ +function $__jsx_profiler() { +} + +/* + * public interface to JSX code + */ +JSX.require = function (path) { + var m = $__jsx_classMap[path]; + return m !== undefined ? m : null; +}; + +JSX.profilerIsRunning = function () { + return $__jsx_profiler.getResults != null; +}; + +JSX.getProfileResults = function () { + return ($__jsx_profiler.getResults || function () { return {}; })(); +}; + +JSX.postProfileResults = function (url, cb) { + if ($__jsx_profiler.postResults == null) + throw new Error("profiler has not been turned on"); + return $__jsx_profiler.postResults(url, cb); +}; + +JSX.resetProfileResults = function () { + if ($__jsx_profiler.resetResults == null) + throw new Error("profiler has not been turned on"); + return $__jsx_profiler.resetResults(); +}; +JSX.DEBUG = false; +/** + * class _Result extends Object + * @constructor + */ +function _Result() { +} + +/** + * @constructor + * @param {!string} title + * @param {!string} url + * @param {!string} content + * @param {!number} score + */ +function _Result$SSSI(title, url, content, score) { + this.title = title; + this.url = url; + this.content = content; + this.score = score; +}; + +_Result$SSSI.prototype = new _Result; + +/** + * class _Proposal extends Object + * @constructor + */ +function _Proposal() { +} + +/** + * @constructor + * @param {!string} options + * @param {!string} label + * @param {!number} count + */ +function _Proposal$SSI(options, label, count) { + this.options = options; + this.label = label; + this.count = count; +}; + +_Proposal$SSI.prototype = new _Proposal; + +/** + * class OktaviaSearch extends Object + * @constructor + */ +function OktaviaSearch() { +} + +/** + * @constructor + * @param {!number} entriesPerPage + */ +function OktaviaSearch$I(entriesPerPage) { + this._queries = null; + this._highlight = ""; + this._result = null; + this._proposals = null; + this._currentFolderDepth = 0; + this._oktavia = new Oktavia$(); + this._entriesPerPage = entriesPerPage; + this._currentPage = 1; + this._queryString = null; + this._callback = null; + OktaviaSearch._instance = this; +}; + +OktaviaSearch$I.prototype = new OktaviaSearch; + +/** + * @param {Stemmer} stemmer + */ +OktaviaSearch.setStemmer$LStemmer$ = function (stemmer) { + /** @type {Oktavia} */ + var this$0; + if (OktaviaSearch._instance) { + this$0 = OktaviaSearch._instance._oktavia; + this$0._stemmer = stemmer; + } else { + OktaviaSearch._stemmer = stemmer; + } +}; + +var OktaviaSearch$setStemmer$LStemmer$ = OktaviaSearch.setStemmer$LStemmer$; + +/** + * @param {!string} index + */ +OktaviaSearch.prototype.loadIndex$S = function (index) { + /** @type {Oktavia} */ + var this$0; + /** @type {Stemmer} */ + var stemmer$0; + if (OktaviaSearch._stemmer) { + this$0 = this._oktavia; + stemmer$0 = OktaviaSearch._stemmer; + this$0._stemmer = stemmer$0; + } + this._oktavia.load$S(Binary$base64decode$S(index)); + if (this._queryString) { + this.search$SF$IIV$(this._queryString, this._callback); + this._queryString = null; + this._callback = null; + } +}; + +/** + * @param {!string} queryString + * @param {*} callback + */ +OktaviaSearch.prototype.search$SF$IIV$ = function (queryString, callback) { + /** @type {QueryStringParser} */ + var queryParser; + /** @type {SearchSummary} */ + var summary; + /** @type {Array.<undefined|SearchUnit>} */ + var _result$0; + if (this._oktavia) { + queryParser = ({queries: [ ]}); + this._queries = QueryStringParser$parse$LQueryStringParser$S(queryParser, queryString); + this._highlight = QueryStringParser$highlight$LQueryStringParser$(queryParser); + summary = this._oktavia.search$ALQuery$(this._queries); + if (SearchSummary$size$LSearchSummary$(summary) > 0) { + this._result = this._sortResult$LSearchSummary$(summary); + this._proposals = [ ]; + this._currentPage = 1; + } else { + this._result = [ ]; + if (this._queries.length > 1) { + this._proposals = SearchSummary$getProposal$LSearchSummary$(summary); + } else { + this._proposals = [ ]; + } + this._currentPage = 1; + } + callback((_result$0 = this._result).length, Math.ceil(_result$0.length / this._entriesPerPage)); + } else { + this._queryString = queryString; + this._callback = callback; + } +}; + +/** + * @return {!number} + */ +OktaviaSearch.prototype.resultSize$ = function () { + return (this._result.length | 0); +}; + +/** + * @return {!number} + */ +OktaviaSearch.prototype.totalPages$ = function () { + return (Math.ceil(this._result.length / this._entriesPerPage) | 0); +}; + +/** + * @return {!number} + */ +OktaviaSearch.prototype.currentPage$ = function () { + return this._currentPage; +}; + +/** + * @param {!number} page + */ +OktaviaSearch.prototype.setCurrentPage$I = function (page) { + this._currentPage = page; +}; + +/** + * @return {!boolean} + */ +OktaviaSearch.prototype.hasPrevPage$ = function () { + return this._currentPage !== 1; +}; + +/** + * @return {!boolean} + */ +OktaviaSearch.prototype.hasNextPage$ = function () { + return this._currentPage !== Math.ceil(this._result.length / this._entriesPerPage); +}; + +/** + * @return {Array.<undefined|!string>} + */ +OktaviaSearch.prototype.pageIndexes$ = function () { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var total; + /** @type {!number} */ + var i; + result = [ ]; + total = Math.ceil(this._result.length / this._entriesPerPage); + if (total < 10) { + for (i = 1; i <= total; i++) { + result.push(i + ""); + } + } else { + if (this._currentPage <= 5) { + for (i = 1; i <= 7; i++) { + result.push(i + ""); + } + result.push('...', total + ""); + } else { + if (total - 5 <= this._currentPage) { + result.push('1', '...'); + for (i = total - 8; i <= total; i++) { + result.push(i + ""); + } + } else { + result.push('1', '...'); + for (i = this._currentPage - 3; i <= this._currentPage + 3; i++) { + result.push(i + ""); + } + result.push('...', total + ""); + } + } + } + return result; +}; + +/** + * @return {Array.<undefined|_Result>} + */ +OktaviaSearch.prototype.getResult$ = function () { + /** @type {Style} */ + var style; + /** @type {!number} */ + var start; + /** @type {!number} */ + var last; + /** @type {Metadata} */ + var metadata; + /** @type {!number} */ + var num; + /** @type {Array.<undefined|_Result>} */ + var results; + /** @type {!number} */ + var i; + /** @type {SearchUnit} */ + var unit; + /** @type {Array.<undefined|!string>} */ + var info; + /** @type {!string} */ + var content; + /** @type {Array.<undefined|Position>} */ + var positions; + /** @type {!number} */ + var end; + /** @type {!boolean} */ + var split; + /** @type {!number} */ + var j; + /** @type {Position} */ + var pos; + /** @type {!string} */ + var text; + /** @type {Oktavia} */ + var this$0; + /** @type {!number} */ + var position$0; + /** @type {!number} */ + var _currentPage$0; + /** @type {!number} */ + var _entriesPerPage$0; + style = new Style$S('html'); + start = ((_currentPage$0 = this._currentPage) - 1) * (_entriesPerPage$0 = this._entriesPerPage); + last = Math.min(_currentPage$0 * _entriesPerPage$0, this._result.length); + this$0 = this._oktavia; + metadata = this$0._metadatas[this$0._metadataLabels[0]]; + num = 250; + results = [ ]; + for (i = start; i < last; i++) { + unit = this._result[i]; + info = metadata.getInformation$I(unit.id).split(Oktavia.eob); + content = metadata.getContent$I(unit.id); + start = 0; + positions = SearchUnit$getPositions$LSearchUnit$(unit); + if (content.indexOf(info[0]) === 1) { + content = content.slice(info[0].length + 2, content.length); + start += info[0].length + 2; + } + end = start + num; + split = false; + if (positions[0].position > end - positions[0].word.length) { + end = positions[0].position + Math.floor(num / 2); + split = true; + } + for (j = positions.length - 1; j > -1; j--) { + pos = positions[j]; + if (pos.position + pos.word.length < end) { + content = [ content.slice(0, pos.position - start), style.convert$S('<hit>*</hit>').replace('*', content.slice((position$0 = pos.position) - start, position$0 + pos.word.length - start)), content.slice(pos.position + pos.word.length - start, content.length) ].join(''); + } + } + if (split) { + text = [ content.slice(0, Math.floor(num / 2)) + ' ...', content.slice(- Math.floor(num / 2), end - start) ].join('<br/>'); + } else { + text = content.slice(0, end - start) + ' ...<br/>'; + } + text = text.replace(Oktavia.eob, ' ').replace(/(<br\/>)(<br\/>)+/, '<br/><br/>'); + results.push(({title: info[0], url: info[1], content: text, score: unit.score})); + } + return results; +}; + +/** + * @return {!string} + */ +OktaviaSearch.prototype.getHighlight$ = function () { + return this._highlight; +}; + +/** + * @return {Array.<undefined|_Proposal>} + */ +OktaviaSearch.prototype.getProposals$ = function () { + /** @type {Style} */ + var style; + /** @type {Array.<undefined|_Proposal>} */ + var results; + /** @type {!number} */ + var i; + /** @type {Proposal} */ + var proposal; + /** @type {Array.<undefined|!string>} */ + var label; + /** @type {Array.<undefined|!string>} */ + var option; + /** @type {!number} */ + var j; + style = new Style$S('html'); + results = [ ]; + if (this._queries.length > 1) { + for (i = 0; i < this._proposals.length; i++) { + proposal = this._proposals[i]; + if (proposal.expect > 0) { + label = [ ]; + option = [ ]; + for (j = 0; j < this._queries.length; j++) { + if (j !== proposal.omit) { + label.push(style.convert$S('<hit>' + this._queries[j].toString() + '</hit>')); + option.push(this._queries[j].toString()); + } else { + label.push(style.convert$S('<del>' + this._queries[j].toString() + '</del>')); + } + } + results.push(({options: option.join(' '), label: label.join(' '), count: proposal.expect})); + } + } + } + return results; +}; + +/** + * @param {SearchSummary} summary + * @return {Array.<undefined|SearchUnit>} + */ +OktaviaSearch.prototype._sortResult$LSearchSummary$ = function (summary) { + /** @type {!number} */ + var i; + /** @type {!number} */ + var score; + /** @type {SearchUnit} */ + var unit; + /** @type {!string} */ + var pos; + /** @type {Position} */ + var position; + for (i = 0; i < summary.result.units.length; i++) { + score = 0; + unit = summary.result.units[i]; + for (pos in unit.positions) { + position = unit.positions[pos]; + if (this._oktavia.wordPositionType$I(position.position)) { + score += 10; + } else { + score += 1; + } + if (! position.stemmed) { + score += 2; + } + } + unit.score = (score | 0); + } + return SearchSummary$getSortedResult$LSearchSummary$(summary); +}; + +/** + * class _Main extends Object + * @constructor + */ +function _Main() { +} + +/** + * @constructor + */ +function _Main$() { +}; + +_Main$.prototype = new _Main; + +/** + * @param {Array.<undefined|!string>} args + */ +_Main.main$AS = function (args) { +}; + +var _Main$main$AS = _Main.main$AS; + +/** + * class Oktavia extends Object + * @constructor + */ +function Oktavia() { +} + +/** + * @constructor + */ +function Oktavia$() { + /** @type {Array.<undefined|!string>} */ + var _utf162compressCode$0; + this._compressCode2utf16 = null; + this._fmindex = new FMIndex$(); + this._metadatas = ({ }); + this._metadataLabels = [ ]; + this._stemmer = null; + this._stemmingResult = ({ }); + _utf162compressCode$0 = this._utf162compressCode = [ Oktavia.eof, Oktavia.eob, Oktavia.unknown ]; + _utf162compressCode$0.length = 65536; + this._compressCode2utf16 = [ Oktavia.eof, Oktavia.eob, Oktavia.unknown ]; +}; + +Oktavia$.prototype = new Oktavia; + +/** + * @param {Stemmer} stemmer + */ +Oktavia.prototype.setStemmer$LStemmer$ = function (stemmer) { + this._stemmer = stemmer; +}; + +/** + * @return {Metadata} + */ +Oktavia.prototype.getPrimaryMetadata$ = function () { + return this._metadatas[this._metadataLabels[0]]; +}; + +/** + * @param {!string} key + * @return {Section} + */ +Oktavia.prototype.addSection$S = function (key) { + /** @type {Section} */ + var section; + if (this._metadataLabels.indexOf(key) !== -1) { + throw new Error('Metadata name ' + key + ' is already exists'); + } + this._metadataLabels.push(key); + section = new Section$LOktavia$(this); + this._metadatas[key] = section; + return section; +}; + +/** + * @param {!string} key + * @return {Section} + */ +Oktavia.prototype.getSection$S = function (key) { + if (this._metadataLabels.indexOf(key) === -1) { + throw new Error('Metadata name ' + key + " does't exists"); + } + return this._metadatas[key]; +}; + +/** + * @param {!string} key + * @return {Splitter} + */ +Oktavia.prototype.addSplitter$S = function (key) { + /** @type {Splitter} */ + var splitter; + if (this._metadataLabels.indexOf(key) !== -1) { + throw new Error('Metadata name ' + key + ' is already exists'); + } + this._metadataLabels.push(key); + splitter = new Splitter$LOktavia$(this); + this._metadatas[key] = splitter; + return splitter; +}; + +/** + * @param {!string} key + * @return {Splitter} + */ +Oktavia.prototype.getSplitter$S = function (key) { + if (this._metadataLabels.indexOf(key) === -1) { + throw new Error('Metadata name ' + key + " does't exists"); + } + return this._metadatas[key]; +}; + +/** + * @param {!string} key + * @param {Array.<undefined|!string>} headers + * @return {Table} + */ +Oktavia.prototype.addTable$SAS = function (key, headers) { + /** @type {Table} */ + var table; + if (this._metadataLabels.indexOf(key) !== -1) { + throw new Error('Metadata name ' + key + ' is already exists'); + } + this._metadataLabels.push(key); + table = new Table$LOktavia$AS(this, headers); + this._metadatas[key] = table; + return table; +}; + +/** + * @param {!string} key + * @return {Table} + */ +Oktavia.prototype.getTable$S = function (key) { + if (this._metadataLabels.indexOf(key) === -1) { + throw new Error('Metadata name ' + key + " does't exists"); + } + return this._metadatas[key]; +}; + +/** + * @param {!string} key + * @return {Block} + */ +Oktavia.prototype.addBlock$S = function (key) { + /** @type {Block} */ + var block; + if (this._metadataLabels.indexOf(key) !== -1) { + throw new Error('Metadata name ' + key + ' is already exists'); + } + this._metadataLabels.push(key); + block = new Block$LOktavia$(this); + this._metadatas[key] = block; + return block; +}; + +/** + * @param {!string} key + * @return {Block} + */ +Oktavia.prototype.getBlock$S = function (key) { + if (this._metadataLabels.indexOf(key) === -1) { + throw new Error('Metadata name ' + key + " does't exists"); + } + return this._metadatas[key]; +}; + +/** + */ +Oktavia.prototype.addEndOfBlock$ = function () { + this._fmindex.push$S(Oktavia.eob); +}; + +/** + * @param {!string} words + */ +Oktavia.prototype.addWord$S = function (words) { + /** @type {Array.<undefined|!string>} */ + var str; + /** @type {!number} */ + var i; + /** @type {!number} */ + var charCode; + /** @type {undefined|!string} */ + var newCharCode; + str = [ ]; + str.length = words.length; + for (i = 0; i < words.length; i++) { + charCode = words.charCodeAt(i); + newCharCode = this._utf162compressCode[charCode]; + if (newCharCode == null) { + newCharCode = String.fromCharCode(this._compressCode2utf16.length); + this._utf162compressCode[charCode] = newCharCode; + this._compressCode2utf16.push(String.fromCharCode(charCode)); + } + str.push(newCharCode); + } + this._fmindex.push$S(str.join('')); +}; + +/** + * @param {!string} words + * @param {!boolean} stemming + */ +Oktavia.prototype.addWord$SB = function (words, stemming) { + /** @type {Array.<undefined|!string>} */ + var wordList; + /** @type {!number} */ + var i; + /** @type {undefined|!string} */ + var originalWord; + /** @type {!string} */ + var smallWord; + /** @type {undefined|!string} */ + var registerWord; + /** @type {!string} */ + var baseWord; + /** @type {!string} */ + var compressedCodeWord; + /** @type {Array.<undefined|!string>} */ + var stemmedList; + this.addWord$S(words); + wordList = words.split(/\s+/); + for (i = 0; i < wordList.length; i++) { + originalWord = wordList[i]; + smallWord = originalWord.slice(0, 1).toLowerCase() + originalWord.slice(1); + registerWord = null; + if (stemming && this._stemmer) { + baseWord = this._stemmer.stemWord$S(originalWord.toLowerCase()); + if (originalWord.indexOf(baseWord) === -1) { + registerWord = baseWord; + } + } else { + if (originalWord != smallWord) { + registerWord = smallWord; + } + } + if (registerWord) { + compressedCodeWord = this._convertToCompressionCode$S(originalWord); + stemmedList = this._stemmingResult[registerWord]; + if (! stemmedList) { + stemmedList = [ compressedCodeWord ]; + this._stemmingResult[registerWord] = stemmedList; + } else { + if (stemmedList.indexOf(compressedCodeWord) === -1) { + stemmedList.push(compressedCodeWord); + } + } + } + } +}; + +/** + * @param {!string} keyword + * @return {!string} + */ +Oktavia.prototype._convertToCompressionCode$S = function (keyword) { + /** @type {Array.<undefined|!string>} */ + var resultChars; + /** @type {!number} */ + var i; + /** @type {undefined|!string} */ + var chr; + resultChars = [ ]; + for (i = 0; i < keyword.length; i++) { + chr = this._utf162compressCode[keyword.charCodeAt(i)]; + if (chr == null) { + resultChars.push(Oktavia.unknown); + } else { + resultChars.push(chr); + } + } + return resultChars.join(''); +}; + +/** + * @param {!string} keyword + * @param {!boolean} stemming + * @return {Array.<undefined|!number>} + */ +Oktavia.prototype.rawSearch$SB = function (keyword, stemming) { + /** @type {Array.<undefined|!number>} */ + var result; + /** @type {!string} */ + var baseWord; + /** @type {Array.<undefined|!string>} */ + var stemmedList; + /** @type {!number} */ + var i; + /** @type {undefined|!string} */ + var word; + if (stemming) { + result = [ ]; + if (this._stemmer) { + baseWord = this._stemmer.stemWord$S(keyword.toLowerCase()); + stemmedList = this._stemmingResult[baseWord]; + if (stemmedList) { + for (i = 0; i < stemmedList.length; i++) { + word = stemmedList[i]; + result = result.concat(this._fmindex.search$S(word)); + } + } + } + } else { + result = this._fmindex.search$S(this._convertToCompressionCode$S(keyword)); + } + return result; +}; + +/** + * @param {Array.<undefined|Query>} queries + * @return {SearchSummary} + */ +Oktavia.prototype.search$ALQuery$ = function (queries) { + /** @type {SearchSummary} */ + var summary; + /** @type {!number} */ + var i; + /** @type {SingleResult} */ + var result$0; + summary = ({sourceResults: [ ], result: null, oktavia: this}); + for (i = 0; i < queries.length; i++) { + result$0 = this._searchQuery$LQuery$(queries[i]); + summary.sourceResults.push(result$0); + } + summary.result = SearchSummary$mergeResult$LSearchSummary$ALSingleResult$(summary, summary.sourceResults); + return summary; +}; + +/** + * @param {Query} query + * @return {SingleResult} + */ +Oktavia.prototype._searchQuery$LQuery$ = function (query) { + /** @type {SingleResult} */ + var result; + /** @type {Array.<undefined|!number>} */ + var positions; + result = new SingleResult$SBB(query.word, query.or, query.not); + if (query.raw) { + positions = this.rawSearch$SB(query.word, false); + } else { + positions = this.rawSearch$SB(query.word, false).concat(this.rawSearch$SB(query.word, true)); + } + this._metadatas[this._metadataLabels[0]].grouping$LSingleResult$AISB(result, positions, query.word, ! query.raw); + return result; +}; + +/** + */ +Oktavia.prototype.build$ = function () { + this.build$IB(5, false); +}; + +/** + * @param {!number} cacheDensity + * @param {!boolean} verbose + */ +Oktavia.prototype.build$IB = function (cacheDensity, verbose) { + /** @type {!string} */ + var key; + /** @type {!number} */ + var cacheRange; + /** @type {!number} */ + var maxChar; + for (key in this._metadatas) { + this._metadatas[key]._build$(); + } + cacheRange = Math.round(Math.max(1, 100 / Math.min(100, Math.max(0.01, cacheDensity)))); + maxChar = this._compressCode2utf16.length; + this._fmindex.build$SIIB(Oktavia.eof, maxChar, cacheRange, verbose); +}; + +/** + * @return {!string} + */ +Oktavia.prototype.dump$ = function () { + return this.dump$B(false); +}; + +/** + * @param {!boolean} verbose + * @return {!string} + */ +Oktavia.prototype.dump$B = function (verbose) { + /** @type {!string} */ + var header; + /** @type {!string} */ + var fmdata; + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + /** @type {CompressionReport} */ + var report; + /** @type {undefined|!string} */ + var name; + /** @type {!string} */ + var data; + header = Binary$dumpString$SLCompressionReport$("oktavia-01", null).slice(1); + if (verbose) { + console.log("Source text size: " + (this._fmindex.size$() * 2 + "") + ' bytes'); + } + fmdata = this._fmindex.dump$B(verbose); + result = [ header, fmdata ]; + result.push(Binary$dump16bitNumber$I(this._compressCode2utf16.length)); + for (i = 3; i < this._compressCode2utf16.length; i++) { + result.push(this._compressCode2utf16[i]); + } + if (verbose) { + console.log('Char Code Map: ' + (this._compressCode2utf16.length * 2 - 2 + "") + ' bytes'); + } + report = ({source: 0, result: 0}); + result.push(Binary$dumpStringListMap$HASLCompressionReport$(this._stemmingResult, report)); + if (verbose) { + console.log('Stemmed Word Table: ' + (result[result.length - 1].length + "") + ' bytes (' + (Math.round(report.result * 100.0 / report.source) + "") + '%)'); + } + result.push(Binary$dump16bitNumber$I(this._metadataLabels.length)); + for (i = 0; i < this._metadataLabels.length; i++) { + report = ({source: 0, result: 0}); + name = this._metadataLabels[i]; + data = this._metadatas[name]._dump$LCompressionReport$(report); + result.push(Binary$dumpString$SLCompressionReport$(name, report), data); + if (verbose) { + console.log('Meta Data ' + name + ': ' + (data.length * 2 + "") + ' bytes (' + (Math.round(report.result * 100.0 / report.source) + "") + '%)'); + } + } + return result.join(''); +}; + +/** + * @param {!string} data + */ +Oktavia.prototype.load$S = function (data) { + /** @type {!string} */ + var header; + /** @type {!number} */ + var offset; + /** @type {!number} */ + var charCodeCount; + /** @type {!number} */ + var i; + /** @type {!number} */ + var charCode; + /** @type {LoadedStringListMapResult} */ + var stemmedWords; + /** @type {!number} */ + var metadataCount; + /** @type {LoadedStringResult} */ + var nameResult; + /** @type {!string} */ + var name; + /** @type {!number} */ + var type; + header = Binary$dumpString$SLCompressionReport$("oktavia-01", null).slice(1); + if (data.slice(0, 5) !== header) { + throw new Error('Invalid data file'); + } + this._metadatas = ({ }); + this._metadataLabels = [ ]; + offset = 5; + offset = this._fmindex.load$SI(data, offset); + charCodeCount = Binary$load16bitNumber$SI(data, offset++); + this._compressCode2utf16 = [ Oktavia.eof, Oktavia.eob, Oktavia.unknown ]; + this._utf162compressCode = [ Oktavia.eof, Oktavia.eob, Oktavia.unknown ]; + for (i = 3; i < charCodeCount; i++) { + charCode = Binary$load16bitNumber$SI(data, offset++); + this._compressCode2utf16.push(String.fromCharCode(charCode)); + this._utf162compressCode[charCode] = String.fromCharCode(i); + } + stemmedWords = Binary$loadStringListMap$SI(data, offset); + this._stemmingResult = stemmedWords.result; + offset = stemmedWords.offset; + metadataCount = Binary$load16bitNumber$SI(data, offset++); + for (i = 0; i < metadataCount; i++) { + nameResult = Binary$loadString$SI(data, offset); + name = nameResult.result; + offset = nameResult.offset; + type = Binary$load16bitNumber$SI(data, offset++); + switch (type) { + case 0: + offset = Section$_load$LOktavia$SSI(this, name, data, offset); + break; + case 1: + offset = Splitter$_load$LOktavia$SSI(this, name, data, offset); + break; + case 2: + offset = Table$_load$LOktavia$SSI(this, name, data, offset); + break; + case 3: + offset = Block$_load$LOktavia$SSI(this, name, data, offset); + break; + } + } +}; + +/** + * @return {!number} + */ +Oktavia.prototype.contentSize$ = function () { + /** @type {FMIndex} */ + var this$0; + this$0 = this._fmindex; + return this$0._substr.length; +}; + +/** + * @param {!number} position + * @return {!number} + */ +Oktavia.prototype.wordPositionType$I = function (position) { + /** @type {!number} */ + var result; + /** @type {!string} */ + var ahead; + result = 0; + if (position === 0) { + result = 4; + } else { + ahead = this._fmindex.getSubstring$II(position - 1, 1); + if (/\s/.test(ahead)) { + result = 2; + } else { + if (/\W/.test(ahead)) { + result = 1; + } else { + if (Oktavia.eob === ahead) { + result = 3; + } + } + } + } + return (result | 0); +}; + +/** + * @param {!number} position + * @param {!number} length + * @return {!string} + */ +Oktavia.prototype._getSubstring$II = function (position, length) { + /** @type {!string} */ + var result; + /** @type {Array.<undefined|!string>} */ + var str; + /** @type {!number} */ + var i; + result = this._fmindex.getSubstring$II(position, length); + str = [ ]; + for (i = 0; i < result.length; i++) { + str.push(this._compressCode2utf16[result.charCodeAt(i)]); + } + return str.join(''); +}; + +/** + * class Binary extends Object + * @constructor + */ +function Binary() { +} + +/** + * @constructor + */ +function Binary$() { +}; + +Binary$.prototype = new Binary; + +/** + * @param {!number} num + * @return {!string} + */ +Binary.dump32bitNumber$N = function (num) { + /** @type {Array.<undefined|!string>} */ + var result; + result = [ String.fromCharCode(Math.floor(num / 65536)) ]; + result.push(String.fromCharCode(num % 65536)); + return result.join(""); +}; + +var Binary$dump32bitNumber$N = Binary.dump32bitNumber$N; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {!number} + */ +Binary.load32bitNumber$SI = function (buffer, offset) { + /** @type {!number} */ + var result; + result = buffer.charCodeAt(offset) * 65536 + buffer.charCodeAt(offset + 1); + return result; +}; + +var Binary$load32bitNumber$SI = Binary.load32bitNumber$SI; + +/** + * @param {!number} num + * @return {!string} + */ +Binary.dump16bitNumber$I = function (num) { + return String.fromCharCode(num % 65536); +}; + +var Binary$dump16bitNumber$I = Binary.dump16bitNumber$I; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {!number} + */ +Binary.load16bitNumber$SI = function (buffer, offset) { + return (buffer.charCodeAt(offset) | 0); +}; + +var Binary$load16bitNumber$SI = Binary.load16bitNumber$SI; + +/** + * @param {!string} str + * @return {!string} + */ +Binary.dumpString$S = function (str) { + return Binary$dumpString$SLCompressionReport$(str, null); +}; + +var Binary$dumpString$S = Binary.dumpString$S; + +/** + * @param {!string} str + * @param {CompressionReport} report + * @return {!string} + */ +Binary.dumpString$SLCompressionReport$ = function (str, report) { + /** @type {!number} */ + var length; + /** @type {!boolean} */ + var compress; + /** @type {Array.<undefined|!number>} */ + var charCodes; + /** @type {!number} */ + var i; + /** @type {!number} */ + var charCode; + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {undefined|!number} */ + var bytes; + if (str.length > 32768) { + str = str.slice(0, 32768); + } + length = str.length; + compress = true; + charCodes = [ ]; + for (i = 0; i < length; i++) { + charCode = str.charCodeAt(i); + if (charCode > 255) { + compress = false; + break; + } + charCodes.push(charCode); + } + if (compress) { + result = [ Binary$dump16bitNumber$I(length + 32768) ]; + for (i = 0; i < length; i += 2) { + bytes = charCodes[i]; + if (i !== length - 1) { + bytes += charCodes[i + 1] << 8; + } + result.push(String.fromCharCode(bytes % 65536)); + } + if (report) { + CompressionReport$add$LCompressionReport$II(report, length, Math.ceil(length / 2)); + } + } else { + result = [ Binary$dump16bitNumber$I(length), str ]; + if (report) { + CompressionReport$add$LCompressionReport$II(report, length, length); + } + } + return result.join(''); +}; + +var Binary$dumpString$SLCompressionReport$ = Binary.dumpString$SLCompressionReport$; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {LoadedStringResult} + */ +Binary.loadString$SI = function (buffer, offset) { + return new LoadedStringResult$SI(buffer, offset); +}; + +var Binary$loadString$SI = Binary.loadString$SI; + +/** + * @param {Array.<undefined|!string>} strList + * @return {!string} + */ +Binary.dumpStringList$AS = function (strList) { + return Binary$dumpStringList$ASLCompressionReport$(strList, null); +}; + +var Binary$dumpStringList$AS = Binary.dumpStringList$AS; + +/** + * @param {Array.<undefined|!string>} strList + * @param {CompressionReport} report + * @return {!string} + */ +Binary.dumpStringList$ASLCompressionReport$ = function (strList, report) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + result = [ Binary$dump32bitNumber$N(strList.length) ]; + for (i = 0; i < strList.length; i++) { + result.push(Binary$dumpString$SLCompressionReport$(strList[i], report)); + } + return result.join(''); +}; + +var Binary$dumpStringList$ASLCompressionReport$ = Binary.dumpStringList$ASLCompressionReport$; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {LoadedStringListResult} + */ +Binary.loadStringList$SI = function (buffer, offset) { + return new LoadedStringListResult$SI(buffer, offset); +}; + +var Binary$loadStringList$SI = Binary.loadStringList$SI; + +/** + * @param {Object.<string, undefined|Array.<undefined|!string>>} strMap + * @return {!string} + */ +Binary.dumpStringListMap$HAS = function (strMap) { + return Binary$dumpStringListMap$HASLCompressionReport$(strMap, null); +}; + +var Binary$dumpStringListMap$HAS = Binary.dumpStringListMap$HAS; + +/** + * @param {Object.<string, undefined|Array.<undefined|!string>>} strMap + * @param {CompressionReport} report + * @return {!string} + */ +Binary.dumpStringListMap$HASLCompressionReport$ = function (strMap, report) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var counter; + /** @type {!string} */ + var key; + result = [ ]; + counter = 0; + for (key in strMap) { + result.push(Binary$dumpString$SLCompressionReport$(key, report)); + result.push(Binary$dumpStringList$ASLCompressionReport$(strMap[key], report)); + counter++; + } + return Binary$dump32bitNumber$N(counter) + result.join(''); +}; + +var Binary$dumpStringListMap$HASLCompressionReport$ = Binary.dumpStringListMap$HASLCompressionReport$; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {LoadedStringListMapResult} + */ +Binary.loadStringListMap$SI = function (buffer, offset) { + return new LoadedStringListMapResult$SI(buffer, offset); +}; + +var Binary$loadStringListMap$SI = Binary.loadStringListMap$SI; + +/** + * @param {Array.<undefined|!number>} array + * @return {!string} + */ +Binary.dump32bitNumberList$AN = function (array) { + return Binary$dump32bitNumberList$ANLCompressionReport$(array, null); +}; + +var Binary$dump32bitNumberList$AN = Binary.dump32bitNumberList$AN; + +/** + * @param {Array.<undefined|!number>} array + * @param {CompressionReport} report + * @return {!string} + */ +Binary.dump32bitNumberList$ANLCompressionReport$ = function (array, report) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var index; + /** @type {!number} */ + var inputLength; + /** @type {!number} */ + var length; + /** @type {!string} */ + var resultString; + /** @type {!number} */ + var value1$0; + /** @type {!number} */ + var value2$0; + result = [ Binary$dump32bitNumber$N(array.length) ]; + index = 0; + inputLength = array.length; + while (index < inputLength) { + if (array[index] == 0) { + length = Binary$_countZero$ANI(array, index); + result.push(Binary$_zeroBlock$I(length)); + index += length; + } else { + if (Binary$_shouldZebraCode$ANI(array, index)) { + result.push(Binary$_createZebraCode$ANI(array, index)); + value1$0 = array.length; + value2$0 = index + 15; + index = (value1$0 <= value2$0 ? value1$0 : value2$0); + } else { + length = Binary$_searchDoubleZero$ANI(array, index); + result.push(Binary$_nonZeroBlock$ANII(array, index, length)); + if (length === 0) { + throw new Error(''); + } + index += length; + } + } + } + resultString = result.join(''); + if (report) { + CompressionReport$add$LCompressionReport$II(report, array.length * 2 + 2, resultString.length); + } + return resultString; +}; + +var Binary$dump32bitNumberList$ANLCompressionReport$ = Binary.dump32bitNumberList$ANLCompressionReport$; + +/** + * @param {!string} buffer + * @param {!number} offset + * @return {LoadedNumberListResult} + */ +Binary.load32bitNumberList$SI = function (buffer, offset) { + return new LoadedNumberListResult$SI(buffer, offset); +}; + +var Binary$load32bitNumberList$SI = Binary.load32bitNumberList$SI; + +/** + * @param {Array.<undefined|!number>} array + * @param {!number} offset + * @return {!number} + */ +Binary._countZero$ANI = function (array, offset) { + /** @type {!number} */ + var i; + /** @type {!number} */ + var array$len$0; + for ((i = offset, array$len$0 = array.length); i < array$len$0; i++) { + if (array[i] != 0) { + return (i - offset | 0); + } + } + return (array.length - offset | 0); +}; + +var Binary$_countZero$ANI = Binary._countZero$ANI; + +/** + * @param {!number} length + * @return {!string} + */ +Binary._zeroBlock$I = function (length) { + /** @type {Array.<undefined|!string>} */ + var result; + result = [ ]; + while (length > 0) { + if (length > 16384) { + result.push(Binary$dump16bitNumber$I(16383)); + length -= 16384; + } else { + result.push(Binary$dump16bitNumber$I(length - 1)); + length = 0; + } + } + return result.join(''); +}; + +var Binary$_zeroBlock$I = Binary._zeroBlock$I; + +/** + * @param {Array.<undefined|!number>} array + * @param {!number} offset + * @return {!boolean} + */ +Binary._shouldZebraCode$ANI = function (array, offset) { + /** @type {!number} */ + var change; + /** @type {!boolean} */ + var isLastZero; + /** @type {!number} */ + var i; + if (array.length - offset < 16) { + return true; + } + change = 0; + isLastZero = false; + for (i = offset; i < offset + 15; i++) { + if (array[i] == 0) { + if (! isLastZero) { + isLastZero = true; + change++; + } + } else { + if (isLastZero) { + isLastZero = false; + change++; + } + } + } + return change > 2; +}; + +var Binary$_shouldZebraCode$ANI = Binary._shouldZebraCode$ANI; + +/** + * @param {Array.<undefined|!number>} array + * @param {!number} offset + * @return {!number} + */ +Binary._searchDoubleZero$ANI = function (array, offset) { + /** @type {!boolean} */ + var isLastZero; + /** @type {!number} */ + var i; + /** @type {!number} */ + var array$len$0; + isLastZero = false; + for ((i = offset, array$len$0 = array.length); i < array$len$0; i++) { + if (array[i] == 0) { + if (isLastZero) { + return (i - offset - 1 | 0); + } + isLastZero = true; + } else { + isLastZero = false; + } + } + return (array.length - offset | 0); +}; + +var Binary$_searchDoubleZero$ANI = Binary._searchDoubleZero$ANI; + +/** + * @param {Array.<undefined|!number>} array + * @param {!number} offset + * @param {!number} length + * @return {!string} + */ +Binary._nonZeroBlock$ANII = function (array, offset, length) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var blockLength; + /** @type {!number} */ + var i; + result = [ ]; + while (length > 0) { + if (length > 16384) { + blockLength = 16384; + length -= 16384; + } else { + blockLength = length; + length = 0; + } + result.push(Binary$dump16bitNumber$I(blockLength - 1 + 0x4000)); + for (i = offset; i < offset + blockLength; i++) { + result.push(Binary$dump32bitNumber$N(array[i])); + } + offset += blockLength; + } + return result.join(''); +}; + +var Binary$_nonZeroBlock$ANII = Binary._nonZeroBlock$ANII; + +/** + * @param {Array.<undefined|!number>} array + * @param {!number} offset + * @return {!string} + */ +Binary._createZebraCode$ANI = function (array, offset) { + /** @type {!number} */ + var last; + /** @type {!number} */ + var code; + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + /** @type {!number} */ + var value1$0; + /** @type {!number} */ + var value2$0; + value1$0 = offset + 15; + value2$0 = array.length; + last = (value1$0 <= value2$0 ? value1$0 : value2$0); + code = 0x8000; + result = [ ]; + for (i = offset; i < last; i++) { + if (array[i] != 0) { + result.push(Binary$dump32bitNumber$N(array[i])); + code = code + (0x1 << i - offset); + } + } + return String.fromCharCode(code) + result.join(''); +}; + +var Binary$_createZebraCode$ANI = Binary._createZebraCode$ANI; + +/** + * @param {!string} str + * @return {!string} + */ +Binary.base64encode$S = function (str) { + /** @type {Array.<undefined|!string>} */ + var out; + /** @type {Array.<undefined|!number>} */ + var source; + /** @type {!number} */ + var i; + /** @type {!number} */ + var code; + /** @type {!number} */ + var len; + /** @type {!number} */ + var c1; + /** @type {undefined|!number} */ + var c2; + /** @type {undefined|!number} */ + var c3; + out = [ ]; + source = [ ]; + for (i = 0; i < str.length; i++) { + code = str.charCodeAt(i); + source.push(code & 0x00ff, code >>> 8); + } + len = str.length * 2; + i = 0; + while (i < len) { + c1 = source[i++] & 0xff; + if (i === len) { + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(c1 >> 2)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt((c1 & 0x3) << 4)); + out.push("=="); + break; + } + c2 = source[i++]; + if (i === len) { + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(c1 >> 2)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt((c1 & 0x3) << 4 | (c2 & 0xF0) >> 4)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt((c2 & 0xF) << 2)); + out.push("="); + break; + } + c3 = source[i++]; + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(c1 >> 2)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt((c1 & 0x3) << 4 | (c2 & 0xF0) >> 4)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt((c2 & 0xF) << 2 | (c3 & 0xC0) >> 6)); + out.push("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(c3 & 0x3F)); + } + return out.join(''); +}; + +var Binary$base64encode$S = Binary.base64encode$S; + +/** + * @param {Array.<undefined|!number>} source + * @return {!string} + */ +Binary._mergeCharCode$AI = function (source) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + result = [ ]; + for (i = 0; i < source.length; i += 2) { + result.push(String.fromCharCode(source[i] + (source[i + 1] << 8))); + } + return result.join(''); +}; + +var Binary$_mergeCharCode$AI = Binary._mergeCharCode$AI; + +/** + * @param {!string} str + * @return {!string} + */ +Binary.base64decode$S = function (str) { + /** @type {!number} */ + var len; + /** @type {!number} */ + var i; + /** @type {Array.<undefined|!number>} */ + var out; + /** @type {undefined|!number} */ + var c1; + /** @type {undefined|!number} */ + var c2; + /** @type {!number} */ + var c3; + /** @type {!number} */ + var c4; + len = str.length; + i = 0; + out = [ ]; + while (i < len) { + do { + c1 = Binary._base64DecodeChars[str.charCodeAt(i++) & 0xff]; + } while (i < len && c1 == -1); + if (c1 == -1) { + break; + } + do { + c2 = Binary._base64DecodeChars[str.charCodeAt(i++) & 0xff]; + } while (i < len && c2 == -1); + if (c2 == -1) { + break; + } + out.push(c1 << 2 | (c2 & 0x30) >> 4); + do { + c3 = str.charCodeAt(i++) & 0xff; + if (c3 === 61) { + return Binary$_mergeCharCode$AI(out); + } + c3 = Binary._base64DecodeChars[c3]; + } while (i < len && c3 === -1); + if (c3 === -1) { + break; + } + out.push((c2 & 0XF) << 4 | (c3 & 0x3C) >> 2); + do { + c4 = str.charCodeAt(i++) & 0xff; + if (c4 === 61) { + return Binary$_mergeCharCode$AI(out); + } + c4 = (Binary._base64DecodeChars[c4] | 0); + } while (i < len && c4 === -1); + if (c4 === -1) { + break; + } + out.push((c3 & 0x03) << 6 | c4); + } + return Binary$_mergeCharCode$AI(out); +}; + +var Binary$base64decode$S = Binary.base64decode$S; + +/** + * class LoadedStringResult extends Object + * @constructor + */ +function LoadedStringResult() { +} + +/** + * @constructor + * @param {!string} data + * @param {!number} offset + */ +function LoadedStringResult$SI(data, offset) { + /** @type {!number} */ + var strLength; + /** @type {Array.<undefined|!string>} */ + var bytes; + /** @type {!number} */ + var i; + /** @type {!number} */ + var code; + /** @type {!number} */ + var offset$0; + this.result = ""; + this.offset = 0; + offset$0 = offset++; + strLength = data.charCodeAt(offset$0); + if (strLength > 32767) { + strLength = strLength - 32768; + bytes = [ ]; + for (i = 0; i < strLength; i += 2) { + code = data.charCodeAt(offset); + bytes.push(String.fromCharCode(code & 0x00ff)); + if (i !== strLength - 1) { + bytes.push(String.fromCharCode(code >>> 8)); + } + offset++; + } + this.result = bytes.join(''); + this.offset = offset; + } else { + this.result = data.slice(offset, offset + strLength); + this.offset = (offset + strLength | 0); + } +}; + +LoadedStringResult$SI.prototype = new LoadedStringResult; + +/** + * class LoadedStringListResult extends Object + * @constructor + */ +function LoadedStringListResult() { +} + +/** + * @constructor + * @param {!string} data + * @param {!number} offset + */ +function LoadedStringListResult$SI(data, offset) { + /** @type {!number} */ + var length; + /** @type {!number} */ + var i; + /** @type {!number} */ + var strLength; + /** @type {!string} */ + var resultStr; + /** @type {Array.<undefined|!string>} */ + var bytes; + /** @type {!number} */ + var j; + /** @type {!number} */ + var code; + /** @type {!number} */ + var result$0; + /** @type {!number} */ + var offset$0; + this.offset = 0; + this.result = [ ]; + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + length = result$0; + offset += 2; + for (i = 0; i < length; i++) { + offset$0 = offset++; + strLength = data.charCodeAt(offset$0); + if (strLength > 32767) { + strLength = strLength - 32768; + bytes = [ ]; + for (j = 0; j < strLength; j += 2) { + code = data.charCodeAt(offset); + bytes.push(String.fromCharCode(code & 0x00ff)); + if (j !== strLength - 1) { + bytes.push(String.fromCharCode(code >>> 8)); + } + offset++; + } + resultStr = bytes.join(''); + } else { + resultStr = data.slice(offset, offset + strLength); + offset = (offset + strLength | 0); + } + this.result.push(resultStr); + } + this.offset = offset; +}; + +LoadedStringListResult$SI.prototype = new LoadedStringListResult; + +/** + * class LoadedStringListMapResult extends Object + * @constructor + */ +function LoadedStringListMapResult() { +} + +/** + * @constructor + * @param {!string} data + * @param {!number} offset + */ +function LoadedStringListMapResult$SI(data, offset) { + /** @type {!number} */ + var length; + /** @type {!number} */ + var i; + /** @type {LoadedStringResult} */ + var keyResult; + /** @type {LoadedStringListResult} */ + var valueResult; + /** @type {!number} */ + var result$0; + /** @type {!number} */ + var offset$0; + this.offset = 0; + this.result = ({ }); + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + length = result$0; + offset += 2; + for (i = 0; i < length; i++) { + keyResult = new LoadedStringResult$SI(data, offset); + offset$0 = keyResult.offset; + valueResult = new LoadedStringListResult$SI(data, offset$0); + this.result[keyResult.result] = valueResult.result; + offset = valueResult.offset; + } + this.offset = offset; +}; + +LoadedStringListMapResult$SI.prototype = new LoadedStringListMapResult; + +/** + * class LoadedNumberListResult extends Object + * @constructor + */ +function LoadedNumberListResult() { +} + +/** + * @constructor + * @param {!string} data + * @param {!number} offset + */ +function LoadedNumberListResult$SI(data, offset) { + /** @type {!number} */ + var resultLength; + /** @type {!number} */ + var originalOffset; + /** @type {Array.<undefined|!number>} */ + var result; + /** @type {!number} */ + var tag; + /** @type {!number} */ + var length; + /** @type {!number} */ + var i; + /** @type {!number} */ + var result$0; + /** @type {!number} */ + var value1$0; + this.result = null; + this.offset = 0; + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + resultLength = result$0; + originalOffset = offset; + offset += 2; + result = [ ]; + while (result.length < resultLength) { + tag = data.charCodeAt(offset++); + if (tag >>> 15 === 1) { + value1$0 = resultLength - result.length; + length = (value1$0 <= 15 ? value1$0 : 15); + for (i = 0; i < length; i++) { + if (tag >>> i & 0x1) { + result.push(Binary$load32bitNumber$SI(data, offset)); + offset += 2; + } else { + result.push(0); + } + } + } else { + if (tag >>> 14 === 1) { + length = tag - 0x4000 + 1; + for (i = 0; i < length; i++) { + result.push(Binary$load32bitNumber$SI(data, offset)); + offset += 2; + } + } else { + length = tag + 1; + for (i = 0; i < length; i++) { + result.push(0); + } + } + } + } + this.result = result; + this.offset = offset; +}; + +LoadedNumberListResult$SI.prototype = new LoadedNumberListResult; + +/** + * class CompressionReport extends Object + * @constructor + */ +function CompressionReport() { +} + +/** + * @constructor + */ +function CompressionReport$() { + this.source = 0; + this.result = 0; +}; + +CompressionReport$.prototype = new CompressionReport; + +/** + * @param {CompressionReport} $this + * @param {!number} source + * @param {!number} result + */ +CompressionReport.add$LCompressionReport$II = function ($this, source, result) { + $this.source += source; + $this.result += result; +}; + +var CompressionReport$add$LCompressionReport$II = CompressionReport.add$LCompressionReport$II; + +/** + * @param {CompressionReport} $this + * @return {!number} + */ +CompressionReport.rate$LCompressionReport$ = function ($this) { + return (Math.round($this.result * 100.0 / $this.source) | 0); +}; + +var CompressionReport$rate$LCompressionReport$ = CompressionReport.rate$LCompressionReport$; + +/** + * class Query extends Object + * @constructor + */ +function Query() { +} + +/** + * @constructor + */ +function Query$() { + this.word = ''; + this.or = false; + this.not = false; + this.raw = false; +}; + +Query$.prototype = new Query; + +/** + * @return {!string} + */ +Query.prototype.toString = function () { + /** @type {Array.<undefined|!string>} */ + var result; + result = [ ]; + if (this.or) { + result.push("OR "); + } + if (this.not) { + result.push("-"); + } + if (this.raw) { + result.push('"', this.word, '"'); + } else { + result.push(this.word); + } + return result.join(''); +}; + +/** + * class QueryStringParser extends Object + * @constructor + */ +function QueryStringParser() { +} + +/** + * @constructor + */ +function QueryStringParser$() { + this.queries = [ ]; +}; + +QueryStringParser$.prototype = new QueryStringParser; + +/** + * @param {QueryStringParser} $this + * @param {!string} queryString + * @return {Array.<undefined|Query>} + */ +QueryStringParser.parse$LQueryStringParser$S = function ($this, queryString) { + /** @type {!boolean} */ + var nextOr; + /** @type {!boolean} */ + var nextNot; + /** @type {!number} */ + var currentWordStart; + /** @type {!number} */ + var status; + /** @type {RegExp} */ + var isSpace; + /** @type {!number} */ + var i; + /** @type {!string} */ + var ch; + /** @type {!string} */ + var word; + /** @type {Query} */ + var query; + nextOr = false; + nextNot = false; + currentWordStart = 0; + status = 0; + isSpace = /[\s\u3000]/; + for (i = 0; i < queryString.length; i++) { + ch = queryString.charAt(i); + switch (status) { + case 0: + if (! isSpace.test(ch)) { + if (ch === '-') { + nextNot = true; + } else { + if (ch === '"') { + currentWordStart = i + 1; + status = 2; + } else { + currentWordStart = i; + status = 1; + } + } + } else { + nextNot = false; + } + break; + case 1: + if (isSpace.test(ch)) { + word = queryString.slice(currentWordStart, i); + if (word === 'OR') { + nextOr = true; + } else { + query = new Query$(); + query.word = word; + query.or = nextOr; + query.not = nextNot; + $this.queries.push(query); + nextOr = false; + nextNot = false; + } + status = 0; + } + break; + case 2: + if (ch === '"') { + word = queryString.slice(currentWordStart, i); + query = new Query$(); + query.word = word; + query.or = nextOr; + query.not = nextNot; + query.raw = true; + $this.queries.push(query); + nextOr = false; + nextNot = false; + status = 0; + } + break; + } + } + switch (status) { + case 0: + break; + case 1: + query = new Query$(); + word = queryString.slice(currentWordStart, queryString.length); + if (word !== 'OR') { + query.word = word; + query.or = nextOr; + query.not = nextNot; + $this.queries.push(query); + } + break; + case 2: + query = new Query$(); + query.word = queryString.slice(currentWordStart, queryString.length); + query.or = nextOr; + query.not = nextNot; + query.raw = true; + $this.queries.push(query); + break; + } + return $this.queries; +}; + +var QueryStringParser$parse$LQueryStringParser$S = QueryStringParser.parse$LQueryStringParser$S; + +/** + * @param {QueryStringParser} $this + * @return {!string} + */ +QueryStringParser.highlight$LQueryStringParser$ = function ($this) { + /** @type {Array.<undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + /** @type {Query} */ + var query; + result = [ ]; + for (i = 0; i < $this.queries.length; i++) { + query = $this.queries[i]; + if (! query.not) { + result.push("highlight=" + $__jsx_encodeURIComponent(query.word)); + } + } + return '?' + result.join('&'); +}; + +var QueryStringParser$highlight$LQueryStringParser$ = QueryStringParser.highlight$LQueryStringParser$; + +/** + * class Proposal extends Object + * @constructor + */ +function Proposal() { +} + +/** + * @constructor + * @param {!number} omit + * @param {!number} expect + */ +function Proposal$II(omit, expect) { + this.omit = omit; + this.expect = expect; +}; + +Proposal$II.prototype = new Proposal; + +/** + * class Position extends Object + * @constructor + */ +function Position() { +} + +/** + * @constructor + * @param {!string} word + * @param {!number} position + * @param {!boolean} stemmed + */ +function Position$SIB(word, position, stemmed) { + this.word = word; + this.position = position; + this.stemmed = stemmed; +}; + +Position$SIB.prototype = new Position; + +/** + * class SearchUnit extends Object + * @constructor + */ +function SearchUnit() { +} + +/** + * @constructor + * @param {!number} id + */ +function SearchUnit$I(id) { + this.positions = ({ }); + this.id = id; + this._size = 0; + this.score = 0; + this.startPosition = -1; +}; + +SearchUnit$I.prototype = new SearchUnit; + +/** + * @param {SearchUnit} $this + * @param {!string} word + * @param {!number} position + * @param {!boolean} stemmed + */ +SearchUnit.addPosition$LSearchUnit$SIB = function ($this, word, position, stemmed) { + /** @type {Position} */ + var positionObj; + positionObj = $this.positions[position + ""]; + if (! positionObj) { + $this._size++; + $this.positions[position + ""] = ({word: word, position: position, stemmed: stemmed}); + } else { + if (positionObj.word.length < word.length) { + positionObj.word = word; + } + positionObj.stemmed = positionObj.stemmed && stemmed; + } +}; + +var SearchUnit$addPosition$LSearchUnit$SIB = SearchUnit.addPosition$LSearchUnit$SIB; + +/** + * @param {SearchUnit} $this + * @param {!number} position + * @return {Position} + */ +SearchUnit.get$LSearchUnit$I = function ($this, position) { + return $this.positions[position + ""]; +}; + +var SearchUnit$get$LSearchUnit$I = SearchUnit.get$LSearchUnit$I; + +/** + * @param {SearchUnit} $this + * @return {!number} + */ +SearchUnit.size$LSearchUnit$ = function ($this) { + return $this._size; +}; + +var SearchUnit$size$LSearchUnit$ = SearchUnit.size$LSearchUnit$; + +/** + * @param {SearchUnit} $this + * @param {SearchUnit} rhs + */ +SearchUnit.merge$LSearchUnit$LSearchUnit$ = function ($this, rhs) { + /** @type {!string} */ + var position; + /** @type {Position} */ + var pos; + for (position in rhs.positions) { + pos = rhs.positions[position]; + SearchUnit$addPosition$LSearchUnit$SIB($this, pos.word, pos.position, pos.stemmed); + } +}; + +var SearchUnit$merge$LSearchUnit$LSearchUnit$ = SearchUnit.merge$LSearchUnit$LSearchUnit$; + +/** + * @param {SearchUnit} $this + * @return {Array.<undefined|Position>} + */ +SearchUnit.getPositions$LSearchUnit$ = function ($this) { + /** @type {Array.<undefined|Position>} */ + var result; + /** @type {!string} */ + var pos; + result = [ ]; + for (pos in $this.positions) { + result.push($this.positions[pos]); + } + result.sort((function (a, b) { + return a.position - b.position; + })); + return result; +}; + +var SearchUnit$getPositions$LSearchUnit$ = SearchUnit.getPositions$LSearchUnit$; + +/** + * class SingleResult extends Object + * @constructor + */ +function SingleResult() { +} + +/** + * @constructor + */ +function SingleResult$() { + this.units = [ ]; + this.unitIds = [ ]; + this.or = false; + this.not = false; + this.searchWord = ''; +}; + +SingleResult$.prototype = new SingleResult; + +/** + * @constructor + * @param {!string} searchWord + * @param {!boolean} or + * @param {!boolean} not + */ +function SingleResult$SBB(searchWord, or, not) { + this.units = [ ]; + this.unitIds = [ ]; + this.or = or; + this.not = not; + this.searchWord = searchWord; +}; + +SingleResult$SBB.prototype = new SingleResult; + +/** + * @param {SingleResult} $this + * @param {!number} unitId + * @return {SearchUnit} + */ +SingleResult.getSearchUnit$LSingleResult$I = function ($this, unitId) { + /** @type {!number} */ + var existing; + /** @type {SearchUnit} */ + var result; + existing = $this.unitIds.indexOf(unitId); + if (existing === -1) { + result = ({positions: ({ }), id: unitId, _size: 0, score: 0, startPosition: -1}); + $this.units.push(result); + $this.unitIds.push(unitId); + } else { + result = $this.units[existing]; + } + return result; +}; + +var SingleResult$getSearchUnit$LSingleResult$I = SingleResult.getSearchUnit$LSingleResult$I; + +/** + * @param {SingleResult} $this + * @param {SingleResult} rhs + * @return {SingleResult} + */ +SingleResult.merge$LSingleResult$LSingleResult$ = function ($this, rhs) { + /** @type {SingleResult} */ + var result; + result = ({units: [ ], unitIds: [ ], or: false, not: false, searchWord: ''}); + if (rhs.or) { + SingleResult$_orMerge$LSingleResult$LSingleResult$LSingleResult$($this, result, rhs); + } else { + if (rhs.not) { + SingleResult$_notMerge$LSingleResult$LSingleResult$LSingleResult$($this, result, rhs); + } else { + SingleResult$_andMerge$LSingleResult$LSingleResult$LSingleResult$($this, result, rhs); + } + } + return result; +}; + +var SingleResult$merge$LSingleResult$LSingleResult$ = SingleResult.merge$LSingleResult$LSingleResult$; + +/** + * @param {SingleResult} $this + * @return {!number} + */ +SingleResult.size$LSingleResult$ = function ($this) { + return ($this.units.length | 0); +}; + +var SingleResult$size$LSingleResult$ = SingleResult.size$LSingleResult$; + +/** + * @param {SingleResult} $this + * @param {SingleResult} result + * @param {SingleResult} rhs + */ +SingleResult._andMerge$LSingleResult$LSingleResult$LSingleResult$ = function ($this, result, rhs) { + /** @type {!number} */ + var i; + /** @type {undefined|!number} */ + var id; + /** @type {SearchUnit} */ + var lhsSection; + for (i = 0; i < $this.unitIds.length; i++) { + id = $this.unitIds[i]; + if (rhs.unitIds.indexOf(id) !== -1) { + lhsSection = $this.units[i]; + result.unitIds.push(id); + result.units.push(lhsSection); + } + } +}; + +var SingleResult$_andMerge$LSingleResult$LSingleResult$LSingleResult$ = SingleResult._andMerge$LSingleResult$LSingleResult$LSingleResult$; + +/** + * @param {SingleResult} $this + * @param {SingleResult} result + * @param {SingleResult} rhs + */ +SingleResult._orMerge$LSingleResult$LSingleResult$LSingleResult$ = function ($this, result, rhs) { + /** @type {!number} */ + var i; + /** @type {undefined|!number} */ + var id; + /** @type {SearchUnit} */ + var rhsSection; + /** @type {SearchUnit} */ + var lhsSection; + /** @type {Array.<undefined|!number>} */ + var unitIds$0; + /** @type {Array.<undefined|SearchUnit>} */ + var units$0; + result.unitIds = (unitIds$0 = $this.unitIds).slice(0, unitIds$0.length); + result.units = (units$0 = $this.units).slice(0, units$0.length); + for (i = 0; i < rhs.unitIds.length; i++) { + id = rhs.unitIds[i]; + rhsSection = rhs.units[i]; + if (result.unitIds.indexOf(id) !== -1) { + lhsSection = result.units[result.unitIds.indexOf(id)]; + SearchUnit$merge$LSearchUnit$LSearchUnit$(lhsSection, rhsSection); + } else { + result.unitIds.push(id); + result.units.push(rhsSection); + } + } +}; + +var SingleResult$_orMerge$LSingleResult$LSingleResult$LSingleResult$ = SingleResult._orMerge$LSingleResult$LSingleResult$LSingleResult$; + +/** + * @param {SingleResult} $this + * @param {SingleResult} result + * @param {SingleResult} rhs + */ +SingleResult._notMerge$LSingleResult$LSingleResult$LSingleResult$ = function ($this, result, rhs) { + /** @type {!number} */ + var i; + /** @type {undefined|!number} */ + var id; + /** @type {SearchUnit} */ + var lhsSection; + for (i = 0; i < $this.unitIds.length; i++) { + id = $this.unitIds[i]; + if (rhs.unitIds.indexOf(id) === -1) { + lhsSection = $this.units[i]; + result.unitIds.push(id); + result.units.push(lhsSection); + } + } +}; + +var SingleResult$_notMerge$LSingleResult$LSingleResult$LSingleResult$ = SingleResult._notMerge$LSingleResult$LSingleResult$LSingleResult$; + +/** + * class SearchSummary extends Object + * @constructor + */ +function SearchSummary() { +} + +/** + * @constructor + */ +function SearchSummary$() { + this.sourceResults = [ ]; + this.result = null; + this.oktavia = null; +}; + +SearchSummary$.prototype = new SearchSummary; + +/** + * @constructor + * @param {Oktavia} oktavia + */ +function SearchSummary$LOktavia$(oktavia) { + this.sourceResults = [ ]; + this.result = null; + this.oktavia = oktavia; +}; + +SearchSummary$LOktavia$.prototype = new SearchSummary; + +/** + * @param {SearchSummary} $this + * @param {SingleResult} result + */ +SearchSummary.addQuery$LSearchSummary$LSingleResult$ = function ($this, result) { + $this.sourceResults.push(result); +}; + +var SearchSummary$addQuery$LSearchSummary$LSingleResult$ = SearchSummary.addQuery$LSearchSummary$LSingleResult$; + +/** + * @param {SearchSummary} $this + */ +SearchSummary.mergeResult$LSearchSummary$ = function ($this) { + $this.result = SearchSummary$mergeResult$LSearchSummary$ALSingleResult$($this, $this.sourceResults); +}; + +var SearchSummary$mergeResult$LSearchSummary$ = SearchSummary.mergeResult$LSearchSummary$; + +/** + * @param {SearchSummary} $this + * @param {Array.<undefined|SingleResult>} results + * @return {SingleResult} + */ +SearchSummary.mergeResult$LSearchSummary$ALSingleResult$ = function ($this, results) { + /** @type {SingleResult} */ + var rhs; + /** @type {!number} */ + var i; + /** @type {!number} */ + var results$len$0; + rhs = results[0]; + for ((i = 1, results$len$0 = results.length); i < results$len$0; i++) { + rhs = SingleResult$merge$LSingleResult$LSingleResult$(rhs, results[i]); + } + return rhs; +}; + +var SearchSummary$mergeResult$LSearchSummary$ALSingleResult$ = SearchSummary.mergeResult$LSearchSummary$ALSingleResult$; + +/** + * @param {SearchSummary} $this + * @return {Array.<undefined|Proposal>} + */ +SearchSummary.getProposal$LSearchSummary$ = function ($this) { + /** @type {Array.<undefined|Proposal>} */ + var proposals; + /** @type {!number} */ + var i; + /** @type {Array.<undefined|SingleResult>} */ + var tmpSource; + /** @type {!number} */ + var j; + /** @type {SingleResult} */ + var result; + proposals = [ ]; + for (i = 0; i < $this.sourceResults.length; i++) { + tmpSource = [ ]; + for (j = 0; j < $this.sourceResults.length; j++) { + if (i !== j) { + tmpSource.push($this.sourceResults[j]); + } + } + result = SearchSummary$mergeResult$LSearchSummary$ALSingleResult$($this, tmpSource); + proposals.push(({omit: i, expect: result.units.length})); + } + proposals.sort((function (a, b) { + return b.expect - a.expect; + })); + return proposals; +}; + +var SearchSummary$getProposal$LSearchSummary$ = SearchSummary.getProposal$LSearchSummary$; + +/** + * @param {SearchSummary} $this + * @return {Array.<undefined|SearchUnit>} + */ +SearchSummary.getSortedResult$LSearchSummary$ = function ($this) { + /** @type {Array.<undefined|SearchUnit>} */ + var result; + /** @type {Array.<undefined|SearchUnit>} */ + var units$0; + result = (units$0 = $this.result.units).slice(0, units$0.length); + result.sort((function (a, b) { + return b.score - a.score; + })); + return result; +}; + +var SearchSummary$getSortedResult$LSearchSummary$ = SearchSummary.getSortedResult$LSearchSummary$; + +/** + * @param {SearchSummary} $this + * @return {!number} + */ +SearchSummary.size$LSearchSummary$ = function ($this) { + /** @type {SingleResult} */ + var this$0; + this$0 = $this.result; + return (this$0.units.length | 0); +}; + +var SearchSummary$size$LSearchSummary$ = SearchSummary.size$LSearchSummary$; + +/** + * @param {SearchSummary} $this + * @param {SingleResult} result + */ +SearchSummary.add$LSearchSummary$LSingleResult$ = function ($this, result) { + $this.sourceResults.push(result); +}; + +var SearchSummary$add$LSearchSummary$LSingleResult$ = SearchSummary.add$LSearchSummary$LSingleResult$; + +/** + * class Style extends Object + * @constructor + */ +function Style() { +} + +/** + * @constructor + * @param {!string} mode + */ +function Style$S(mode) { + this.styles = null; + this.escapeHTML = false; + switch (mode) { + case 'console': + this.styles = Style.console; + break; + case 'html': + this.styles = Style.html; + break; + case 'ignore': + this.styles = Style.ignore; + break; + default: + this.styles = Style.ignore; + break; + } + this.escapeHTML = mode === 'html'; +}; + +Style$S.prototype = new Style; + +/** + * @param {!string} source + * @return {!string} + */ +Style.prototype.convert$S = function (source) { + /** @type {_HTMLHandler} */ + var handler; + /** @type {SAXParser} */ + var parser; + handler = new _HTMLHandler$HASB(this.styles, this.escapeHTML); + parser = new SAXParser$LSAXHandler$(handler); + parser.parse$S(source); + return handler.text.join(''); +}; + +/** + * class Stemmer + * @constructor + */ +function Stemmer() { +} + +Stemmer.prototype.$__jsx_implements_Stemmer = true; + +/** + * @constructor + */ +function Stemmer$() { +}; + +Stemmer$.prototype = new Stemmer; + +/** + * class Metadata extends Object + * @constructor + */ +function Metadata() { +} + +/** + * @constructor + * @param {Oktavia} parent + */ +function Metadata$LOktavia$(parent) { + this._parent = parent; + this._bitVector = new BitVector$(); +}; + +Metadata$LOktavia$.prototype = new Metadata; + +/** + * @return {!number} + */ +Metadata.prototype._size$ = function () { + /** @type {BitVector} */ + var this$0; + /** @type {!number} */ + var i$0; + /** @type {BitVector} */ + var _bitVector$0; + this$0 = _bitVector$0 = this._bitVector; + i$0 = _bitVector$0._size; + return this$0.rank$IB(i$0, true); +}; + +/** + * @param {!number} index + * @return {!string} + */ +Metadata.prototype.getContent$I = function (index) { + /** @type {!number} */ + var startPosition; + /** @type {!number} */ + var length; + if (index < 0 || this._size$() <= index) { + throw new Error("Section.getContent() : range error " + (index + "")); + } + startPosition = 0; + if (index > 0) { + startPosition = this._bitVector.select$I(index - 1) + 1; + } + length = this._bitVector.select$I(index) - startPosition + 1; + return this._parent._getSubstring$II(startPosition, length); +}; + +/** + * @param {!number} index + * @return {!number} + */ +Metadata.prototype.getStartPosition$I = function (index) { + /** @type {!number} */ + var startPosition; + if (index < 0 || this._size$() <= index) { + throw new Error("Section.getContent() : range error " + (index + "")); + } + startPosition = 0; + if (index > 0) { + startPosition = this._bitVector.select$I(index - 1) + 1; + } + return (startPosition | 0); +}; + +/** + * @param {SingleResult} result + * @param {Array.<undefined|!number>} positions + * @param {!string} word + * @param {!boolean} stemmed + */ +Metadata.prototype.grouping$LSingleResult$AISB = function (result, positions, word, stemmed) { +}; + +/** + * @param {!number} index + * @return {!string} + */ +Metadata.prototype.getInformation$I = function (index) { + return ''; +}; + +/** + */ +Metadata.prototype._build$ = function () { + this._bitVector.build$(); +}; + +/** + * @param {!string} name + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +Metadata.prototype._load$SSI = function (name, data, offset) { + offset = this._bitVector.load$SI(data, offset); + this._parent._metadataLabels.push(name); + this._parent._metadatas[name] = this; + return offset; +}; + +/** + * @return {!string} + */ +Metadata.prototype._dump$ = function () { + /** @type {BitVector} */ + var this$0; + /** @type {Array.<undefined|!string>} */ + var contents$0; + this$0 = this._bitVector; + contents$0 = [ ]; + contents$0.push(Binary$dump32bitNumber$N(this$0._size)); + contents$0.push(Binary$dump32bitNumberList$AN(this$0._v)); + return contents$0.join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +Metadata.prototype._dump$LCompressionReport$ = function (report) { + /** @type {BitVector} */ + var this$0; + /** @type {Array.<undefined|!string>} */ + var contents$0; + this$0 = this._bitVector; + contents$0 = [ ]; + contents$0.push(Binary$dump32bitNumber$N(this$0._size)); + CompressionReport$add$LCompressionReport$II(report, 2, 2); + contents$0.push(Binary$dump32bitNumberList$ANLCompressionReport$(this$0._v, report)); + return contents$0.join(''); +}; + +/** + * class Section extends Metadata + * @constructor + */ +function Section() { +} + +Section.prototype = new Metadata; +/** + * @constructor + * @param {Oktavia} parent + */ +function Section$LOktavia$(parent) { + this._parent = parent; + this._bitVector = new BitVector$(); + this._names = [ ]; +}; + +Section$LOktavia$.prototype = new Section; + +/** + * @param {!string} name + */ +Section.prototype.setTail$S = function (name) { + /** @type {!number} */ + var index$0; + /** @type {Oktavia} */ + var this$0; + /** @type {FMIndex} */ + var this$0$0; + this$0 = this._parent; + this$0$0 = this$0._fmindex; + index$0 = this$0$0._substr.length; + this._names.push(name); + this._bitVector.set$I(index$0 - 1); +}; + +/** + * @param {!string} name + * @param {!number} index + */ +Section.prototype.setTail$SI = function (name, index) { + this._names.push(name); + this._bitVector.set$I(index - 1); +}; + +/** + * @return {!number} + */ +Section.prototype.size$ = function () { + return (this._names.length | 0); +}; + +/** + * @param {!number} position + * @return {!number} + */ +Section.prototype.getSectionIndex$I = function (position) { + /** @type {BitVector} */ + var this$0; + if (position < 0 || this._bitVector.size$() <= position) { + throw new Error("Section.getSectionIndex() : range error " + (position + "")); + } + this$0 = this._bitVector; + return this$0.rank$IB(position, true); +}; + +/** + * @param {!number} index + * @return {!string} + */ +Section.prototype.getName$I = function (index) { + if (index < 0 || this._names.length <= index) { + throw new Error("Section.getName() : range error"); + } + return this._names[index]; +}; + +/** + * @param {SingleResult} result + * @param {Array.<undefined|!number>} positions + * @param {!string} word + * @param {!boolean} stemmed + */ +Section.prototype.grouping$LSingleResult$AISB = function (result, positions, word, stemmed) { + /** @type {!number} */ + var i; + /** @type {undefined|!number} */ + var position; + /** @type {!number} */ + var index; + /** @type {SearchUnit} */ + var unit; + for (i = 0; i < positions.length; i++) { + position = positions[i]; + index = this.getSectionIndex$I(position); + unit = SingleResult$getSearchUnit$LSingleResult$I(result, index); + if (unit.startPosition < 0) { + unit.startPosition = this.getStartPosition$I(index); + } + SearchUnit$addPosition$LSearchUnit$SIB(unit, word, position - unit.startPosition, stemmed); + } +}; + +/** + * @param {!number} index + * @return {!string} + */ +Section.prototype.getInformation$I = function (index) { + return this.getName$I(index); +}; + +/** + * @param {Oktavia} parent + * @param {!string} name + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +Section._load$LOktavia$SSI = function (parent, name, data, offset) { + /** @type {LoadedStringListResult} */ + var strs; + /** @type {Section} */ + var section; + /** @type {!number} */ + var offset$0; + strs = new LoadedStringListResult$SI(data, offset); + section = new Section$LOktavia$(parent); + section._names = strs.result; + offset$0 = strs.offset; + offset$0 = section._bitVector.load$SI(data, offset$0); + section._parent._metadataLabels.push(name); + section._parent._metadatas[name] = section; + return offset$0; +}; + +var Section$_load$LOktavia$SSI = Section._load$LOktavia$SSI; + +/** + * @return {!string} + */ +Section.prototype._dump$ = function () { + return [ Binary$dump16bitNumber$I(0), Binary$dumpStringList$AS(this._names), Metadata.prototype._dump$.call(this) ].join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +Section.prototype._dump$LCompressionReport$ = function (report) { + CompressionReport$add$LCompressionReport$II(report, 1, 1); + return [ Binary$dump16bitNumber$I(0), Binary$dumpStringList$ASLCompressionReport$(this._names, report), Metadata.prototype._dump$LCompressionReport$.call(this, report) ].join(''); +}; + +/** + * class Splitter extends Metadata + * @constructor + */ +function Splitter() { +} + +Splitter.prototype = new Metadata; +/** + * @constructor + * @param {Oktavia} parent + */ +function Splitter$LOktavia$(parent) { + this._parent = parent; + this._bitVector = new BitVector$(); + this.name = null; +}; + +Splitter$LOktavia$.prototype = new Splitter; + +/** + * @constructor + * @param {Oktavia} parent + * @param {!string} name + */ +function Splitter$LOktavia$S(parent, name) { + this._parent = parent; + this._bitVector = new BitVector$(); + this.name = name; +}; + +Splitter$LOktavia$S.prototype = new Splitter; + +/** + * @return {!number} + */ +Splitter.prototype.size$ = function () { + /** @type {BitVector} */ + var this$0$0; + /** @type {!number} */ + var i$0$0; + /** @type {BitVector} */ + var _bitVector$0; + this$0$0 = _bitVector$0 = this._bitVector; + i$0$0 = _bitVector$0._size; + return this$0$0.rank$IB(i$0$0, true); +}; + +/** + */ +Splitter.prototype.split$ = function () { + /** @type {!number} */ + var index$0; + /** @type {Oktavia} */ + var this$0; + /** @type {FMIndex} */ + var this$0$0; + this$0 = this._parent; + this$0$0 = this$0._fmindex; + index$0 = this$0$0._substr.length; + this._bitVector.set$I(index$0 - 1); +}; + +/** + * @param {!number} index + */ +Splitter.prototype.split$I = function (index) { + this._bitVector.set$I(index - 1); +}; + +/** + * @param {!number} position + * @return {!number} + */ +Splitter.prototype.getIndex$I = function (position) { + /** @type {BitVector} */ + var this$0; + if (position < 0 || this._bitVector.size$() <= position) { + throw new Error("Section.getSectionIndex() : range error"); + } + this$0 = this._bitVector; + return this$0.rank$IB(position, true); +}; + +/** + * @param {SingleResult} result + * @param {Array.<undefined|!number>} positions + * @param {!string} word + * @param {!boolean} stemmed + */ +Splitter.prototype.grouping$LSingleResult$AISB = function (result, positions, word, stemmed) { + /** @type {!number} */ + var i; + /** @type {undefined|!number} */ + var position; + /** @type {!number} */ + var index; + /** @type {SearchUnit} */ + var unit; + for (i = 0; i < positions.length; i++) { + position = positions[i]; + index = this.getIndex$I(position); + unit = SingleResult$getSearchUnit$LSingleResult$I(result, index); + if (unit.startPosition < 0) { + unit.startPosition = this.getStartPosition$I(index); + } + SearchUnit$addPosition$LSearchUnit$SIB(unit, word, position - unit.startPosition, stemmed); + } +}; + +/** + * @param {!number} index + * @return {!string} + */ +Splitter.prototype.getInformation$I = function (index) { + return (this.name != null ? this.name + (index + 1 + "") : ''); +}; + +/** + * @param {Oktavia} parent + * @param {!string} name + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +Splitter._load$LOktavia$SSI = function (parent, name, data, offset) { + /** @type {Splitter} */ + var section; + section = new Splitter$LOktavia$(parent); + offset = section._bitVector.load$SI(data, offset); + section._parent._metadataLabels.push(name); + section._parent._metadatas[name] = section; + return offset; +}; + +var Splitter$_load$LOktavia$SSI = Splitter._load$LOktavia$SSI; + +/** + * @return {!string} + */ +Splitter.prototype._dump$ = function () { + return [ Binary$dump16bitNumber$I(1), Metadata.prototype._dump$.call(this) ].join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +Splitter.prototype._dump$LCompressionReport$ = function (report) { + CompressionReport$add$LCompressionReport$II(report, 1, 1); + return [ Binary$dump16bitNumber$I(1), Metadata.prototype._dump$LCompressionReport$.call(this, report) ].join(''); +}; + +/** + * class Table extends Metadata + * @constructor + */ +function Table() { +} + +Table.prototype = new Metadata; +/** + * @constructor + * @param {Oktavia} parent + * @param {Array.<undefined|!string>} headers + */ +function Table$LOktavia$AS(parent, headers) { + this._parent = parent; + this._bitVector = new BitVector$(); + this._headers = headers; + this._columnTails = new BitVector$(); +}; + +Table$LOktavia$AS.prototype = new Table; + +/** + * @return {!number} + */ +Table.prototype.rowSize$ = function () { + /** @type {BitVector} */ + var this$0$0; + /** @type {!number} */ + var i$0$0; + /** @type {BitVector} */ + var _bitVector$0; + this$0$0 = _bitVector$0 = this._bitVector; + i$0$0 = _bitVector$0._size; + return this$0$0.rank$IB(i$0$0, true); +}; + +/** + * @return {!number} + */ +Table.prototype.columnSize$ = function () { + return (this._headers.length | 0); +}; + +/** + */ +Table.prototype.setColumnTail$ = function () { + /** @type {!number} */ + var index; + /** @type {Oktavia} */ + var this$0; + /** @type {FMIndex} */ + var this$0$0; + /** @type {Oktavia} */ + var _parent$0; + this$0 = _parent$0 = this._parent; + this$0$0 = this$0._fmindex; + index = this$0$0._substr.length; + _parent$0._fmindex.push$S(Oktavia.eob); + this._columnTails.set$I(index - 1); +}; + +/** + */ +Table.prototype.setRowTail$ = function () { + /** @type {!number} */ + var index; + /** @type {Oktavia} */ + var this$0; + /** @type {FMIndex} */ + var this$0$0; + this$0 = this._parent; + this$0$0 = this$0._fmindex; + index = this$0$0._substr.length; + this._bitVector.set$I(index - 1); +}; + +/** + * @param {!number} position + * @return {Array.<undefined|!number>} + */ +Table.prototype.getCell$I = function (position) { + /** @type {!number} */ + var row; + /** @type {!number} */ + var currentColumn; + /** @type {!number} */ + var lastRowColumn; + /** @type {!number} */ + var startPosition; + /** @type {Array.<undefined|!number>} */ + var result; + /** @type {BitVector} */ + var this$0; + /** @type {BitVector} */ + var this$1; + if (position < 0 || this._bitVector.size$() <= position) { + throw new Error("Section.getSectionIndex() : range error " + (position + "")); + } + this$0 = this._bitVector; + row = this$0.rank$IB(position, true); + this$1 = this._columnTails; + currentColumn = this$1.rank$IB(position, true); + lastRowColumn = 0; + if (row > 0) { + startPosition = this._bitVector.select$I(row - 1) + 1; + lastRowColumn = this._columnTails.rank$I(startPosition); + } + result = [ row, currentColumn - lastRowColumn ]; + return result; +}; + +/** + * @param {!number} rowIndex + * @return {Object.<string, undefined|!string>} + */ +Table.prototype.getRowContent$I = function (rowIndex) { + /** @type {!string} */ + var content; + /** @type {Array.<undefined|!string>} */ + var values; + /** @type {Object.<string, undefined|!string>} */ + var result; + /** @type {!number} */ + var i; + content = this.getContent$I(rowIndex); + values = content.split(Oktavia.eob, this._headers.length); + result = ({ }); + for (i in this._headers) { + if (i < values.length) { + result[this._headers[i]] = values[i]; + } else { + result[this._headers[i]] = ''; + } + } + return result; +}; + +/** + * @param {SingleResult} result + * @param {Array.<undefined|!number>} positions + * @param {!string} word + * @param {!boolean} stemmed + */ +Table.prototype.grouping$LSingleResult$AISB = function (result, positions, word, stemmed) { +}; + +/** + * @param {!number} index + * @return {!string} + */ +Table.prototype.getInformation$I = function (index) { + return ''; +}; + +/** + */ +Table.prototype._build$ = function () { + this._bitVector.build$(); + this._columnTails.build$(); +}; + +/** + * @param {Oktavia} parent + * @param {!string} name + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +Table._load$LOktavia$SSI = function (parent, name, data, offset) { + /** @type {LoadedStringListResult} */ + var strs; + /** @type {Table} */ + var table; + /** @type {!number} */ + var offset$0; + strs = new LoadedStringListResult$SI(data, offset); + table = new Table$LOktavia$AS(parent, strs.result); + offset$0 = strs.offset; + offset$0 = table._bitVector.load$SI(data, offset$0); + table._parent._metadataLabels.push(name); + table._parent._metadatas[name] = table; + offset = offset$0; + return table._columnTails.load$SI(data, offset$0); +}; + +var Table$_load$LOktavia$SSI = Table._load$LOktavia$SSI; + +/** + * @return {!string} + */ +Table.prototype._dump$ = function () { + return [ Binary$dump16bitNumber$I(2), Binary$dumpStringList$AS(this._headers), Metadata.prototype._dump$.call(this), this._columnTails.dump$() ].join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +Table.prototype._dump$LCompressionReport$ = function (report) { + CompressionReport$add$LCompressionReport$II(report, 1, 1); + return [ Binary$dump16bitNumber$I(2), Binary$dumpStringList$ASLCompressionReport$(this._headers, report), Metadata.prototype._dump$LCompressionReport$.call(this, report), this._columnTails.dump$LCompressionReport$(report) ].join(''); +}; + +/** + * class Block extends Metadata + * @constructor + */ +function Block() { +} + +Block.prototype = new Metadata; +/** + * @constructor + * @param {Oktavia} parent + */ +function Block$LOktavia$(parent) { + this._parent = parent; + this._bitVector = new BitVector$(); + this._names = [ ]; + this._start = false; +}; + +Block$LOktavia$.prototype = new Block; + +/** + * @param {!string} blockName + */ +Block.prototype.startBlock$S = function (blockName) { + this.startBlock$SI(blockName, this._parent.contentSize$()); +}; + +/** + * @param {!string} blockName + * @param {!number} index + */ +Block.prototype.startBlock$SI = function (blockName, index) { + if (this._start) { + throw new Error('Splitter `' + this._names[this._names.length - 1] + '` is not closed'); + } + this._start = true; + this._names.push(blockName); + this._bitVector.set$I(index - 1); +}; + +/** + */ +Block.prototype.endBlock$ = function () { + this.endBlock$I(this._parent.contentSize$()); +}; + +/** + * @param {!number} index + */ +Block.prototype.endBlock$I = function (index) { + if (! this._start) { + throw new Error('Splitter is not started'); + } + this._start = false; + this._bitVector.set$I(index - 1); +}; + +/** + * @return {!number} + */ +Block.prototype.size$ = function () { + return (this._names.length | 0); +}; + +/** + * @param {!number} position + * @return {!number} + */ +Block.prototype.blockIndex$I = function (position) { + /** @type {!number} */ + var result; + /** @type {BitVector} */ + var this$0; + if (position < 0 || this._parent._fmindex.size$() - 1 <= position) { + throw new Error("Block.blockIndex() : range error " + (position + "")); + } + if (position >= this._bitVector.size$()) { + position = (this._bitVector.size$() - 1 | 0); + result = (this._bitVector.rank$I(position) + 1 | 0); + } else { + this$0 = this._bitVector; + result = this$0.rank$IB(position, true); + } + return result; +}; + +/** + * @param {!number} position + * @return {!boolean} + */ +Block.prototype.inBlock$I = function (position) { + /** @type {!number} */ + var blockIndex; + blockIndex = this.blockIndex$I(position); + return blockIndex % 2 !== 0; +}; + +/** + * @param {!number} position + * @return {!string} + */ +Block.prototype.getBlockContent$I = function (position) { + /** @type {!number} */ + var blockIndex; + /** @type {!string} */ + var result; + blockIndex = this.blockIndex$I(position); + if (blockIndex % 2 !== 0) { + result = this.getContent$I(blockIndex); + } else { + result = ''; + } + return result; +}; + +/** + * @param {!number} position + * @return {!string} + */ +Block.prototype.getBlockName$I = function (position) { + /** @type {!number} */ + var blockIndex; + /** @type {!string} */ + var result; + blockIndex = this.blockIndex$I(position); + if (blockIndex % 2 !== 0) { + result = this._names[blockIndex >>> 1]; + } else { + result = ''; + } + return result; +}; + +/** + * @param {SingleResult} result + * @param {Array.<undefined|!number>} positions + * @param {!string} word + * @param {!boolean} stemmed + */ +Block.prototype.grouping$LSingleResult$AISB = function (result, positions, word, stemmed) { +}; + +/** + * @param {!number} index + * @return {!string} + */ +Block.prototype.getInformation$I = function (index) { + return ''; +}; + +/** + * @param {Oktavia} parent + * @param {!string} name + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +Block._load$LOktavia$SSI = function (parent, name, data, offset) { + /** @type {LoadedStringListResult} */ + var strs; + /** @type {Block} */ + var block; + /** @type {!number} */ + var offset$0; + strs = new LoadedStringListResult$SI(data, offset); + block = new Block$LOktavia$(parent); + block._names = strs.result; + offset$0 = strs.offset; + offset$0 = block._bitVector.load$SI(data, offset$0); + block._parent._metadataLabels.push(name); + block._parent._metadatas[name] = block; + return offset$0; +}; + +var Block$_load$LOktavia$SSI = Block._load$LOktavia$SSI; + +/** + * @return {!string} + */ +Block.prototype._dump$ = function () { + return [ Binary$dump16bitNumber$I(3), Binary$dumpStringList$AS(this._names), Metadata.prototype._dump$.call(this) ].join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +Block.prototype._dump$LCompressionReport$ = function (report) { + CompressionReport$add$LCompressionReport$II(report, 1, 1); + return [ Binary$dump16bitNumber$I(3), Binary$dumpStringList$ASLCompressionReport$(this._names, report), Metadata.prototype._dump$LCompressionReport$.call(this, report) ].join(''); +}; + +/** + * class FMIndex extends Object + * @constructor + */ +function FMIndex() { +} + +/** + * @constructor + */ +function FMIndex$() { + /** @type {Array.<undefined|!number>} */ + var _rlt$0; + this._ssize = 0; + (this._ddic = 0, this._head = 0); + this._substr = ""; + this._sv = new WaveletMatrix$(); + this._posdic = [ ]; + this._idic = [ ]; + _rlt$0 = this._rlt = [ ]; + _rlt$0.length = 65536; +}; + +FMIndex$.prototype = new FMIndex; + +/** + */ +FMIndex.prototype.clear$ = function () { + /** @type {WaveletMatrix} */ + var this$0; + this$0 = this._sv; + this$0._bv.length = 0; + this$0._seps.length = 0; + this$0._size = 0; + this._posdic.length = 0; + this._idic.length = 0; + this._ddic = 0; + this._head = 0; + this._substr = ""; +}; + +/** + * @return {!number} + */ +FMIndex.prototype.size$ = function () { + /** @type {WaveletMatrix} */ + var this$0; + this$0 = this._sv; + return this$0._size; +}; + +/** + * @return {!number} + */ +FMIndex.prototype.contentSize$ = function () { + return this._substr.length; +}; + +/** + * @param {!string} key + * @return {!number} + */ +FMIndex.prototype.getRows$S = function (key) { + /** @type {Array.<undefined|!number>} */ + var pos; + pos = [ ]; + return this.getRows$SAI(key, pos); +}; + +/** + * @param {!string} key + * @param {Array.<undefined|!number>} pos + * @return {!number} + */ +FMIndex.prototype.getRows$SAI = function (key, pos) { + /** @type {!number} */ + var i; + /** @type {!number} */ + var code; + /** @type {!number} */ + var first; + /** @type {undefined|!number} */ + var last; + /** @type {!number} */ + var c; + /** @type {Array.<undefined|!number>} */ + var _rlt$0; + i = key.length - 1; + code = key.charCodeAt(i); + first = (_rlt$0 = this._rlt)[code] + 1; + last = _rlt$0[code + 1]; + while (first <= last) { + if (i === 0) { + pos[0] = (-- first | 0); + pos[1] = -- last; + return (last - first + 1 | 0); + } + i--; + c = key.charCodeAt(i); + first = this._rlt[c] + this._sv.rank$II(first - 1, c) + 1; + last = this._rlt[c] + this._sv.rank$II(last, c); + } + return 0; +}; + +/** + * @param {!number} i + * @return {!number} + */ +FMIndex.prototype.getPosition$I = function (i) { + /** @type {!number} */ + var pos; + /** @type {!number} */ + var c; + if (i >= this.size$()) { + throw new Error("FMIndex.getPosition() : range error"); + } + pos = 0; + while (i !== this._head) { + if (i % this._ddic === 0) { + pos += this._posdic[i / this._ddic] + 1; + break; + } + c = this._sv.get$I(i); + i = this._rlt[c] + this._sv.rank$II(i, c); + pos++; + } + return (pos % this.size$() | 0); +}; + +/** + * @param {!number} pos + * @param {!number} len + * @return {!string} + */ +FMIndex.prototype.getSubstring$II = function (pos, len) { + /** @type {!number} */ + var pos_end; + /** @type {!number} */ + var pos_tmp; + /** @type {!number} */ + var i; + /** @type {!number} */ + var pos_idic; + /** @type {!string} */ + var substr; + /** @type {!number} */ + var c; + /** @type {!number} */ + var _ddic$0; + if (pos >= this.size$()) { + throw new Error("FMIndex.getSubstring() : range error"); + } + pos_end = Math.min(pos + len, this.size$()); + pos_tmp = this.size$() - 1; + i = this._head; + pos_idic = Math.floor((pos_end + (_ddic$0 = this._ddic) - 2) / _ddic$0); + if (pos_idic < this._idic.length) { + pos_tmp = pos_idic * this._ddic; + i = this._idic[pos_idic]; + } + substr = ""; + while (pos_tmp >= pos) { + c = this._sv.get$I(i); + i = this._rlt[c] + this._sv.rank$II(i, c); + if (pos_tmp < pos_end) { + substr = String.fromCharCode(c) + substr; + } + if (pos_tmp === 0) { + break; + } + pos_tmp--; + } + return substr; +}; + +/** + */ +FMIndex.prototype.build$ = function () { + this.build$SIIB(String.fromCharCode(0), 65535, 20, false); +}; + +/** + * @param {!string} end_marker + * @param {!number} ddic + * @param {!boolean} verbose + */ +FMIndex.prototype.build$SIB = function (end_marker, ddic, verbose) { + this.build$SIIB(end_marker, 65535, ddic, verbose); +}; + +/** + * @param {!string} end_marker + * @param {!number} maxChar + * @param {!number} ddic + * @param {!boolean} verbose + */ +FMIndex.prototype.build$SIIB = function (end_marker, maxChar, ddic, verbose) { + /** @type {BurrowsWheelerTransform} */ + var b; + /** @type {!string} */ + var s; + /** @type {!number} */ + var c; + /** @type {!string} */ + var str$0; + /** @type {WaveletMatrix} */ + var this$0; + /** @type {!string} */ + var _str$0; + /** @type {Array.<undefined|!number>} */ + var _suffixarray$0; + if (verbose) { + console.time("building burrows-wheeler transform"); + } + this._substr += end_marker; + b = ({_str: "", _size: 0, _head: 0, _suffixarray: [ ]}); + str$0 = this._substr; + _str$0 = b._str = str$0; + b._size = _str$0.length; + _suffixarray$0 = b._suffixarray = SAIS$make$S(str$0); + b._head = (_suffixarray$0.indexOf(0) | 0); + s = BurrowsWheelerTransform$get$LBurrowsWheelerTransform$(b); + this._ssize = s.length; + this._head = b._head; + b._str = ""; + b._size = 0; + b._head = 0; + b._suffixarray.length = 0; + this._substr = ""; + if (verbose) { + console.timeEnd("building burrows-wheeler transform"); + } + if (verbose) { + console.time("building wavelet matrix"); + } + this$0 = this._sv; + this$0._bitsize = (Math.ceil(Math.log(maxChar) / 0.6931471805599453) | 0); + if (verbose) { + console.log(" maxCharCode: ", maxChar); + console.log(" bitSize: ", this._sv.bitsize$()); + } + this._sv.build$S(s); + if (verbose) { + console.timeEnd("building wavelet matrix"); + } + if (verbose) { + console.time("caching rank less than"); + } + for (c = 0; c < maxChar; c++) { + this._rlt[c] = this._sv.rank_less_than$II(this._sv.size$(), c); + } + if (verbose) { + console.timeEnd("caching rank less than"); + } + this._ddic = ddic; + if (verbose) { + console.time("building dictionaries"); + } + this._buildDictionaries$(); + if (verbose) { + console.timeEnd("building dictionaries"); + console.log(''); + } +}; + +/** + */ +FMIndex.prototype._buildDictionaries$ = function () { + /** @type {!number} */ + var i; + /** @type {!number} */ + var pos; + /** @type {!number} */ + var c; + for (i = 0; i < this._ssize / this._ddic + 1; i++) { + this._posdic.push(0); + this._idic.push(0); + } + i = this._head; + pos = this.size$() - 1; + do { + if (i % this._ddic === 0) { + this._posdic[Math.floor(i / this._ddic)] = (pos | 0); + } + if (pos % this._ddic === 0) { + this._idic[Math.floor(pos / this._ddic)] = (i | 0); + } + c = this._sv.get$I(i); + i = this._rlt[c] + this._sv.rank$II(i, c); + pos--; + } while (i !== this._head); +}; + +/** + * @param {!string} doc + */ +FMIndex.prototype.push$S = function (doc) { + if (doc.length <= 0) { + throw new Error("FMIndex::push(): empty string"); + } + this._substr += doc; +}; + +/** + * @param {!string} keyword + * @return {Array.<undefined|!number>} + */ +FMIndex.prototype.search$S = function (keyword) { + /** @type {Array.<undefined|!number>} */ + var result; + /** @type {Array.<undefined|!number>} */ + var position; + /** @type {!number} */ + var rows; + /** @type {undefined|!number} */ + var first; + /** @type {undefined|!number} */ + var last; + /** @type {undefined|!number} */ + var i; + result = [ ]; + position = [ ]; + rows = this.getRows$SAI(keyword, position); + if (rows > 0) { + first = position[0]; + last = position[1]; + for (i = first; i <= last; i++) { + result.push(this.getPosition$I(i)); + } + } + return result; +}; + +/** + * @return {!string} + */ +FMIndex.prototype.dump$ = function () { + return this.dump$B(false); +}; + +/** + * @param {!boolean} verbose + * @return {!string} + */ +FMIndex.prototype.dump$B = function (verbose) { + /** @type {Array.<undefined|!string>} */ + var contents; + /** @type {CompressionReport} */ + var report; + /** @type {!number} */ + var i; + contents = [ ]; + report = ({source: 0, result: 0}); + contents.push(Binary$dump32bitNumber$N(this._ddic)); + contents.push(Binary$dump32bitNumber$N(this._ssize)); + contents.push(Binary$dump32bitNumber$N(this._head)); + CompressionReport$add$LCompressionReport$II(report, 6, 6); + contents.push(this._sv.dump$LCompressionReport$(report)); + if (verbose) { + console.log("Serializing FM-index"); + console.log(' Wavelet Matrix: ' + (contents[3].length * 2 + "") + ' bytes (' + (Math.round(report.result * 100.0 / report.source) + "") + '%)'); + } + contents.push(Binary$dump32bitNumber$N(this._posdic.length)); + for (i in this._posdic) { + contents.push(Binary$dump32bitNumber$N(this._posdic[i])); + } + for (i in this._idic) { + contents.push(Binary$dump32bitNumber$N(this._idic[i])); + } + if (verbose) { + console.log(' Dictionary Cache: ' + (this._idic.length * 16 + "") + ' bytes'); + } + return contents.join(""); +}; + +/** + * @param {!string} data + * @return {!number} + */ +FMIndex.prototype.load$S = function (data) { + return this.load$SI(data, 0); +}; + +/** + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +FMIndex.prototype.load$SI = function (data, offset) { + /** @type {!number} */ + var maxChar; + /** @type {!number} */ + var c; + /** @type {!number} */ + var size; + /** @type {!number} */ + var i; + /** @type {!number} */ + var result$0; + /** @type {!number} */ + var result$1; + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + this._ddic = (result$0 | 0); + this._ssize = (Binary$load32bitNumber$SI(data, offset + 2) | 0); + this._head = (Binary$load32bitNumber$SI(data, offset + 4) | 0); + offset = this._sv.load$SI(data, offset + 6); + maxChar = Math.pow(2, this._sv.bitsize$()); + for (c = 0; c < maxChar; c++) { + this._rlt[c] = this._sv.rank_less_than$II(this._sv.size$(), c); + } + result$1 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + size = result$1; + offset += 2; + for (i = 0; i < size; (i++, offset += 2)) { + this._posdic.push(Binary$load32bitNumber$SI(data, offset)); + } + for (i = 0; i < size; (i++, offset += 2)) { + this._idic.push(Binary$load32bitNumber$SI(data, offset)); + } + return offset; +}; + +/** + * class Tag extends Object + * @constructor + */ +function Tag() { +} + +/** + * @constructor + * @param {!string} name + */ +function Tag$S(name) { + this.name = name; + this.attributes = ({ }); + this.isSelfClosing = false; +}; + +Tag$S.prototype = new Tag; + +/** + * class _Common extends Object + * @constructor + */ +function _Common() { +} + +/** + * @constructor + */ +function _Common$() { +}; + +_Common$.prototype = new _Common; + +/** + * class _State extends Object + * @constructor + */ +function _State() { +} + +/** + * @constructor + */ +function _State$() { +}; + +_State$.prototype = new _State; + +/** + * class SAXHandler extends Object + * @constructor + */ +function SAXHandler() { +} + +/** + * @constructor + */ +function SAXHandler$() { + this.position = 0; + this.column = 0; + this.line = 0; +}; + +SAXHandler$.prototype = new SAXHandler; + +/** + * @param {Error} error + */ +SAXHandler.prototype.onerror$LError$ = function (error) { +}; + +/** + * @param {!string} text + */ +SAXHandler.prototype.ontext$S = function (text) { +}; + +/** + * @param {!string} doctype + */ +SAXHandler.prototype.ondoctype$S = function (doctype) { +}; + +/** + * @param {!string} name + * @param {!string} body + */ +SAXHandler.prototype.onprocessinginstruction$SS = function (name, body) { +}; + +/** + * @param {!string} sgmlDecl + */ +SAXHandler.prototype.onsgmldeclaration$S = function (sgmlDecl) { +}; + +/** + * @param {!string} tagname + * @param {Object.<string, undefined|!string>} attributes + */ +SAXHandler.prototype.onopentag$SHS = function (tagname, attributes) { +}; + +/** + * @param {!string} tagname + */ +SAXHandler.prototype.onclosetag$S = function (tagname) { +}; + +/** + * @param {!string} name + * @param {!string} value + */ +SAXHandler.prototype.onattribute$SS = function (name, value) { +}; + +/** + * @param {!string} comment + */ +SAXHandler.prototype.oncomment$S = function (comment) { +}; + +/** + */ +SAXHandler.prototype.onopencdata$ = function () { +}; + +/** + * @param {!string} cdata + */ +SAXHandler.prototype.oncdata$S = function (cdata) { +}; + +/** + */ +SAXHandler.prototype.onclosecdata$ = function () { +}; + +/** + */ +SAXHandler.prototype.onend$ = function () { +}; + +/** + */ +SAXHandler.prototype.onready$ = function () { +}; + +/** + * @param {!string} script + */ +SAXHandler.prototype.onscript$S = function (script) { +}; + +/** + * class _HTMLHandler extends SAXHandler + * @constructor + */ +function _HTMLHandler() { +} + +_HTMLHandler.prototype = new SAXHandler; +/** + * @constructor + * @param {Object.<string, undefined|Array.<undefined|!string>>} styles + * @param {!boolean} escape + */ +function _HTMLHandler$HASB(styles, escape) { + this.position = 0; + this.column = 0; + this.line = 0; + this.text = [ ]; + this.escape = escape; + this.styles = styles; +}; + +_HTMLHandler$HASB.prototype = new _HTMLHandler; + +/** + * @param {!string} str + * @return {!string} + */ +_HTMLHandler.escapeHTML$S = function (str) { + return str.replace(/\n/g, "<br/>").replace(/&/g, "&").replace(/"/g, """).replace(/</g, "<").replace(/>/g, ">"); +}; + +var _HTMLHandler$escapeHTML$S = _HTMLHandler.escapeHTML$S; + +/** + * @param {!string} tagname + * @param {Object.<string, undefined|!string>} attributes + */ +_HTMLHandler.prototype.onopentag$SHS = function (tagname, attributes) { + this.text.push(this.styles[tagname][0]); +}; + +/** + * @param {!string} tagname + */ +_HTMLHandler.prototype.onclosetag$S = function (tagname) { + this.text.push(this.styles[tagname][1]); +}; + +/** + * @param {!string} text + */ +_HTMLHandler.prototype.ontext$S = function (text) { + if (this.escape) { + this.text.push(text.replace(/\n/g, "<br/>").replace(/&/g, "&").replace(/"/g, """).replace(/</g, "<").replace(/>/g, ">")); + } else { + this.text.push(text); + } +}; + +/** + * @return {!string} + */ +_HTMLHandler.prototype.result$ = function () { + return this.text.join(''); +}; + +/** + * class SAXParser extends Object + * @constructor + */ +function SAXParser() { +} + +/** + * @constructor + * @param {SAXHandler} handler + */ +function SAXParser$LSAXHandler$(handler) { + this.q = ""; + this.c = ""; + this.bufferCheckPosition = 0; + this.looseCase = ""; + this.tags = [ ]; + this.closed = false; + this.closedRoot = false; + this.sawRoot = false; + this.tag = null; + this.error = null; + this.handler = null; + this.ENTITIES = null; + this.strict = false; + this.tagName = ""; + this.state = 0; + this.line = 0; + this.column = 0; + this.position = 0; + this.startTagPosition = 0; + this.attribName = ""; + this.attribValue = ""; + this.script = ""; + this.textNode = ""; + this.attribList = null; + this.noscript = false; + this.cdata = ""; + this.procInstBody = ""; + this.procInstName = ""; + this.doctype = ""; + this.entity = ""; + this.sgmlDecl = ""; + this.comment = ""; + this.preTags = 0; + this._init$LSAXHandler$B(handler, false); +}; + +SAXParser$LSAXHandler$.prototype = new SAXParser; + +/** + * @constructor + * @param {SAXHandler} handler + * @param {!boolean} strict + */ +function SAXParser$LSAXHandler$B(handler, strict) { + this.q = ""; + this.c = ""; + this.bufferCheckPosition = 0; + this.looseCase = ""; + this.tags = [ ]; + this.closed = false; + this.closedRoot = false; + this.sawRoot = false; + this.tag = null; + this.error = null; + this.handler = null; + this.ENTITIES = null; + this.strict = false; + this.tagName = ""; + this.state = 0; + this.line = 0; + this.column = 0; + this.position = 0; + this.startTagPosition = 0; + this.attribName = ""; + this.attribValue = ""; + this.script = ""; + this.textNode = ""; + this.attribList = null; + this.noscript = false; + this.cdata = ""; + this.procInstBody = ""; + this.procInstName = ""; + this.doctype = ""; + this.entity = ""; + this.sgmlDecl = ""; + this.comment = ""; + this.preTags = 0; + this._init$LSAXHandler$B(handler, strict); +}; + +SAXParser$LSAXHandler$B.prototype = new SAXParser; + +/** + * @param {SAXHandler} handler + * @param {!boolean} strict + */ +SAXParser.prototype._init$LSAXHandler$B = function (handler, strict) { + this.handler = handler; + this.clearBuffers$(); + this.q = ""; + this.bufferCheckPosition = 65536; + this.looseCase = 'toLowerCase'; + this.tags = [ ]; + this.closed = this.closedRoot = this.sawRoot = false; + this.tag = null; + this.error = null; + this.strict = strict; + this.noscript = strict; + this.state = 1; + this.ENTITIES = _Entities$entity_list$(); + this.attribList = [ ]; + this.noscript = false; + this.preTags = 0; +}; + +/** + * @param {!boolean} flag + */ +SAXParser.prototype.set_noscript$B = function (flag) { + this.noscript = flag; +}; + +/** + * @return {SAXParser} + */ +SAXParser.prototype.resume$ = function () { + this.error = null; + return this; +}; + +/** + * @return {SAXParser} + */ +SAXParser.prototype.close$ = function () { + return this.parse$S(''); +}; + +/** + * @param {!string} chunk + * @return {SAXParser} + */ +SAXParser.prototype.parse$S = function (chunk) { + /** @type {Char} */ + var _; + /** @type {!number} */ + var i; + /** @type {!string} */ + var c; + /** @type {!number} */ + var starti; + /** @type {!number} */ + var pad; + /** @type {!number} */ + var returnState; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$0; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$1; + /** @type {RegExp} */ + var charclass$2; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$3; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$4; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$5; + /** @type {!string} */ + var text$0; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$6; + /** @type {RegExp} */ + var charclass$7; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$8; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$9; + /** @type {RegExp} */ + var charclass$10; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$11; + /** @type {RegExp} */ + var charclass$12; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$13; + /** @type {RegExp} */ + var charclass$14; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$15; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$16; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$17; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$18; + /** @type {RegExp} */ + var charclass$19; + /** @type {RegExp} */ + var charclass$20; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$21; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$22; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$23; + /** @type {Object.<string, undefined|!boolean>} */ + var charclass$24; + /** @type {!string} */ + var comment$0; + _ = new Char$(); + if (this.error) { + throw this.error; + } + if (this.closed) { + return this.emiterror$S("Cannot write after close. Assign an onready handler."); + } + (i = 0, c = ""); + while (this.c = c = chunk.charAt(i++)) { + this.position++; + if (c === "\n") { + this.handler.line++; + this.handler.column = 0; + } else { + this.handler.column++; + } + switch (this.state) { + case 1: + if (c === "<") { + this.state = 4; + this.startTagPosition = this.position; + } else { + charclass$0 = _.whitespace; + if (! $__jsx_ObjectHasOwnProperty.call(charclass$0, c)) { + this.strictFail$S("Non-whitespace before first tag."); + this.textNode = c; + this.state = 2; + } + } + continue; + case 2: + if (this.sawRoot && ! this.closedRoot) { + starti = i - 1; + while (c && c !== "<" && c !== "&") { + c = chunk.charAt(i++); + if (c) { + this.position++; + if (c === "\n") { + this.handler.line++; + this.handler.column = 0; + } else { + this.handler.column++; + } + } + } + this.textNode += chunk.substring(starti, i - 1); + } + if (c === "<") { + this.state = 4; + this.startTagPosition = this.position; + } else { + if (_.not$HBS(_.whitespace, c) && (! this.sawRoot || this.closedRoot)) { + this.strictFail$S("Text data outside of root node."); + } + if (c === "&") { + this.state = 3; + } else { + this.textNode += c; + } + } + continue; + case 33: + if (c === "<") { + this.state = 34; + } else { + this.script += c; + } + continue; + case 34: + if (c === "/") { + this.state = 31; + } else { + this.script += "<" + c; + this.state = 33; + } + continue; + case 4: + if (c === "!") { + this.state = 5; + this.sgmlDecl = ""; + } else { + charclass$1 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$1, c)) { + } else { + charclass$2 = _.nameStart; + if (charclass$2.test(c)) { + this.state = 21; + this.tagName = c; + } else { + if (c === "/") { + this.state = 31; + this.tagName = ""; + } else { + if (c === "?") { + this.state = 18; + this.procInstName = this.procInstBody = ""; + } else { + this.strictFail$S("Unencoded <"); + if (this.startTagPosition + 1 < this.position) { + pad = this.position - this.startTagPosition; + for (i = 0; i < pad; i++) { + c = " " + c; + } + } + this.textNode += "<" + c; + this.state = 2; + } + } + } + } + } + continue; + case 5: + if ((this.sgmlDecl + c).toUpperCase() === _.CDATA) { + this.closetext_if_exist$(); + this.state = 15; + this.sgmlDecl = ""; + this.cdata = ""; + } else { + if (this.sgmlDecl + c === "--") { + this.state = 12; + this.comment = ""; + this.sgmlDecl = ""; + } else { + if ((this.sgmlDecl + c).toUpperCase() === _.DOCTYPE) { + this.state = 7; + if (this.doctype || this.sawRoot) { + this.strictFail$S("Inappropriately located doctype declaration"); + } + this.doctype = ""; + this.sgmlDecl = ""; + } else { + if (c === ">") { + this.closetext_if_exist$(); + this.sgmlDecl = ""; + this.state = 2; + } else { + charclass$3 = _.quote; + if ($__jsx_ObjectHasOwnProperty.call(charclass$3, c)) { + this.state = 6; + this.sgmlDecl += c; + } else { + this.sgmlDecl += c; + } + } + } + } + } + continue; + case 6: + if (c === this.q) { + this.state = 5; + this.q = ""; + } + this.sgmlDecl += c; + continue; + case 7: + if (c === ">") { + this.state = 2; + this.closetext_if_exist$(); + this.doctype.trim(); + } else { + this.doctype += c; + if (c === "[") { + this.state = 9; + } else { + charclass$4 = _.quote; + if ($__jsx_ObjectHasOwnProperty.call(charclass$4, c)) { + this.state = 8; + this.q = c; + } + } + } + continue; + case 8: + this.doctype += c; + if (c === this.q) { + this.q = ""; + this.state = 7; + } + continue; + case 9: + this.doctype += c; + if (c === "]") { + this.state = 7; + } else { + charclass$5 = _.quote; + if ($__jsx_ObjectHasOwnProperty.call(charclass$5, c)) { + this.state = 10; + this.q = c; + } + } + continue; + case 10: + this.doctype += c; + if (c === this.q) { + this.state = 9; + this.q = ""; + } + continue; + case 12: + if (c === "-") { + this.state = 13; + } else { + this.comment += c; + } + continue; + case 13: + if (c === "-") { + this.state = 14; + text$0 = this.comment; + text$0 = text$0.replace(/[\n\t]/g, ' '); + text$0 = text$0.replace(/\s\s+/g, " "); + comment$0 = this.comment = text$0; + if (comment$0) { + this.closetext_if_exist$(); + this.comment.trim(); + } + this.comment = ""; + } else { + this.comment += "-" + c; + this.state = 12; + } + continue; + case 14: + if (c !== ">") { + this.strictFail$S("Malformed comment"); + this.comment += "--" + c; + this.state = 12; + } else { + this.state = 2; + } + continue; + case 15: + if (c === "]") { + this.state = 16; + } else { + this.cdata += c; + } + continue; + case 16: + if (c === "]") { + this.state = 17; + } else { + this.cdata += "]" + c; + this.state = 15; + } + continue; + case 17: + if (c === ">") { + if (this.cdata) { + this.closetext_if_exist$(); + } + this.cdata = ""; + this.state = 2; + } else { + if (c === "]") { + this.cdata += "]"; + } else { + this.cdata += "]]" + c; + this.state = 15; + } + } + continue; + case 18: + if (c === "?") { + this.state = 20; + } else { + charclass$6 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$6, c)) { + this.state = 19; + } else { + this.procInstName += c; + } + } + continue; + case 19: + if (! this.procInstBody && _.is$HBS(_.whitespace, c)) { + continue; + } else { + if (c === "?") { + this.state = 20; + } else { + this.procInstBody += c; + } + } + continue; + case 20: + if (c === ">") { + this.closetext_if_exist$(); + this.procInstName = this.procInstBody = ""; + this.state = 2; + } else { + this.procInstBody += "?" + c; + this.state = 19; + } + continue; + case 21: + charclass$7 = _.nameBody; + if (charclass$7.test(c)) { + this.tagName += c; + } else { + this.newTag$(); + if (c === ">") { + this.openTag$B(false); + } else { + if (c === "/") { + this.state = 22; + } else { + charclass$8 = _.whitespace; + if (! $__jsx_ObjectHasOwnProperty.call(charclass$8, c)) { + this.strictFail$S("Invalid character in tag name"); + } + this.state = 23; + } + } + } + continue; + case 22: + if (c === ">") { + this.openTag$B(true); + this.closeTag$(); + } else { + this.strictFail$S("Forward-slash in opening tag not followed by >"); + this.state = 23; + } + continue; + case 23: + charclass$9 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$9, c)) { + continue; + } else { + if (c === ">") { + this.openTag$B(false); + } else { + if (c === "/") { + this.state = 22; + } else { + charclass$10 = _.nameStart; + if (charclass$10.test(c)) { + this.attribName = c; + this.attribValue = ""; + this.state = 24; + } else { + this.strictFail$S("Invalid attribute name"); + } + } + } + } + continue; + case 24: + if (c === "=") { + this.state = 26; + } else { + if (c === ">") { + this.strictFail$S("Attribute without value"); + this.attribValue = this.attribName; + this.attrib$(); + this.openTag$B(false); + } else { + charclass$11 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$11, c)) { + this.state = 25; + } else { + charclass$12 = _.nameBody; + if (charclass$12.test(c)) { + this.attribName += c; + } else { + this.strictFail$S("Invalid attribute name"); + } + } + } + } + continue; + case 25: + if (c === "=") { + this.state = 26; + } else { + charclass$13 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$13, c)) { + continue; + } else { + this.strictFail$S("Attribute without value"); + this.tag.attributes[this.attribName] = ""; + this.attribValue = ""; + this.closetext_if_exist$(); + this.attribName = ""; + if (c === ">") { + this.openTag$B(false); + } else { + charclass$14 = _.nameStart; + if (charclass$14.test(c)) { + this.attribName = c; + this.state = 24; + } else { + this.strictFail$S("Invalid attribute name"); + this.state = 23; + } + } + } + } + continue; + case 26: + charclass$15 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$15, c)) { + continue; + } else { + charclass$16 = _.quote; + if ($__jsx_ObjectHasOwnProperty.call(charclass$16, c)) { + this.q = c; + this.state = 27; + } else { + this.strictFail$S("Unquoted attribute value"); + this.state = 28; + this.attribValue = c; + } + } + continue; + case 27: + if (c !== this.q) { + if (c === "&") { + this.state = 29; + } else { + this.attribValue += c; + } + continue; + } + this.attrib$(); + this.q = ""; + this.state = 23; + continue; + case 28: + charclass$17 = _.attribEnd; + if (! $__jsx_ObjectHasOwnProperty.call(charclass$17, c)) { + if (c === "&") { + this.state = 30; + } else { + this.attribValue += c; + } + continue; + } + this.attrib$(); + if (c === ">") { + this.openTag$B(false); + } else { + this.state = 23; + } + continue; + case 31: + if (! this.tagName) { + charclass$18 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$18, c)) { + continue; + } else { + charclass$19 = _.nameStart; + if (! charclass$19.test(c)) { + if (this.script) { + this.script += "</" + c; + this.state = 33; + } else { + this.strictFail$S("Invalid tagname in closing tag."); + } + } else { + this.tagName = c; + } + } + } else { + if (c === ">") { + this.closeTag$(); + } else { + charclass$20 = _.nameBody; + if (charclass$20.test(c)) { + this.tagName += c; + } else { + if (this.script) { + this.script += "</" + this.tagName; + this.tagName = ""; + this.state = 33; + } else { + charclass$21 = _.whitespace; + if (! $__jsx_ObjectHasOwnProperty.call(charclass$21, c)) { + this.strictFail$S("Invalid tagname in closing tag"); + } + this.state = 32; + } + } + } + } + continue; + case 32: + charclass$22 = _.whitespace; + if ($__jsx_ObjectHasOwnProperty.call(charclass$22, c)) { + continue; + } + if (c === ">") { + this.closeTag$(); + } else { + this.strictFail$S("Invalid characters in closing tag"); + } + continue; + case 3: + if (c === ";") { + this.textNode += this.parseEntity$(); + this.entity = ""; + this.state = 2; + } else { + charclass$23 = _.entity; + if ($__jsx_ObjectHasOwnProperty.call(charclass$23, c)) { + this.entity += c; + } else { + this.strictFail$S("Invalid character entity"); + this.textNode += "&" + this.entity + c; + this.entity = ""; + this.state = 2; + } + } + continue; + case 29: + case 30: + if (this.state === 29) { + returnState = 27; + } else { + returnState = 28; + } + if (c === ";") { + this.attribValue += this.parseEntity$(); + this.entity = ""; + this.state = (returnState | 0); + } else { + charclass$24 = _.entity; + if ($__jsx_ObjectHasOwnProperty.call(charclass$24, c)) { + this.entity += c; + } else { + this.strictFail$S("Invalid character entity"); + this.attribValue += "&" + this.entity + c; + this.entity = ""; + this.state = (returnState | 0); + } + } + continue; + default: + throw new Error("Unknown state: " + (this.state + "")); + } + } + this.end$(); + return this; +}; + +/** + */ +SAXParser.prototype.clearBuffers$ = function () { + this.comment = ''; + this.sgmlDecl = ''; + this.textNode = ''; + this.tagName = ''; + this.doctype = ''; + this.procInstName = ''; + this.procInstBody = ''; + this.entity = ''; + this.attribName = ''; + this.attribValue = ''; + this.cdata = ''; + this.script = ''; +}; + +/** + */ +SAXParser.prototype.closetext_if_exist$ = function () { + if (this.textNode !== '') { + this.closetext$(); + } +}; + +/** + */ +SAXParser.prototype.closetext$ = function () { + /** @type {!string} */ + var text; + /** @type {!string} */ + var text$0; + if (this.preTags === 0) { + text$0 = this.textNode; + text$0 = text$0.replace(/[\n\t]/g, ' '); + text$0 = text$0.replace(/\s\s+/g, " "); + text = text$0; + if (text$0) { + this.handler.ontext$S(text); + } + } else { + if (this.textNode) { + this.handler.ontext$S(this.textNode); + } + } + this.textNode = ""; +}; + +/** + * @param {!string} text + * @return {!string} + */ +SAXParser.prototype.textopts$S = function (text) { + text = text.replace(/[\n\t]/g, ' '); + text = text.replace(/\s\s+/g, " "); + return text; +}; + +/** + * @param {!string} er + * @return {SAXParser} + */ +SAXParser.prototype.emiterror$S = function (er) { + /** @type {Error} */ + var error; + this.closetext$(); + er += "\nLine: " + (this.line + "") + "\nColumn: " + (this.column + "") + "\nChar: " + this.c; + error = new Error(er); + this.error = error; + return this; +}; + +/** + */ +SAXParser.prototype.end$ = function () { + if (! this.closedRoot) { + this.strictFail$S("Unclosed root tag"); + } + if (this.state !== 2) { + this.emiterror$S("Unexpected end"); + } + this.closetext$(); + this.c = ""; + this.closed = true; +}; + +/** + * @param {!string} message + */ +SAXParser.prototype.strictFail$S = function (message) { + if (this.strict) { + this.emiterror$S(message); + } +}; + +/** + */ +SAXParser.prototype.newTag$ = function () { + if (! this.strict) { + this.tagName = this.tagName.toLowerCase(); + } + this.tag = ({name: this.tagName, attributes: ({ }), isSelfClosing: false}); + this.attribList.length = 0; +}; + +/** + */ +SAXParser.prototype.attrib$ = function () { + if (! this.strict) { + this.attribName = this.attribName.toLowerCase(); + } + if ($__jsx_ObjectHasOwnProperty.call(this.tag.attributes, this.attribName)) { + this.attribName = this.attribValue = ""; + return; + } + this.tag.attributes[this.attribName] = this.attribValue; + this.closetext_if_exist$(); + this.attribName = this.attribValue = ""; +}; + +/** + */ +SAXParser.prototype.openTag$ = function () { + this.openTag$B(false); +}; + +/** + * @param {!boolean} selfClosing + */ +SAXParser.prototype.openTag$B = function (selfClosing) { + /** @type {Tag} */ + var tag$0; + /** @type {Tag} */ + var tag$1; + (tag$0 = this.tag).isSelfClosing = selfClosing; + this.sawRoot = true; + this.tags.push(tag$0); + this.closetext_if_exist$(); + this.handler.onopentag$SHS((tag$1 = this.tag).name, tag$1.attributes); + if (this.tag.name === 'pre') { + this.preTags++; + } + if (! selfClosing) { + if (! this.noscript && this.tagName.toLowerCase() === "script") { + this.state = 33; + } else { + this.state = 2; + } + this.tag = null; + this.tagName = ""; + } + this.attribName = this.attribValue = ""; + this.attribList.length = 0; +}; + +/** + */ +SAXParser.prototype.closeTag$ = function () { + /** @type {!number} */ + var t; + /** @type {!string} */ + var tagName; + /** @type {!string} */ + var closeTo; + /** @type {Tag} */ + var close; + /** @type {!number} */ + var s; + /** @type {Tag} */ + var tag$0; + if (! this.tagName) { + this.strictFail$S("Weird empty close tag."); + this.textNode += "</>"; + this.state = 2; + return; + } + if (this.script) { + if (this.tagName !== "script") { + this.script += "</" + this.tagName + ">"; + this.tagName = ""; + this.state = 33; + return; + } + this.closetext_if_exist$(); + this.script = ""; + } + t = this.tags.length; + tagName = this.tagName; + if (! this.strict) { + tagName = tagName.toLowerCase(); + } + closeTo = tagName; + while (t--) { + close = this.tags[t]; + if (close.name !== closeTo) { + this.strictFail$S("Unexpected close tag"); + } else { + break; + } + } + if (t < 0) { + this.strictFail$S("Unmatched closing tag: " + this.tagName); + this.textNode += "</" + this.tagName + ">"; + this.state = 2; + return; + } + this.tagName = tagName; + s = this.tags.length; + while (s-- > t) { + tag$0 = this.tag = this.tags.pop(); + this.tagName = tag$0.name; + this.closetext_if_exist$(); + this.handler.onclosetag$S(this.tagName); + if (this.tagName === 'pre') { + this.preTags--; + } + } + if (t === 0) { + this.closedRoot = true; + } + this.tagName = this.attribValue = this.attribName = ""; + this.attribList.length = 0; + this.state = 2; +}; + +/** + * @return {!string} + */ +SAXParser.prototype.parseEntity$ = function () { + /** @type {!string} */ + var entity; + /** @type {!string} */ + var entityLC; + /** @type {!number} */ + var num; + /** @type {!string} */ + var numStr; + entity = this.entity; + entityLC = entity.toLowerCase(); + num = 0; + numStr = ""; + if (this.ENTITIES[entity]) { + return this.ENTITIES[entity]; + } + if (this.ENTITIES[entityLC]) { + return this.ENTITIES[entityLC]; + } + entity = entityLC; + if (entityLC.charAt(0) === "#") { + if (entity.charAt(1) === "x") { + entity = entity.slice(2); + num = $__jsx_parseInt(entity, 16); + numStr = num.toString(16); + } else { + entity = entity.slice(1); + num = $__jsx_parseInt(entity, 10); + numStr = num.toString(10); + } + } + entity = entity.replace(/^0+/, ""); + if (numStr.toLowerCase() !== entity) { + this.strictFail$S("Invalid character entity"); + return "&" + this.entity + ";"; + } + return String.fromCharCode(num); +}; + +/** + * class Char extends Object + * @constructor + */ +function Char() { +} + +/** + * @constructor + */ +function Char$() { + this.CDATA = "[CDATA["; + this.DOCTYPE = "DOCTYPE"; + this.XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"; + this.whitespace = this._charClass$S("\r\n\t "); + this.number = this._charClass$S("0124356789"); + this.letter = this._charClass$S("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); + this.quote = this._charClass$S("'\""); + this.entity = this._charClass$S("0124356789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ#"); + this.attribEnd = this._charClass$S("\r\n\t >"); + this.nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/; + this.nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/; +}; + +Char$.prototype = new Char; + +/** + * @param {!string} str + * @return {Object.<string, undefined|!boolean>} + */ +Char.prototype._charClass$S = function (str) { + /** @type {Object.<string, undefined|!boolean>} */ + var result; + /** @type {!number} */ + var i; + result = ({ }); + for (i = 0; i < str.length; i++) { + result[str.slice(i, i + 1)] = true; + } + return result; +}; + +/** + * @param {RegExp} charclass + * @param {!string} c + * @return {!boolean} + */ +Char.prototype.is$LRegExp$S = function (charclass, c) { + return charclass.test(c); +}; + +/** + * @param {Object.<string, undefined|!boolean>} charclass + * @param {!string} c + * @return {!boolean} + */ +Char.prototype.is$HBS = function (charclass, c) { + return $__jsx_ObjectHasOwnProperty.call(charclass, c); +}; + +/** + * @param {RegExp} charclass + * @param {!string} c + * @return {!boolean} + */ +Char.prototype.not$LRegExp$S = function (charclass, c) { + return ! charclass.test(c); +}; + +/** + * @param {Object.<string, undefined|!boolean>} charclass + * @param {!string} c + * @return {!boolean} + */ +Char.prototype.not$HBS = function (charclass, c) { + return ! $__jsx_ObjectHasOwnProperty.call(charclass, c); +}; + +/** + * class _Entities extends Object + * @constructor + */ +function _Entities() { +} + +/** + * @constructor + */ +function _Entities$() { +}; + +_Entities$.prototype = new _Entities; + +/** + * @return {Object.<string, undefined|!string>} + */ +_Entities.entity_list$ = function () { + /** @type {Object.<string, undefined|!string>} */ + var result; + /** @type {!string} */ + var key; + /** @type {*} */ + var value; + result = ({ }); + for (key in _Entities._entities) { + value = _Entities._entities[key]; + if (typeof value === 'string') { + result[key] = value + ""; + } else { + if (typeof value === 'number') { + result[key] = String.fromCharCode(value | 0); + } + } + } + return result; +}; + +var _Entities$entity_list$ = _Entities.entity_list$; + +/** + * class BitVector extends Object + * @constructor + */ +function BitVector() { +} + +/** + * @constructor + */ +function BitVector$() { + /** @type {Array.<undefined|!number>} */ + var _v$0; + /** @type {Array.<undefined|!number>} */ + var _r$0; + _r$0 = this._r = [ ]; + _v$0 = this._v = [ ]; + _v$0.length = 0; + _r$0.length = 0; + this._size = 0; + this._size1 = 0; +}; + +BitVector$.prototype = new BitVector; + +/** + */ +BitVector.prototype.build$ = function () { + /** @type {!number} */ + var i; + this._size1 = 0; + for (i = 0; i < this._v.length; i++) { + if (i % 8 === 0) { + this._r.push(true ? this._size1 : this._size - this._size1); + } + this._size1 += this._rank32$IIB(this._v[i], 32, true); + } +}; + +/** + */ +BitVector.prototype.clear$ = function () { + this._v.length = 0; + this._r.length = 0; + this._size = 0; + this._size1 = 0; +}; + +/** + * @return {!number} + */ +BitVector.prototype.size$ = function () { + return this._size; +}; + +/** + * @param {!boolean} b + * @return {!number} + */ +BitVector.prototype.size$B = function (b) { + return (b ? this._size1 : this._size - this._size1); +}; + +/** + * @param {!number} value + */ +BitVector.prototype.set$I = function (value) { + this.set$IB(value, true); +}; + +/** + * @param {!number} value + * @param {!boolean} flag + */ +BitVector.prototype.set$IB = function (value, flag) { + /** @type {!number} */ + var q; + /** @type {!number} */ + var r; + /** @type {!number} */ + var m; + if (value >= this._size) { + this._size = (value + 1 | 0); + } + q = (value / 32 | 0); + r = (value % 32 | 0); + while (q >= this._v.length) { + this._v.push(0); + } + m = 0x1 << r; + if (flag) { + this._v[q] |= m; + } else { + this._v[q] &= ~ m; + } +}; + +/** + * @param {!number} value + * @return {!boolean} + */ +BitVector.prototype.get$I = function (value) { + /** @type {!number} */ + var q; + /** @type {!number} */ + var r; + /** @type {!number} */ + var m; + if (value >= this._size) { + throw new Error("BitVector.get() : range error"); + } + q = (value / 32 | 0); + r = (value % 32 | 0); + m = 0x1 << r; + return !! (this._v[q] & m); +}; + +/** + * @param {!number} i + * @return {!number} + */ +BitVector.prototype.rank$I = function (i) { + return this.rank$IB(i, true); +}; + +/** + * @param {!number} i + * @param {!boolean} b + * @return {!number} + */ +BitVector.prototype.rank$IB = function (i, b) { + /** @type {!number} */ + var q_large; + /** @type {!number} */ + var q_small; + /** @type {!number} */ + var r; + /** @type {!number} */ + var rank; + /** @type {!number} */ + var begin; + /** @type {!number} */ + var j; + if (i > this._size) { + throw new Error("BitVector.rank() : range error"); + } + if (i === 0) { + return 0; + } + i--; + q_large = (Math.floor(i / 256) | 0); + q_small = (Math.floor(i / 32) | 0); + r = (Math.floor(i % 32) | 0); + rank = (this._r[q_large] | 0); + if (! b) { + rank = q_large * 256 - rank; + } + begin = q_large * 8; + for (j = begin; j < q_small; j++) { + rank += this._rank32$IIB(this._v[j], 32, b); + } + rank += this._rank32$IIB(this._v[q_small], r + 1, b); + return rank; +}; + +/** + * @param {!number} i + * @return {!number} + */ +BitVector.prototype.select$I = function (i) { + return this.select$IB(i, true); +}; + +/** + * @param {!number} i + * @param {!boolean} b + * @return {!number} + */ +BitVector.prototype.select$IB = function (i, b) { + /** @type {!number} */ + var left; + /** @type {!number} */ + var right; + /** @type {!number} */ + var pivot; + /** @type {undefined|!number} */ + var rank; + /** @type {!number} */ + var j; + if (i >= (b ? this._size1 : this._size - this._size1)) { + throw new Error("BitVector.select() : range error"); + } + left = 0; + right = this._r.length; + while (left < right) { + pivot = Math.floor((left + right) / 2); + rank = this._r[pivot]; + if (! b) { + rank = pivot * 256 - rank; + } + if (i < rank) { + right = pivot; + } else { + left = pivot + 1; + } + } + right--; + if (b) { + i -= (this._r[right] | 0); + } else { + i -= (right * 256 - this._r[right] | 0); + } + j = right * 8; + while (1) { + rank = this._rank32$IIB(this._v[j], 32, b); + if (i < rank) { + break; + } + j++; + i -= (rank | 0); + } + return (j * 32 + this._select32$IIB(this._v[j], i, b) | 0); +}; + +/** + * @param {!number} x + * @param {!number} i + * @param {!boolean} b + * @return {!number} + */ +BitVector.prototype._rank32$IIB = function (x, i, b) { + if (! b) { + x = ~ x; + } + x <<= 32 - i; + x = ((x & 0xaaaaaaaa) >>> 1) + (x & 0x55555555); + x = ((x & 0xcccccccc) >>> 2) + (x & 0x33333333); + x = ((x & 0xf0f0f0f0) >>> 4) + (x & 0x0f0f0f0f); + x = ((x & 0xff00ff00) >>> 8) + (x & 0x00ff00ff); + x = ((x & 0xffff0000) >>> 16) + (x & 0x0000ffff); + return x; +}; + +/** + * @param {!number} x + * @param {!number} i + * @param {!boolean} b + * @return {!number} + */ +BitVector.prototype._select32$IIB = function (x, i, b) { + /** @type {!number} */ + var x1; + /** @type {!number} */ + var x2; + /** @type {!number} */ + var x3; + /** @type {!number} */ + var x4; + /** @type {!number} */ + var x5; + /** @type {!number} */ + var pos; + /** @type {!number} */ + var v5; + /** @type {!number} */ + var v4; + /** @type {!number} */ + var v3; + /** @type {!number} */ + var v2; + /** @type {!number} */ + var v1; + /** @type {!number} */ + var v0; + if (! b) { + x = ~ x; + } + x1 = ((x & 0xaaaaaaaa) >>> 1) + (x & 0x55555555); + x2 = ((x1 & 0xcccccccc) >>> 2) + (x1 & 0x33333333); + x3 = ((x2 & 0xf0f0f0f0) >>> 4) + (x2 & 0x0f0f0f0f); + x4 = ((x3 & 0xff00ff00) >>> 8) + (x3 & 0x00ff00ff); + x5 = ((x4 & 0xffff0000) >>> 16) + (x4 & 0x0000ffff); + i++; + pos = 0; + v5 = x5 & 0xffffffff; + if (i > v5) { + i -= (v5 | 0); + pos += 32; + } + v4 = x4 >>> pos & 0x0000ffff; + if (i > v4) { + i -= (v4 | 0); + pos += 16; + } + v3 = x3 >>> pos & 0x000000ff; + if (i > v3) { + i -= (v3 | 0); + pos += 8; + } + v2 = x2 >>> pos & 0x0000000f; + if (i > v2) { + i -= (v2 | 0); + pos += 4; + } + v1 = x1 >>> pos & 0x00000003; + if (i > v1) { + i -= (v1 | 0); + pos += 2; + } + v0 = x >>> pos & 0x00000001; + if (i > v0) { + i -= (v0 | 0); + pos += 1; + } + return (pos | 0); +}; + +/** + * @return {!string} + */ +BitVector.prototype.dump$ = function () { + /** @type {Array.<undefined|!string>} */ + var contents; + contents = [ ]; + contents.push(Binary$dump32bitNumber$N(this._size)); + contents.push(Binary$dump32bitNumberList$AN(this._v)); + return contents.join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +BitVector.prototype.dump$LCompressionReport$ = function (report) { + /** @type {Array.<undefined|!string>} */ + var contents; + contents = [ ]; + contents.push(Binary$dump32bitNumber$N(this._size)); + CompressionReport$add$LCompressionReport$II(report, 2, 2); + contents.push(Binary$dump32bitNumberList$ANLCompressionReport$(this._v, report)); + return contents.join(''); +}; + +/** + * @param {!string} data + * @return {!number} + */ +BitVector.prototype.load$S = function (data) { + return this.load$SI(data, 0); +}; + +/** + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +BitVector.prototype.load$SI = function (data, offset) { + /** @type {LoadedNumberListResult} */ + var result; + /** @type {!number} */ + var result$0; + this._v.length = 0; + this._r.length = 0; + this._size = 0; + this._size1 = 0; + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + this._size = (result$0 | 0); + result = Binary$load32bitNumberList$SI(data, offset + 2); + this._v = result.result; + this.build$(); + return result.offset; +}; + +/** + * class WaveletMatrix extends Object + * @constructor + */ +function WaveletMatrix() { +} + +/** + * @constructor + */ +function WaveletMatrix$() { + /** @type {Array.<undefined|BitVector>} */ + var _bv$0; + /** @type {Array.<undefined|!number>} */ + var _seps$0; + this._range = ({ }); + _bv$0 = this._bv = [ ]; + _seps$0 = this._seps = [ ]; + this._bitsize = 16; + _bv$0.length = 0; + _seps$0.length = 0; + this._size = 0; +}; + +WaveletMatrix$.prototype = new WaveletMatrix; + +/** + * @return {!number} + */ +WaveletMatrix.prototype.bitsize$ = function () { + return this._bitsize; +}; + +/** + * @param {!number} charCode + */ +WaveletMatrix.prototype.setMaxCharCode$I = function (charCode) { + this._bitsize = (Math.ceil(Math.log(charCode) / 0.6931471805599453) | 0); +}; + +/** + */ +WaveletMatrix.prototype.clear$ = function () { + this._bv.length = 0; + this._seps.length = 0; + this._size = 0; +}; + +/** + * @param {!string} v + */ +WaveletMatrix.prototype.build$S = function (v) { + /** @type {!number} */ + var size; + /** @type {!number} */ + var bitsize; + /** @type {!number} */ + var i; + /** @type {!number} */ + var depth; + /** @type {Object.<string, undefined|!number>} */ + var range_tmp; + /** @type {!number} */ + var code; + /** @type {!boolean} */ + var bit; + /** @type {!number} */ + var key; + /** @type {Object.<string, undefined|!number>} */ + var range_rev; + /** @type {!string} */ + var range_key; + /** @type {!number} */ + var value; + /** @type {!number} */ + var pos0; + /** @type {undefined|!number} */ + var pos1; + /** @type {!string} */ + var range_rev_key; + /** @type {!number} */ + var begin; + /** @type {undefined|!number} */ + var end; + /** @type {!number} */ + var num0; + /** @type {!number} */ + var num1; + this._bv.length = 0; + this._seps.length = 0; + this._size = 0; + size = v.length; + bitsize = this._bitsize; + for (i = 0; i < bitsize; i++) { + this._bv.push(new BitVector$()); + this._seps.push(0); + } + this._size = (size | 0); + for (i = 0; i < size; i++) { + this._bv[0].set$IB(i, this._uint2bit$II(v.charCodeAt(i), 0)); + } + this._bv[0].build$(); + this._seps[0] = this._bv[0].size$B(false); + this._range["0"] = 0; + this._range["1"] = this._seps[0]; + depth = 1; + while (depth < bitsize) { + range_tmp = WaveletMatrix$_shallow_copy$HI(this._range); + for (i = 0; i < size; i++) { + code = v.charCodeAt(i); + bit = this._uint2bit$II(code, depth); + key = code >>> bitsize - depth; + this._bv[depth].set$IB(range_tmp[key + ""], bit); + range_tmp[key + ""]++; + } + this._bv[depth].build$(); + this._seps[depth] = this._bv[depth].size$B(false); + range_rev = ({ }); + for (range_key in this._range) { + value = this._range[range_key]; + if (value != range_tmp[range_key]) { + range_rev[value + ""] = range_key | 0; + } + } + this._range = ({ }); + pos0 = 0; + pos1 = this._seps[depth]; + for (range_rev_key in range_rev) { + begin = range_rev_key | 0; + value = range_rev[range_rev_key]; + end = range_tmp[value + ""]; + num0 = this._bv[depth].rank$IB(end, false) - this._bv[depth].rank$IB(begin, false); + num1 = end - begin - num0; + if (num0 > 0) { + this._range[(value << 1) + ""] = (pos0 | 0); + pos0 += num0; + } + if (num1 > 0) { + this._range[(value << 1) + 1 + ""] = pos1; + pos1 += (num1 | 0); + } + } + depth++; + } +}; + +/** + * @return {!number} + */ +WaveletMatrix.prototype.size$ = function () { + return this._size; +}; + +/** + * @param {!number} c + * @return {!number} + */ +WaveletMatrix.prototype.size$I = function (c) { + return this.rank$II(this._size, c); +}; + +/** + * @param {!number} i + * @return {!number} + */ +WaveletMatrix.prototype.get$I = function (i) { + /** @type {!number} */ + var value; + /** @type {!number} */ + var depth; + /** @type {!boolean} */ + var bit; + if (i >= this._size) { + throw new Error("WaveletMatrix.get() : range error"); + } + value = 0; + depth = 0; + while (depth < this._bitsize) { + bit = this._bv[depth].get$I(i); + i = this._bv[depth].rank$IB(i, bit); + value <<= 1; + if (bit) { + i += this._seps[depth]; + value += 1; + } + depth++; + } + return (value | 0); +}; + +/** + * @param {!number} i + * @param {!number} c + * @return {!number} + */ +WaveletMatrix.prototype.rank$II = function (i, c) { + /** @type {undefined|!number} */ + var begin; + /** @type {!number} */ + var end; + /** @type {!number} */ + var depth; + /** @type {!boolean} */ + var bit; + if (i > this._size) { + throw new Error("WaveletMatrix.rank(): range error"); + } + if (i === 0) { + return 0; + } + begin = this._range[c + ""]; + if (begin == null) { + return 0; + } + end = i; + depth = 0; + while (depth < this._bitsize) { + bit = this._uint2bit$II(c, depth); + end = this._bv[depth].rank$IB(end, bit); + if (bit) { + end += this._seps[depth]; + } + depth++; + } + return (end - begin | 0); +}; + +/** + * @param {!number} i + * @param {!number} c + * @return {!number} + */ +WaveletMatrix.prototype.rank_less_than$II = function (i, c) { + /** @type {!number} */ + var begin; + /** @type {!number} */ + var end; + /** @type {!number} */ + var depth; + /** @type {!number} */ + var rlt; + /** @type {!number} */ + var rank0_begin; + /** @type {!number} */ + var rank0_end; + /** @type {Array.<undefined|!number>} */ + var _seps$0; + if (i > this._size) { + throw new Error("WaveletMatrix.rank_less_than(): range error"); + } + if (i === 0) { + return 0; + } + begin = 0; + end = i; + depth = 0; + rlt = 0; + while (depth < this._bitsize) { + rank0_begin = this._bv[depth].rank$IB(begin, false); + rank0_end = this._bv[depth].rank$IB(end, false); + if (this._uint2bit$II(c, depth)) { + rlt += rank0_end - rank0_begin; + begin += (_seps$0 = this._seps)[depth] - rank0_begin; + end += _seps$0[depth] - rank0_end; + } else { + begin = rank0_begin; + end = rank0_end; + } + depth++; + } + return (rlt | 0); +}; + +/** + * @return {!string} + */ +WaveletMatrix.prototype.dump$ = function () { + /** @type {Array.<undefined|!string>} */ + var contents; + /** @type {!number} */ + var i; + /** @type {Array.<undefined|!string>} */ + var range_contents; + /** @type {!number} */ + var counter; + /** @type {!string} */ + var key; + contents = [ Binary$dump16bitNumber$I(this._bitsize), Binary$dump32bitNumber$N(this._size) ]; + for (i = 0; i < this._bitsize; i++) { + contents.push(this._bv[i].dump$()); + } + for (i = 0; i < this._bitsize; i++) { + contents.push(Binary$dump32bitNumber$N(this._seps[i])); + } + range_contents = [ ]; + counter = 0; + for (key in this._range) { + range_contents.push(Binary$dump32bitNumber$N(key | 0)); + range_contents.push(Binary$dump32bitNumber$N(this._range[key])); + counter++; + } + contents.push(Binary$dump32bitNumber$N(counter)); + return contents.join('') + range_contents.join(''); +}; + +/** + * @param {CompressionReport} report + * @return {!string} + */ +WaveletMatrix.prototype.dump$LCompressionReport$ = function (report) { + /** @type {Array.<undefined|!string>} */ + var contents; + /** @type {!number} */ + var i; + /** @type {Array.<undefined|!string>} */ + var range_contents; + /** @type {!number} */ + var counter; + /** @type {!string} */ + var key; + contents = [ Binary$dump16bitNumber$I(this._bitsize), Binary$dump32bitNumber$N(this._size) ]; + CompressionReport$add$LCompressionReport$II(report, 3, 3); + for (i = 0; i < this._bitsize; i++) { + contents.push(this._bv[i].dump$LCompressionReport$(report)); + } + for (i = 0; i < this._bitsize; i++) { + contents.push(Binary$dump32bitNumber$N(this._seps[i])); + CompressionReport$add$LCompressionReport$II(report, 2, 2); + } + range_contents = [ ]; + counter = 0; + for (key in this._range) { + range_contents.push(Binary$dump32bitNumber$N(key | 0)); + range_contents.push(Binary$dump32bitNumber$N(this._range[key])); + CompressionReport$add$LCompressionReport$II(report, 4, 4); + counter++; + } + CompressionReport$add$LCompressionReport$II(report, 2, 2); + contents.push(Binary$dump32bitNumber$N(counter)); + return contents.join('') + range_contents.join(''); +}; + +/** + * @param {!string} data + * @return {!number} + */ +WaveletMatrix.prototype.load$S = function (data) { + return this.load$SI(data, 0); +}; + +/** + * @param {!string} data + * @param {!number} offset + * @return {!number} + */ +WaveletMatrix.prototype.load$SI = function (data, offset) { + /** @type {!number} */ + var i; + /** @type {BitVector} */ + var bit_vector; + /** @type {!number} */ + var range_size; + /** @type {!number} */ + var value; + /** @type {!number} */ + var offset$0; + /** @type {!number} */ + var result$0; + /** @type {!number} */ + var result$1; + /** @type {!number} */ + var result$2; + this._bv.length = 0; + this._seps.length = 0; + this._size = 0; + offset$0 = offset++; + this._bitsize = (data.charCodeAt(offset$0) | 0); + result$0 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + this._size = (result$0 | 0); + offset += 2; + for (i = 0; i < this._bitsize; i++) { + bit_vector = new BitVector$(); + offset = bit_vector.load$SI(data, offset); + this._bv.push(bit_vector); + } + for (i = 0; i < this._bitsize; (i++, offset += 2)) { + this._seps.push(Binary$load32bitNumber$SI(data, offset)); + } + result$1 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + range_size = result$1; + offset += 2; + for (i = 0; i < range_size; (i++, offset += 4)) { + result$2 = data.charCodeAt(offset) * 65536 + data.charCodeAt(offset + 1); + value = Binary$load32bitNumber$SI(data, offset + 2); + this._range[result$2 + ""] = (value | 0); + } + return offset; +}; + +/** + * @param {Object.<string, undefined|!number>} input + * @return {Object.<string, undefined|!number>} + */ +WaveletMatrix._shallow_copy$HI = function (input) { + /** @type {Object.<string, undefined|!number>} */ + var result; + /** @type {!string} */ + var key; + result = ({ }); + for (key in input) { + result[key] = input[key]; + } + return result; +}; + +var WaveletMatrix$_shallow_copy$HI = WaveletMatrix._shallow_copy$HI; + +/** + * @param {!number} c + * @param {!number} i + * @return {!boolean} + */ +WaveletMatrix.prototype._uint2bit$II = function (c, i) { + return (c >>> this._bitsize - 1 - i & 0x1) === 0x1; +}; + +/** + * class BurrowsWheelerTransform extends Object + * @constructor + */ +function BurrowsWheelerTransform() { +} + +/** + * @constructor + */ +function BurrowsWheelerTransform$() { + this._str = ""; + this._size = 0; + this._head = 0; + this._suffixarray = [ ]; +}; + +BurrowsWheelerTransform$.prototype = new BurrowsWheelerTransform; + +/** + * @param {BurrowsWheelerTransform} $this + * @return {!number} + */ +BurrowsWheelerTransform.size$LBurrowsWheelerTransform$ = function ($this) { + return $this._size; +}; + +var BurrowsWheelerTransform$size$LBurrowsWheelerTransform$ = BurrowsWheelerTransform.size$LBurrowsWheelerTransform$; + +/** + * @param {BurrowsWheelerTransform} $this + * @return {!number} + */ +BurrowsWheelerTransform.head$LBurrowsWheelerTransform$ = function ($this) { + return $this._head; +}; + +var BurrowsWheelerTransform$head$LBurrowsWheelerTransform$ = BurrowsWheelerTransform.head$LBurrowsWheelerTransform$; + +/** + * @param {BurrowsWheelerTransform} $this + */ +BurrowsWheelerTransform.clear$LBurrowsWheelerTransform$ = function ($this) { + $this._str = ""; + $this._size = 0; + $this._head = 0; + $this._suffixarray.length = 0; +}; + +var BurrowsWheelerTransform$clear$LBurrowsWheelerTransform$ = BurrowsWheelerTransform.clear$LBurrowsWheelerTransform$; + +/** + * @param {BurrowsWheelerTransform} $this + * @param {!string} str + */ +BurrowsWheelerTransform.build$LBurrowsWheelerTransform$S = function ($this, str) { + /** @type {!string} */ + var _str$0; + /** @type {Array.<undefined|!number>} */ + var _suffixarray$0; + _str$0 = $this._str = str; + $this._size = _str$0.length; + _suffixarray$0 = $this._suffixarray = SAIS$make$S(str); + $this._head = (_suffixarray$0.indexOf(0) | 0); +}; + +var BurrowsWheelerTransform$build$LBurrowsWheelerTransform$S = BurrowsWheelerTransform.build$LBurrowsWheelerTransform$S; + +/** + * @param {BurrowsWheelerTransform} $this + * @param {!number} i + * @return {!string} + */ +BurrowsWheelerTransform.get$LBurrowsWheelerTransform$I = function ($this, i) { + /** @type {!number} */ + var size; + /** @type {!number} */ + var index; + size = $this._size; + if (i >= size) { + throw new Error("BurrowsWheelerTransform.get() : range error"); + } + index = ($this._suffixarray[i] + size - 1) % size; + return $this._str.charAt(index); +}; + +var BurrowsWheelerTransform$get$LBurrowsWheelerTransform$I = BurrowsWheelerTransform.get$LBurrowsWheelerTransform$I; + +/** + * @param {BurrowsWheelerTransform} $this + * @return {!string} + */ +BurrowsWheelerTransform.get$LBurrowsWheelerTransform$ = function ($this) { + /** @type {Array.<undefined|!string>} */ + var str; + /** @type {!number} */ + var size; + /** @type {!number} */ + var i; + str = [ ]; + size = $this._size; + for (i = 0; i < size; i++) { + str.push(BurrowsWheelerTransform$get$LBurrowsWheelerTransform$I($this, i)); + } + return str.join(""); +}; + +var BurrowsWheelerTransform$get$LBurrowsWheelerTransform$ = BurrowsWheelerTransform.get$LBurrowsWheelerTransform$; + +/** + * @param {BurrowsWheelerTransform} $this + * @param {!string} replace + * @return {!string} + */ +BurrowsWheelerTransform.get$LBurrowsWheelerTransform$S = function ($this, replace) { + /** @type {!string} */ + var result; + result = BurrowsWheelerTransform$get$LBurrowsWheelerTransform$($this); + return result.replace(BurrowsWheelerTransform.END_MARKER, replace); +}; + +var BurrowsWheelerTransform$get$LBurrowsWheelerTransform$S = BurrowsWheelerTransform.get$LBurrowsWheelerTransform$S; + +/** + * class OArray extends Object + * @constructor + */ +function OArray() { +} + +/** + * @constructor + * @param {Array.<undefined|!number>} array + */ +function OArray$AI(array) { + this.array = array; + this.offset = 0; +}; + +OArray$AI.prototype = new OArray; + +/** + * @constructor + * @param {Array.<undefined|!number>} array + * @param {!number} offset + */ +function OArray$AII(array, offset) { + this.array = array; + this.offset = offset; +}; + +OArray$AII.prototype = new OArray; + +/** + * @param {OArray} $this + * @param {!number} index + * @return {!number} + */ +OArray.get$LOArray$I = function ($this, index) { + return $this.array[index + $this.offset]; +}; + +var OArray$get$LOArray$I = OArray.get$LOArray$I; + +/** + * @param {OArray} $this + * @param {!number} index + * @param {!number} value + */ +OArray.set$LOArray$II = function ($this, index, value) { + $this.array[index + $this.offset] = value; +}; + +var OArray$set$LOArray$II = OArray.set$LOArray$II; + +/** + * @param {OArray} $this + * @param {!number} index + * @return {!boolean} + */ +OArray.isS$LOArray$I = function ($this, index) { + /** @type {Array.<undefined|!number>} */ + var array$0; + /** @type {!number} */ + var offset$0; + return (array$0 = $this.array)[index + (offset$0 = $this.offset)] < array$0[index + offset$0 + 1]; +}; + +var OArray$isS$LOArray$I = OArray.isS$LOArray$I; + +/** + * @param {OArray} $this + * @param {!number} index1 + * @param {!number} index2 + * @return {!boolean} + */ +OArray.compare$LOArray$II = function ($this, index1, index2) { + /** @type {Array.<undefined|!number>} */ + var array$0; + /** @type {!number} */ + var offset$0; + return (array$0 = $this.array)[index1 + (offset$0 = $this.offset)] == array$0[index2 + offset$0]; +}; + +var OArray$compare$LOArray$II = OArray.compare$LOArray$II; + +/** + * class SAIS extends Object + * @constructor + */ +function SAIS() { +} + +/** + * @constructor + */ +function SAIS$() { +}; + +SAIS$.prototype = new SAIS; + +/** + * @param {BitVector} t + * @param {!number} i + * @return {!boolean} + */ +SAIS._isLMS$LBitVector$I = function (t, i) { + return i > 0 && t.get$I(i) && ! t.get$I(i - 1); +}; + +var SAIS$_isLMS$LBitVector$I = SAIS._isLMS$LBitVector$I; + +/** + * @param {OArray} s + * @param {Array.<undefined|!number>} bkt + * @param {!number} n + * @param {!number} K + * @param {!boolean} end + */ +SAIS._getBuckets$LOArray$AIIIB = function (s, bkt, n, K, end) { + /** @type {!number} */ + var sum; + /** @type {!number} */ + var i; + sum = 0; + for (i = 0; i <= K; i++) { + bkt[i] = 0; + } + for (i = 0; i < n; i++) { + bkt[OArray$get$LOArray$I(s, i)]++; + } + for (i = 0; i <= K; i++) { + sum += bkt[i]; + bkt[i] = ((end ? sum : sum - bkt[i]) | 0); + } +}; + +var SAIS$_getBuckets$LOArray$AIIIB = SAIS._getBuckets$LOArray$AIIIB; + +/** + * @param {BitVector} t + * @param {Array.<undefined|!number>} SA + * @param {OArray} s + * @param {Array.<undefined|!number>} bkt + * @param {!number} n + * @param {!number} K + * @param {!boolean} end + */ +SAIS._induceSAl$LBitVector$AILOArray$AIIIB = function (t, SA, s, bkt, n, K, end) { + /** @type {!number} */ + var i; + /** @type {!number} */ + var j; + SAIS$_getBuckets$LOArray$AIIIB(s, bkt, n, K, end); + for (i = 0; i < n; i++) { + j = SA[i] - 1; + if (j >= 0 && ! t.get$I(j)) { + SA[bkt[OArray$get$LOArray$I(s, j)]++] = (j | 0); + } + } +}; + +var SAIS$_induceSAl$LBitVector$AILOArray$AIIIB = SAIS._induceSAl$LBitVector$AILOArray$AIIIB; + +/** + * @param {BitVector} t + * @param {Array.<undefined|!number>} SA + * @param {OArray} s + * @param {Array.<undefined|!number>} bkt + * @param {!number} n + * @param {!number} K + * @param {!boolean} end + */ +SAIS._induceSAs$LBitVector$AILOArray$AIIIB = function (t, SA, s, bkt, n, K, end) { + /** @type {!number} */ + var i; + /** @type {!number} */ + var j; + SAIS$_getBuckets$LOArray$AIIIB(s, bkt, n, K, end); + for (i = n - 1; i >= 0; i--) { + j = SA[i] - 1; + if (j >= 0 && t.get$I(j)) { + SA[-- bkt[OArray$get$LOArray$I(s, j)]] = (j | 0); + } + } +}; + +var SAIS$_induceSAs$LBitVector$AILOArray$AIIIB = SAIS._induceSAs$LBitVector$AILOArray$AIIIB; + +/** + * @param {!string} source + * @return {Array.<undefined|!number>} + */ +SAIS.make$S = function (source) { + /** @type {Array.<undefined|!number>} */ + var charCodes; + /** @type {!number} */ + var maxCode; + /** @type {!number} */ + var i; + /** @type {!number} */ + var code; + /** @type {Array.<undefined|!number>} */ + var SA; + /** @type {OArray} */ + var s; + charCodes = [ ]; + charCodes.length = source.length; + maxCode = 0; + for (i = 0; i < source.length; i++) { + code = source.charCodeAt(i); + charCodes[i] = (code | 0); + maxCode = (code > maxCode ? code : maxCode); + } + SA = [ ]; + SA.length = source.length; + s = ({offset: 0, array: charCodes}); + SAIS$_make$LOArray$AIII(s, SA, source.length, maxCode); + return SA; +}; + +var SAIS$make$S = SAIS.make$S; + +/** + * @param {OArray} s + * @param {Array.<undefined|!number>} SA + * @param {!number} n + * @param {!number} K + */ +SAIS._make$LOArray$AIII = function (s, SA, n, K) { + /** @type {BitVector} */ + var t; + /** @type {!number} */ + var i; + /** @type {Array.<undefined|!number>} */ + var bkt; + /** @type {!number} */ + var n1; + /** @type {!number} */ + var name; + /** @type {!number} */ + var prev; + /** @type {undefined|!number} */ + var pos; + /** @type {!boolean} */ + var diff; + /** @type {!number} */ + var d; + /** @type {!number} */ + var j; + /** @type {Array.<undefined|!number>} */ + var SA1; + /** @type {OArray} */ + var s1; + /** @type {!number} */ + var i$0; + /** @type {!number} */ + var index$0; + t = new BitVector$(); + t.set$IB(n - 2, false); + t.set$IB(n - 1, true); + for (i = n - 3; i >= 0; i--) { + t.set$IB(i, OArray$isS$LOArray$I(s, i) || OArray$compare$LOArray$II(s, i, i + 1) && t.get$I(i + 1)); + } + bkt = [ ]; + bkt.length = K + 1; + SAIS$_getBuckets$LOArray$AIIIB(s, bkt, n, K, true); + for (i = 0; i < n; i++) { + SA[i] = -1; + } + for (i = 1; i < n; i++) { + if (SAIS$_isLMS$LBitVector$I(t, i)) { + SA[-- bkt[OArray$get$LOArray$I(s, i)]] = (i | 0); + } + } + SAIS$_induceSAl$LBitVector$AILOArray$AIIIB(t, SA, s, bkt, n, K, false); + SAIS$_induceSAs$LBitVector$AILOArray$AIIIB(t, SA, s, bkt, n, K, true); + n1 = 0; + for (i = 0; i < n; i++) { + i$0 = SA[i]; + if (i$0 > 0 && t.get$I(i$0) && ! t.get$I(i$0 - 1)) { + SA[n1++] = SA[i]; + } + } + for (i = n1; i < n; i++) { + SA[i] = -1; + } + name = 0; + prev = -1; + for (i = 0; i < n1; i++) { + pos = SA[i]; + diff = false; + for (d = 0; d < n; d++) { + if (prev === -1 || ! OArray$compare$LOArray$II(s, pos + d, prev + d) || t.get$I(pos + d) !== t.get$I(prev + d)) { + diff = true; + break; + } else { + if (d > 0 && (SAIS$_isLMS$LBitVector$I(t, pos + d) || SAIS$_isLMS$LBitVector$I(t, prev + d))) { + break; + } + } + } + if (diff) { + name++; + prev = pos; + } + pos = ((pos % 2 === 0 ? pos / 2 : (pos - 1) / 2) | 0); + SA[n1 + pos] = (name - 1 | 0); + } + for ((i = n - 1, j = n - 1); i >= n1; i--) { + if (SA[i] >= 0) { + SA[j--] = SA[i]; + } + } + SA1 = SA; + s1 = ({offset: n - n1, array: SA}); + if (name < n1) { + SAIS$_make$LOArray$AIII(s1, SA1, n1, name - 1); + } else { + for (i = 0; i < n1; i++) { + SA1[OArray$get$LOArray$I(s1, i)] = (i | 0); + } + } + bkt = [ ]; + bkt.length = K + 1; + SAIS$_getBuckets$LOArray$AIIIB(s, bkt, n, K, true); + for ((i = 1, j = 0); i < n; i++) { + if (SAIS$_isLMS$LBitVector$I(t, i)) { + OArray$set$LOArray$II(s1, j++, i); + } + } + for (i = 0; i < n1; i++) { + index$0 = SA1[i]; + SA1[i] = s1.array[index$0 + s1.offset]; + } + for (i = n1; i < n; i++) { + SA[i] = -1; + } + for (i = n1 - 1; i >= 0; i--) { + j = SA[i]; + SA[i] = -1; + SA[-- bkt[OArray$get$LOArray$I(s, j)]] = (j | 0); + } + SAIS$_induceSAl$LBitVector$AILOArray$AIIIB(t, SA, s, bkt, n, K, false); + SAIS$_induceSAs$LBitVector$AILOArray$AIIIB(t, SA, s, bkt, n, K, true); +}; + +var SAIS$_make$LOArray$AIII = SAIS._make$LOArray$AIII; + +OktaviaSearch._stemmer = null; +OktaviaSearch._instance = null; +$__jsx_lazy_init(Oktavia, "eof", function () { + return String.fromCharCode(0); +}); +$__jsx_lazy_init(Oktavia, "eob", function () { + return String.fromCharCode(1); +}); +$__jsx_lazy_init(Oktavia, "unknown", function () { + return String.fromCharCode(3); +}); +Binary._base64EncodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +$__jsx_lazy_init(Binary, "_base64DecodeChars", function () { + return [ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 ]; +}); +$__jsx_lazy_init(Style, "console", function () { + return ({ 'title': [ '\x1B[32m\x1b[4m', '\x1B[39m\x1b[0m' ], 'url': [ '\x1B[34m', '\x1B[39m' ], 'hit': [ '\x1B[4m', '\x1B[0m' ], 'del': [ '\x1B[9m', '\x1B[0m' ], 'summary': [ '\x1B[90m', '\x1B[39m' ] }); +}); +$__jsx_lazy_init(Style, "html", function () { + return ({ 'title': [ '<span class="title">', '</span>' ], 'url': [ '<span class="url">', '</span>' ], 'hit': [ '<span class="hit">', '</span>' ], 'del': [ '<del>', '</del>' ], 'summary': [ '<span class="reuslt">', '</span>' ] }); +}); +$__jsx_lazy_init(Style, "ignore", function () { + return ({ 'tilte': [ '', '' ], 'url': [ '', '' ], 'hit': [ '', '' ], 'del': [ '', '' ], 'summary': [ '', '' ] }); +}); +$__jsx_lazy_init(_Common, "buffers", function () { + return [ "comment", "sgmlDecl", "textNode", "tagName", "doctype", "procInstName", "procInstBody", "entity", "attribName", "attribValue", "cdata", "script" ]; +}); +$__jsx_lazy_init(_Common, "EVENTS", function () { + return [ "text", "processinginstruction", "sgmldeclaration", "doctype", "comment", "attribute", "opentag", "closetag", "opencdata", "cdata", "clo_State.CDATA", "error", "end", "ready", "script", "opennamespace", "closenamespace" ]; +}); +_Common.MAX_BUFFER_LENGTH = 65536; +_State.BEGIN = 1; +_State.TEXT = 2; +_State.TEXT_ENTITY = 3; +_State.OPEN_WAKA = 4; +_State.SGML_DECL = 5; +_State.SGML_DECL_QUOTED = 6; +_State.DOCTYPE = 7; +_State.DOCTYPE_QUOTED = 8; +_State.DOCTYPE_DTD = 9; +_State.DOCTYPE_DTD_QUOTED = 10; +_State.COMMENT_STARTING = 11; +_State.COMMENT = 12; +_State.COMMENT_ENDING = 13; +_State.COMMENT_ENDED = 14; +_State.CDATA = 15; +_State.CDATA_ENDING = 16; +_State.CDATA_ENDING_2 = 17; +_State.PROC_INST = 18; +_State.PROC_INST_BODY = 19; +_State.PROC_INST_ENDING = 20; +_State.OPEN_TAG = 21; +_State.OPEN_TAG_SLASH = 22; +_State.ATTRIB = 23; +_State.ATTRIB_NAME = 24; +_State.ATTRIB_NAME_SAW_WHITE = 25; +_State.ATTRIB_VALUE = 26; +_State.ATTRIB_VALUE_QUOTED = 27; +_State.ATTRIB_VALUE_UNQUOTED = 28; +_State.ATTRIB_VALUE_ENTITY_Q = 29; +_State.ATTRIB_VALUE_ENTITY_U = 30; +_State.CLOSE_TAG = 31; +_State.CLOSE_TAG_SAW_WHITE = 32; +_State.SCRIPT = 33; +_State.SCRIPT_ENDING = 34; +$__jsx_lazy_init(_Entities, "_entities", function () { + return ({ "amp": "&", "gt": ">", "lt": "<", "quot": "\"", "apos": "'", "AElig": 198, "Aacute": 193, "Acirc": 194, "Agrave": 192, "Aring": 197, "Atilde": 195, "Auml": 196, "Ccedil": 199, "ETH": 208, "Eacute": 201, "Ecirc": 202, "Egrave": 200, "Euml": 203, "Iacute": 205, "Icirc": 206, "Igrave": 204, "Iuml": 207, "Ntilde": 209, "Oacute": 211, "Ocirc": 212, "Ograve": 210, "Oslash": 216, "Otilde": 213, "Ouml": 214, "THORN": 222, "Uacute": 218, "Ucirc": 219, "Ugrave": 217, "Uuml": 220, "Yacute": 221, "aacute": 225, "acirc": 226, "aelig": 230, "agrave": 224, "aring": 229, "atilde": 227, "auml": 228, "ccedil": 231, "eacute": 233, "ecirc": 234, "egrave": 232, "eth": 240, "euml": 235, "iacute": 237, "icirc": 238, "igrave": 236, "iuml": 239, "ntilde": 241, "oacute": 243, "ocirc": 244, "ograve": 242, "oslash": 248, "otilde": 245, "ouml": 246, "szlig": 223, "thorn": 254, "uacute": 250, "ucirc": 251, "ugrave": 249, "uuml": 252, "yacute": 253, "yuml": 255, "copy": 169, "reg": 174, "nbsp": 160, "iexcl": 161, "cent": 162, "pound": 163, "curren": 164, "yen": 165, "brvbar": 166, "sect": 167, "uml": 168, "ordf": 170, "laquo": 171, "not": 172, "shy": 173, "macr": 175, "deg": 176, "plusmn": 177, "sup1": 185, "sup2": 178, "sup3": 179, "acute": 180, "micro": 181, "para": 182, "middot": 183, "cedil": 184, "ordm": 186, "raquo": 187, "frac14": 188, "frac12": 189, "frac34": 190, "iquest": 191, "times": 215, "divide": 247, "OElig": 338, "oelig": 339, "Scaron": 352, "scaron": 353, "Yuml": 376, "fnof": 402, "circ": 710, "tilde": 732, "Alpha": 913, "Beta": 914, "Gamma": 915, "Delta": 916, "Epsilon": 917, "Zeta": 918, "Eta": 919, "Theta": 920, "Iota": 921, "Kappa": 922, "Lambda": 923, "Mu": 924, "Nu": 925, "Xi": 926, "Omicron": 927, "Pi": 928, "Rho": 929, "Sigma": 931, "Tau": 932, "Upsilon": 933, "Phi": 934, "Chi": 935, "Psi": 936, "Omega": 937, "alpha": 945, "beta": 946, "gamma": 947, "delta": 948, "epsilon": 949, "zeta": 950, "eta": 951, "theta": 952, "iota": 953, "kappa": 954, "lambda": 955, "mu": 956, "nu": 957, "xi": 958, "omicron": 959, "pi": 960, "rho": 961, "sigmaf": 962, "sigma": 963, "tau": 964, "upsilon": 965, "phi": 966, "chi": 967, "psi": 968, "omega": 969, "thetasym": 977, "upsih": 978, "piv": 982, "ensp": 8194, "emsp": 8195, "thinsp": 8201, "zwnj": 8204, "zwj": 8205, "lrm": 8206, "rlm": 8207, "ndash": 8211, "mdash": 8212, "lsquo": 8216, "rsquo": 8217, "sbquo": 8218, "ldquo": 8220, "rdquo": 8221, "bdquo": 8222, "dagger": 8224, "Dagger": 8225, "bull": 8226, "hellip": 8230, "permil": 8240, "prime": 8242, "Prime": 8243, "lsaquo": 8249, "rsaquo": 8250, "oline": 8254, "frasl": 8260, "euro": 8364, "image": 8465, "weierp": 8472, "real": 8476, "trade": 8482, "alefsym": 8501, "larr": 8592, "uarr": 8593, "rarr": 8594, "darr": 8595, "harr": 8596, "crarr": 8629, "lArr": 8656, "uArr": 8657, "rArr": 8658, "dArr": 8659, "hArr": 8660, "forall": 8704, "part": 8706, "exist": 8707, "empty": 8709, "nabla": 8711, "isin": 8712, "notin": 8713, "ni": 8715, "prod": 8719, "sum": 8721, "minus": 8722, "lowast": 8727, "radic": 8730, "prop": 8733, "infin": 8734, "ang": 8736, "and": 8743, "or": 8744, "cap": 8745, "cup": 8746, "int": 8747, "there4": 8756, "sim": 8764, "cong": 8773, "asymp": 8776, "ne": 8800, "equiv": 8801, "le": 8804, "ge": 8805, "sub": 8834, "sup": 8835, "nsub": 8836, "sube": 8838, "supe": 8839, "oplus": 8853, "otimes": 8855, "perp": 8869, "sdot": 8901, "lceil": 8968, "rceil": 8969, "lfloor": 8970, "rfloor": 8971, "lang": 9001, "rang": 9002, "loz": 9674, "spades": 9824, "clubs": 9827, "hearts": 9829, "diams": 9830 }); +}); +BitVector.SMALL_BLOCK_SIZE = 32; +BitVector.LARGE_BLOCK_SIZE = 256; +BitVector.BLOCK_RATE = 8; +$__jsx_lazy_init(BurrowsWheelerTransform, "END_MARKER", function () { + return String.fromCharCode(0); +}); +var $__jsx_classMap = { + "tool/web/oktavia-search.jsx": { + _Result: _Result, + _Result$SSSI: _Result$SSSI, + _Proposal: _Proposal, + _Proposal$SSI: _Proposal$SSI, + OktaviaSearch: OktaviaSearch, + OktaviaSearch$I: OktaviaSearch$I, + _Main: _Main, + _Main$: _Main$ + }, + "src/oktavia.jsx": { + Oktavia: Oktavia, + Oktavia$: Oktavia$ + }, + "src/binary-util.jsx": { + Binary: Binary, + Binary$: Binary$, + LoadedStringResult: LoadedStringResult, + LoadedStringResult$SI: LoadedStringResult$SI, + LoadedStringListResult: LoadedStringListResult, + LoadedStringListResult$SI: LoadedStringListResult$SI, + LoadedStringListMapResult: LoadedStringListMapResult, + LoadedStringListMapResult$SI: LoadedStringListMapResult$SI, + LoadedNumberListResult: LoadedNumberListResult, + LoadedNumberListResult$SI: LoadedNumberListResult$SI, + CompressionReport: CompressionReport, + CompressionReport$: CompressionReport$ + }, + "src/query.jsx": { + Query: Query, + Query$: Query$ + }, + "src/query-string-parser.jsx": { + QueryStringParser: QueryStringParser, + QueryStringParser$: QueryStringParser$ + }, + "src/search-result.jsx": { + Proposal: Proposal, + Proposal$II: Proposal$II, + Position: Position, + Position$SIB: Position$SIB, + SearchUnit: SearchUnit, + SearchUnit$I: SearchUnit$I, + SingleResult: SingleResult, + SingleResult$: SingleResult$, + SingleResult$SBB: SingleResult$SBB, + SearchSummary: SearchSummary, + SearchSummary$: SearchSummary$, + SearchSummary$LOktavia$: SearchSummary$LOktavia$ + }, + "src/style.jsx": { + Style: Style, + Style$S: Style$S, + _HTMLHandler: _HTMLHandler, + _HTMLHandler$HASB: _HTMLHandler$HASB + }, + "src/stemmer/stemmer.jsx": { + Stemmer: Stemmer, + Stemmer$: Stemmer$ + }, + "src/metadata.jsx": { + Metadata: Metadata, + Metadata$LOktavia$: Metadata$LOktavia$, + Section: Section, + Section$LOktavia$: Section$LOktavia$, + Splitter: Splitter, + Splitter$LOktavia$: Splitter$LOktavia$, + Splitter$LOktavia$S: Splitter$LOktavia$S, + Table: Table, + Table$LOktavia$AS: Table$LOktavia$AS, + Block: Block, + Block$LOktavia$: Block$LOktavia$ + }, + "src/fm-index.jsx": { + FMIndex: FMIndex, + FMIndex$: FMIndex$ + }, + "src/sax.jsx": { + Tag: Tag, + Tag$S: Tag$S, + _Common: _Common, + _Common$: _Common$, + _State: _State, + _State$: _State$, + SAXHandler: SAXHandler, + SAXHandler$: SAXHandler$, + SAXParser: SAXParser, + SAXParser$LSAXHandler$: SAXParser$LSAXHandler$, + SAXParser$LSAXHandler$B: SAXParser$LSAXHandler$B, + Char: Char, + Char$: Char$, + _Entities: _Entities, + _Entities$: _Entities$ + }, + "src/bit-vector.jsx": { + BitVector: BitVector, + BitVector$: BitVector$ + }, + "src/wavelet-matrix.jsx": { + WaveletMatrix: WaveletMatrix, + WaveletMatrix$: WaveletMatrix$ + }, + "src/burrows-wheeler-transform.jsx": { + BurrowsWheelerTransform: BurrowsWheelerTransform, + BurrowsWheelerTransform$: BurrowsWheelerTransform$ + }, + "src/sais.jsx": { + OArray: OArray, + OArray$AI: OArray$AI, + OArray$AII: OArray$AII, + SAIS: SAIS, + SAIS$: SAIS$ + } +}; + + +/** + * launches _Main.main(:string[]):void invoked by jsx --run|--executable + */ +JSX.runMain = function (sourceFile, args) { + var module = JSX.require(sourceFile); + if (! module) { + throw new ReferenceError("entry point module not found in " + sourceFile); + } + if (! module._Main) { + throw new ReferenceError("entry point _Main not found in " + sourceFile); + } + if (! module._Main.main$AS) { + throw new ReferenceError("entry point _Main.main(:string[]):void not found in " + sourceFile); + } + module._Main.main$AS(args); +}; + +/** + * launches _Test#test*():void invoked by jsx --test + */ +JSX.runTests = function (sourceFile, tests) { + var module = JSX.require(sourceFile); + var testClass = module._Test$; + + if (!testClass) return; // skip if there's no test class + + if(tests.length === 0) { + var p = testClass.prototype; + for (var m in p) { + if (p[m] instanceof Function + && /^test.*[$]$/.test(m)) { + tests.push(m); + } + } + } + else { // set as process arguments + tests = tests.map(function (name) { + return name + "$"; // mangle for function test*():void + }); + } + + var testCase = new testClass(); + + if (testCase.beforeClass$AS != null) + testCase.beforeClass$AS(tests); + + for (var i = 0; i < tests.length; ++i) { + (function (method) { + if (method in testCase) { + testCase.run$SF$V$(method, function() { testCase[method](); }); + } + else { + throw new ReferenceError("No such test method: " + method); + } + }(tests[i])); + } + + if (testCase.afterClass$ != null) + testCase.afterClass$(); +}; +/** + * call a function on load/DOMContentLoaded + */ +function $__jsx_onload (event) { + window.removeEventListener("load", $__jsx_onload); + document.removeEventListener("DOMContentLoaded", $__jsx_onload); + JSX.runMain("tool/web/oktavia-search.jsx", []) +} + +window.addEventListener("load", $__jsx_onload); +document.addEventListener("DOMContentLoaded", $__jsx_onload); + +})(JSX); diff --git a/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/searchstyle.css b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/searchstyle.css new file mode 100644 index 000000000..a3d51d436 --- /dev/null +++ b/web/server/h2o/libh2o/misc/oktavia/templates/sphinx/_static/searchstyle.css @@ -0,0 +1,174 @@ +form.oktavia_form { + position: relative; + display: block; + width: 240px; + height: 25px; +} + +input.oktavia_search { + -webkit-appearance: searchfield; + -webkit-user-select: text; + cursor: auto; + background-color: white; + color: black; + line-height: normal; + display: inline-block; + padding: 1px; + text-align: start; + margin: 2px 0px 2px 0px; + padding: 1px; +} + +div.oktavia_searchresult_box { + display: none; + position: absolute; + width: 500px; + padding: 10px; + right: 10px; + background-color: #ffffff; + -moz-border-radius: 8px; + border-radius: 8px; + -moz-box-shadow: 3px 3px 5px 5px #b5b2b2; + box-shadow: 3px 3px 5px 5px #b5b2b2; + opacity: 0.95; + z-index: 100000; +} + +div.oktavia_close_search_box { + position: absolute; + top: 10px; + right: 10px; + width: 20px; + height: 20px; + text-align: center; + vertical-align: middle; + color: #666; +} + +div.oktavia_close_search_box:hover { + background-color: #d1e8ff; + border: 1px solid gray; +} + +div.oktavia_close_search_box:active { + background-color: #b4c8db; + border: 1px solid gray; +} + + +div.oktavia_searchresult_summary { + color: #444; +} + +div.oktavia_searchresult .entry { + margin: 10px 10px 10px 10px; + color: black; +} + +div.oktavia_searchresult .entry .title { + font-size: normal; +} + +div.oktavia_searchresult .entry .title a:link { + color: #0000EE; + text-decoration: underline; +} + +div.oktavia_searchresult .entry .title a:visited { + color: #551A8B; + text-decoration: underline; +} + +div.oktavia_searchresult .entry .title a:hover { +} + +div.oktavia_searchresult .entry .title a:active { + color: #FF0000; + text-decoration: underline; +} + +div.oktavia_searchresult .entry .url { + font-size: 14px!important; + color: #093; + font-style: normal; + font-family: arial,sans-serif; +} + +div.oktavia_searchresult .entry .resultcontent { + font-size: small; + font-family: arial,sans-serif; + color: #222; +} + +div.oktavia_searchresult .entry .resultcontent .hit { + font-weight: bolder; + text-decoration: underline; +} + +div.oktavia_searchresult .proposal { + margin: 10px 10px 10px 10px; + color: #222; + font-size: small; + font-family: arial,sans-serif; +} + +div.oktavia_searchresult .proposal .option { + background-color: #e8f4ff; + border-bottom: 1px solid blue; +} + +div.oktavia_searchresult .proposal .option:hover { + background-color: #d1e8ff; +} + +div.oktavia_searchresult .proposal .option:active { + background-color: #b4c8db; +} + +div.oktavia_searchresult_nav span.leader { + color: #228; +} + +div.oktavia_searchresult_nav span.page { + background-color: #ffffff; + border: 1px solid #888888; + padding: 5px; + margin: 5px; + color: #222; +} + +div.oktavia_searchresult_nav span.page:hover { + background-color: #d1e8ff; + border: 1px solid #7d98ff; +} + +div.oktavia_searchresult_nav span.page:active { + background-color: #b4c8db; + border: 1px solid #6c83db; +} + +div.oktavia_searchresult_nav span.selected { + background-color: #b4c8db; + border: 1px solid #6c83db; +} + +div.oktavia_searchresult_nav span.selected:hover { + background-color: #b4c8db; + border: 1px solid #6c83db; +} + +div.oktavia_searchresult_nav span.selected:active { + background-color: #b4c8db; + border: 1px solid #6c83db; +} + +div.oktavia_searchresult_box span.pr { + position: absolute; + right: 10px; + bottom: 10px; + color: #555; +} + +.highlighted { + background-color: #fbe54e; +} |