Java

DEV2.1/TP01/script-files/script.js

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+var moduleSearchIndex;
+var packageSearchIndex;
+var typeSearchIndex;
+var memberSearchIndex;
+var tagSearchIndex;
+
+var oddRowColor = "odd-row-color";
+var evenRowColor = "even-row-color";
+var sortAsc = "sort-asc";
+var sortDesc = "sort-desc";
+var tableTab = "table-tab";
+var activeTableTab = "active-table-tab";
+
+function loadScripts(doc, tag) {
+    createElem(doc, tag, 'script-files/search.js');
+
+    createElem(doc, tag, 'module-search-index.js');
+    createElem(doc, tag, 'package-search-index.js');
+    createElem(doc, tag, 'type-search-index.js');
+    createElem(doc, tag, 'member-search-index.js');
+    createElem(doc, tag, 'tag-search-index.js');
+}
+
+function createElem(doc, tag, path) {
+    var script = doc.createElement(tag);
+    var scriptElement = doc.getElementsByTagName(tag)[0];
+    script.src = pathtoroot + path;
+    scriptElement.parentNode.insertBefore(script, scriptElement);
+}
+
+// Helper for  making content containing release names comparable lexicographically
+function makeComparable(s) {
+    return s.toLowerCase().replace(/(\d+)/g,
+        function(n, m) {
+            return ("000" + m).slice(-4);
+        });
+}
+
+// Switches between two styles depending on a condition
+function toggleStyle(classList, condition, trueStyle, falseStyle) {
+    if (condition) {
+        classList.remove(falseStyle);
+        classList.add(trueStyle);
+    } else {
+        classList.remove(trueStyle);
+        classList.add(falseStyle);
+    }
+}
+
+// Sorts the rows in a table lexicographically by the content of a specific column
+function sortTable(header, columnIndex, columns) {
+    var container = header.parentElement;
+    var descending = header.classList.contains(sortAsc);
+    container.querySelectorAll("div.table-header").forEach(
+        function(header) {
+            header.classList.remove(sortAsc);
+            header.classList.remove(sortDesc);
+        }
+    )
+    var cells = container.children;
+    var rows = [];
+    for (var i = columns; i < cells.length; i += columns) {
+        rows.push(Array.prototype.slice.call(cells, i, i + columns));
+    }
+    var comparator = function(a, b) {
+        var ka = makeComparable(a[columnIndex].textContent);
+        var kb = makeComparable(b[columnIndex].textContent);
+        if (ka < kb)
+            return descending ? 1 : -1;
+        if (ka > kb)
+            return descending ? -1 : 1;
+        return 0;
+    };
+    var sorted = rows.sort(comparator);
+    var visible = 0;
+    sorted.forEach(function(row) {
+        if (row[0].style.display !== 'none') {
+            var isEvenRow = visible++ % 2 === 0;
+        }
+        row.forEach(function(cell) {
+            toggleStyle(cell.classList, isEvenRow, evenRowColor, oddRowColor);
+            container.appendChild(cell);
+        })
+    });
+    toggleStyle(header.classList, descending, sortDesc, sortAsc);
+}
+
+// Toggles the visibility of a table category in all tables in a page
+function toggleGlobal(checkbox, selected, columns) {
+    var display = checkbox.checked ? '' : 'none';
+    document.querySelectorAll("div.table-tabs").forEach(function(t) {
+        var id = t.parentElement.getAttribute("id");
+        var selectedClass = id + "-tab" + selected;
+        // if selected is empty string it selects all uncategorized entries
+        var selectUncategorized = !Boolean(selected);
+        var visible = 0;
+        document.querySelectorAll('div.' + id)
+            .forEach(function(elem) {
+                if (selectUncategorized) {
+                    if (elem.className.indexOf(selectedClass) === -1) {
+                        elem.style.display = display;
+                    }
+                } else if (elem.classList.contains(selectedClass)) {
+                    elem.style.display = display;
+                }
+                if (elem.style.display === '') {
+                    var isEvenRow = visible++ % (columns * 2) < columns;
+                    toggleStyle(elem.classList, isEvenRow, evenRowColor, oddRowColor);
+                }
+            });
+        var displaySection = visible === 0 ? 'none' : '';
+        t.parentElement.style.display = displaySection;
+        document.querySelector("li#contents-" + id).style.display = displaySection;
+    })
+}
+
+// Shows the elements of a table belonging to a specific category
+function show(tableId, selected, columns) {
+    if (tableId !== selected) {
+        document.querySelectorAll('div.' + tableId + ':not(.' + selected + ')')
+            .forEach(function(elem) {
+                elem.style.display = 'none';
+            });
+    }
+    document.querySelectorAll('div.' + selected)
+        .forEach(function(elem, index) {
+            elem.style.display = '';
+            var isEvenRow = index % (columns * 2) < columns;
+            toggleStyle(elem.classList, isEvenRow, evenRowColor, oddRowColor);
+        });
+    updateTabs(tableId, selected);
+}
+
+function updateTabs(tableId, selected) {
+    document.querySelector('div#' + tableId +' .summary-table')
+        .setAttribute('aria-labelledby', selected);
+    document.querySelectorAll('button[id^="' + tableId + '"]')
+        .forEach(function(tab, index) {
+            if (selected === tab.id || (tableId === selected && index === 0)) {
+                tab.className = activeTableTab;
+                tab.setAttribute('aria-selected', true);
+                tab.setAttribute('tabindex',0);
+            } else {
+                tab.className = tableTab;
+                tab.setAttribute('aria-selected', false);
+                tab.setAttribute('tabindex',-1);
+            }
+        });
+}
+
+function switchTab(e) {
+    var selected = document.querySelector('[aria-selected=true]');
+    if (selected) {
+        if ((e.keyCode === 37 || e.keyCode === 38) && selected.previousSibling) {
+            // left or up arrow key pressed: move focus to previous tab
+            selected.previousSibling.click();
+            selected.previousSibling.focus();
+            e.preventDefault();
+        } else if ((e.keyCode === 39 || e.keyCode === 40) && selected.nextSibling) {
+            // right or down arrow key pressed: move focus to next tab
+            selected.nextSibling.click();
+            selected.nextSibling.focus();
+            e.preventDefault();
+        }
+    }
+}
+
+var updateSearchResults = function() {};
+
+function indexFilesLoaded() {
+    return moduleSearchIndex
+        && packageSearchIndex
+        && typeSearchIndex
+        && memberSearchIndex
+        && tagSearchIndex;
+}
+// Copy the contents of the local snippet to the clipboard
+function copySnippet(button) {
+    copyToClipboard(button.nextElementSibling.innerText);
+    switchCopyLabel(button, button.firstElementChild);
+}
+function copyToClipboard(content) {
+    var textarea = document.createElement("textarea");
+    textarea.style.height = 0;
+    document.body.appendChild(textarea);
+    textarea.value = content;
+    textarea.select();
+    document.execCommand("copy");
+    document.body.removeChild(textarea);
+}
+function switchCopyLabel(button, span) {
+    var copied = span.getAttribute("data-copied");
+    button.classList.add("visible");
+    var initialLabel = span.innerHTML;
+    span.innerHTML = copied;
+    setTimeout(function() {
+        button.classList.remove("visible");
+        setTimeout(function() {
+            if (initialLabel !== copied) {
+                span.innerHTML = initialLabel;
+            }
+        }, 100);
+    }, 1900);
+}
+// Dynamically set scroll margin to accomodate for draft header
+document.addEventListener("DOMContentLoaded", function(e) {
+    document.querySelectorAll(':not(input)[id]').forEach(
+        function(c) {
+            c.style["scroll-margin-top"] = Math.ceil(document.querySelector("header").offsetHeight) + "px"
+        });
+});

DEV2.1/TP01/script-files/search-page.js

@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+"use strict";
+$(function() {
+    var copy = $("#page-search-copy");
+    var expand = $("#page-search-expand");
+    var searchLink = $("span#page-search-link");
+    var redirect = $("input#search-redirect");
+    function setSearchUrlTemplate() {
+        var href = document.location.href.split(/[#?]/)[0];
+        href += "?q=" + "%s";
+        if (redirect.is(":checked")) {
+            href += "&r=1";
+        }
+        searchLink.html(href);
+        copy[0].onmouseenter();
+    }
+    function copyLink(e) {
+        copyToClipboard(this.previousSibling.innerText);
+        switchCopyLabel(this, this.lastElementChild);
+    }
+    copy.click(copyLink);
+    copy[0].onmouseenter = function() {};
+    redirect.click(setSearchUrlTemplate);
+    setSearchUrlTemplate();
+    copy.prop("disabled", false);
+    redirect.prop("disabled", false);
+    expand.click(function (e) {
+        var searchInfo = $("div.page-search-info");
+        if(this.parentElement.hasAttribute("open")) {
+            searchInfo.attr("style", "border-width: 0;");
+        } else {
+            searchInfo.attr("style", "border-width: 1px;").height(searchInfo.prop("scrollHeight"));
+        }
+    });
+});
+$(window).on("load", function() {
+    var input = $("#page-search-input");
+    var reset = $("#page-search-reset");
+    var notify = $("#page-search-notify");
+    var resultSection = $("div#result-section");
+    var resultContainer = $("div#result-container");
+    var searchTerm = "";
+    var activeTab = "";
+    var fixedTab = false;
+    var visibleTabs = [];
+    var feelingLucky = false;
+    function renderResults(result) {
+        if (!result.length) {
+            notify.html(messages.noResult);
+        } else if (result.length === 1) {
+            notify.html(messages.oneResult);
+        } else {
+            notify.html(messages.manyResults.replace("{0}", result.length));
+        }
+        resultContainer.empty();
+        var r = {
+            "types": [],
+            "members": [],
+            "packages": [],
+            "modules": [],
+            "searchTags": []
+        };
+        for (var i in result) {
+            var item = result[i];
+            var arr = r[item.category];
+            arr.push(item);
+        }
+        if (!activeTab || r[activeTab].length === 0 || !fixedTab) {
+            Object.keys(r).reduce(function(prev, curr) {
+                if (r[curr].length > 0 && r[curr][0].score > prev) {
+                    activeTab = curr;
+                    return r[curr][0].score;
+                }
+                return prev;
+            }, 0);
+        }
+        if (feelingLucky && activeTab) {
+            notify.html(messages.redirecting)
+            var firstItem = r[activeTab][0];
+            window.location = getURL(firstItem.indexItem, firstItem.category);
+            return;
+        }
+        if (result.length > 20) {
+            if (searchTerm[searchTerm.length - 1] === ".") {
+                if (activeTab === "types" && r["members"].length > r["types"].length) {
+                    activeTab = "members";
+                } else if (activeTab === "packages" && r["types"].length > r["packages"].length) {
+                    activeTab = "types";
+                }
+            }
+        }
+        var categoryCount = Object.keys(r).reduce(function(prev, curr) {
+            return prev + (r[curr].length > 0 ? 1 : 0);
+        }, 0);
+        visibleTabs = [];
+        var tabContainer = $("<div class='table-tabs'></div>").appendTo(resultContainer);
+        for (var key in r) {
+            var id = "#result-tab-" + key.replace("searchTags", "search_tags");
+            if (r[key].length) {
+                var count = r[key].length >= 1000 ? "999+" : r[key].length;
+                if (result.length > 20 && categoryCount > 1) {
+                    var button = $("<button id='result-tab-" + key
+                        + "' class='page-search-header'><span>" + categories[key] + "</span>"
+                        + "<span style='font-weight: normal'> (" + count + ")</span></button>").appendTo(tabContainer);
+                    button.click(key, function(e) {
+                        fixedTab = true;
+                        renderResult(e.data, $(this));
+                    });
+                    visibleTabs.push(key);
+                } else {
+                    $("<span class='page-search-header active-table-tab'>" + categories[key]
+                        + "<span style='font-weight: normal'> (" + count + ")</span></span>").appendTo(tabContainer);
+                    renderTable(key, r[key]).appendTo(resultContainer);
+                    tabContainer = $("<div class='table-tabs'></div>").appendTo(resultContainer);
+
+                }
+            }
+        }
+        if (activeTab && result.length > 20 && categoryCount > 1) {
+            $("button#result-tab-" + activeTab).addClass("active-table-tab");
+            renderTable(activeTab, r[activeTab]).appendTo(resultContainer);
+        }
+        resultSection.show();
+        function renderResult(category, button) {
+            activeTab = category;
+            setSearchUrl();
+            resultContainer.find("div.summary-table").remove();
+            renderTable(activeTab, r[activeTab]).appendTo(resultContainer);
+            button.siblings().removeClass("active-table-tab");
+            button.addClass("active-table-tab");
+        }
+    }
+    function selectTab(category) {
+        $("button#result-tab-" + category).click();
+    }
+    function renderTable(category, items) {
+        var table = $("<div class='summary-table'>")
+            .addClass(category === "modules"
+                ? "one-column-search-results"
+                : "two-column-search-results");
+        var col1, col2;
+        if (category === "modules") {
+            col1 = "Module";
+        } else if (category === "packages") {
+            col1 = "Module";
+            col2 = "Package";
+        } else if (category === "types") {
+            col1 = "Package";
+            col2 = "Class"
+        } else if (category === "members") {
+            col1 = "Class";
+            col2 = "Member";
+        } else if (category === "searchTags") {
+            col1 = "Location";
+            col2 = "Name";
+        }
+        $("<div class='table-header col-plain'>" + col1 + "</div>").appendTo(table);
+        if (category !== "modules") {
+            $("<div class='table-header col-plain'>" + col2 + "</div>").appendTo(table);
+        }
+        $.each(items, function(index, item) {
+            var rowColor = index % 2 ? "odd-row-color" : "even-row-color";
+            renderItem(item, table, rowColor);
+        });
+        return table;
+    }
+    function renderItem(item, table, rowColor) {
+        var label = getHighlightedText(item.input, item.boundaries, item.prefix.length, item.input.length);
+        var link = $("<a/>")
+            .attr("href",  getURL(item.indexItem, item.category))
+            .attr("tabindex", "0")
+            .addClass("search-result-link")
+            .html(label);
+        var container = getHighlightedText(item.input, item.boundaries, 0, item.prefix.length - 1);
+        if (item.category === "searchTags") {
+            container = item.indexItem.h || "";
+        }
+        if (item.category !== "modules") {
+            $("<div/>").html(container).addClass("col-plain").addClass(rowColor).appendTo(table);
+        }
+        $("<div/>").html(link).addClass("col-last").addClass(rowColor).appendTo(table);
+    }
+    var timeout;
+    function schedulePageSearch() {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(function () {
+            doPageSearch()
+        }, 100);
+    }
+    function doPageSearch() {
+        setSearchUrl();
+        var term = searchTerm = input.val().trim();
+        if (term === "") {
+            notify.html(messages.enterTerm);
+            activeTab = "";
+            fixedTab = false;
+            resultContainer.empty();
+            resultSection.hide();
+        } else {
+            notify.html(messages.searching);
+            doSearch({ term: term, maxResults: 1200 }, renderResults);
+        }
+    }
+    function setSearchUrl() {
+        var query = input.val().trim();
+        var url = document.location.pathname;
+        if (query) {
+            url += "?q=" + encodeURI(query);
+            if (activeTab && fixedTab) {
+                url += "&c=" + activeTab;
+            }
+        }
+        history.replaceState({query: query}, "", url);
+    }
+    input.on("input", function(e) {
+        feelingLucky = false;
+        schedulePageSearch();
+    });
+    $(document).keydown(function(e) {
+        if ((e.ctrlKey || e.metaKey) && (e.key === "ArrowLeft" || e.key === "ArrowRight")) {
+            if (activeTab && visibleTabs.length > 1) {
+                var idx = visibleTabs.indexOf(activeTab);
+                idx += e.key === "ArrowLeft" ? visibleTabs.length - 1 : 1;
+                selectTab(visibleTabs[idx % visibleTabs.length]);
+                return false;
+            }
+        }
+    });
+    reset.click(function() {
+        notify.html(messages.enterTerm);
+        resultSection.hide();
+        activeTab = "";
+        fixedTab = false;
+        resultContainer.empty();
+        input.val('').focus();
+        setSearchUrl();
+    });
+    input.prop("disabled", false);
+    reset.prop("disabled", false);
+
+    var urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.has("q")) {
+        input.val(urlParams.get("q"))
+    }
+    if (urlParams.has("c")) {
+        activeTab = urlParams.get("c");
+        fixedTab = true;
+    }
+    if (urlParams.get("r")) {
+        feelingLucky = true;
+    }
+    if (input.val()) {
+        doPageSearch();
+    } else {
+        notify.html(messages.enterTerm);
+    }
+    input.select().focus();
+});

DEV2.1/TP01/script-files/search.js

@@ -0,0 +1,485 @@
+/*
+ * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+"use strict";
+const messages = {
+    enterTerm: "Enter a search term",
+    noResult: "No results found",
+    oneResult: "Found one result",
+    manyResults: "Found {0} results",
+    loading: "Loading search index...",
+    searching: "Searching...",
+    redirecting: "Redirecting to first result...",
+    linkIcon: "Link icon",
+    linkToSection: "Link to this section"
+}
+const categories = {
+    modules: "Modules",
+    packages: "Packages",
+    types: "Classes and Interfaces",
+    members: "Members",
+    searchTags: "Search Tags"
+};
+const highlight = "<span class='result-highlight'>$&</span>";
+const NO_MATCH = {};
+const MAX_RESULTS = 300;
+const UNICODE_LETTER = 0;
+const UNICODE_DIGIT = 1;
+const UNICODE_OTHER = 2;
+function checkUnnamed(name, separator) {
+    return name === "<Unnamed>" || !name ? "" : name + separator;
+}
+function escapeHtml(str) {
+    return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function getHighlightedText(str, boundaries, from, to) {
+    var start = from;
+    var text = "";
+    for (var i = 0; i < boundaries.length; i += 2) {
+        var b0 = boundaries[i];
+        var b1 = boundaries[i + 1];
+        if (b0 >= to || b1 <= from) {
+            continue;
+        }
+        text += escapeHtml(str.slice(start, Math.max(start, b0)));
+        text += "<span class='result-highlight'>";
+        text += escapeHtml(str.slice(Math.max(start, b0), Math.min(to, b1)));
+        text += "</span>";
+        start = Math.min(to, b1);
+    }
+    text += escapeHtml(str.slice(start, to));
+    return text;
+}
+function getURLPrefix(item, category) {
+    var urlPrefix = "";
+    var slash = "/";
+    if (category === "modules") {
+        return item.l + slash;
+    } else if (category === "packages" && item.m) {
+        return item.m + slash;
+    } else if (category === "types" || category === "members") {
+        if (item.m) {
+            urlPrefix = item.m + slash;
+        } else {
+            $.each(packageSearchIndex, function(index, it) {
+                if (it.m && item.p === it.l) {
+                    urlPrefix = it.m + slash;
+                }
+            });
+        }
+    }
+    return urlPrefix;
+}
+function getURL(item, category) {
+    if (item.url) {
+        return item.url;
+    }
+    var url = getURLPrefix(item, category);
+    if (category === "modules") {
+        url += "module-summary.html";
+    } else if (category === "packages") {
+        if (item.u) {
+            url = item.u;
+        } else {
+            url += item.l.replace(/\./g, '/') + "/package-summary.html";
+        }
+    } else if (category === "types") {
+        if (item.u) {
+            url = item.u;
+        } else {
+            url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.l + ".html";
+        }
+    } else if (category === "members") {
+        url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.c + ".html" + "#";
+        if (item.u) {
+            url += item.u;
+        } else {
+            url += item.l;
+        }
+    } else if (category === "searchTags") {
+        url += item.u;
+    }
+    item.url = url;
+    return url;
+}
+function createMatcher(term, camelCase) {
+    if (camelCase && !isUpperCase(term)) {
+        return null;  // no need for camel-case matcher for lower case query
+    }
+    var pattern = "";
+    var upperCase = [];
+    term.trim().split(/\s+/).forEach(function(w, index, array) {
+        var tokens = w.split(/(?=[\p{Lu},.()<>?[\/])/u);
+        for (var i = 0; i < tokens.length; i++) {
+            var s = tokens[i];
+            // ',' and '?' are the only delimiters commonly followed by space in java signatures
+            pattern += "(" + escapeUnicodeRegex(s).replace(/[,?]/g, "$&\\s*?") + ")";
+            upperCase.push(false);
+            var isWordToken =  /[\p{L}\p{Nd}_]$/u.test(s);
+            if (isWordToken) {
+                if (i === tokens.length - 1 && index < array.length - 1) {
+                    // space in query string matches all delimiters
+                    pattern += "(.*?)";
+                    upperCase.push(isUpperCase(s[0]));
+                } else {
+                    if (!camelCase && isUpperCase(s) && s.length === 1) {
+                        pattern += "()";
+                    } else {
+                        pattern += "([\\p{L}\\p{Nd}\\p{Sc}<>?[\\]]*?)";
+                    }
+                    upperCase.push(isUpperCase(s[0]));
+                }
+            } else {
+                pattern += "()";
+                upperCase.push(false);
+            }
+        }
+    });
+    var re = new RegExp(pattern, "gui");
+    re.upperCase = upperCase;
+    return re;
+}
+// Unicode regular expressions do not allow certain characters to be escaped
+function escapeUnicodeRegex(pattern) {
+    return pattern.replace(/[\[\]{}()*+?.\\^$|\s]/g, '\\$&');
+}
+function findMatch(matcher, input, startOfName, endOfName) {
+    var from = startOfName;
+    matcher.lastIndex = from;
+    var match = matcher.exec(input);
+    // Expand search area until we get a valid result or reach the beginning of the string
+    while (!match || match.index + match[0].length < startOfName || endOfName < match.index) {
+        if (from === 0) {
+            return NO_MATCH;
+        }
+        from = input.lastIndexOf(".", from - 2) + 1;
+        matcher.lastIndex = from;
+        match = matcher.exec(input);
+    }
+    var boundaries = [];
+    var matchEnd = match.index + match[0].length;
+    var score = 5;
+    var start = match.index;
+    var prevEnd = -1;
+    for (var i = 1; i < match.length; i += 2) {
+        var charType = getCharType(input[start]);
+        var isMatcherUpper = matcher.upperCase[i];
+        // capturing groups come in pairs, match and non-match
+        boundaries.push(start, start + match[i].length);
+        // make sure groups are anchored on a left word boundary
+        var prevChar = input[start - 1] || "";
+        var nextChar = input[start + 1] || "";
+        if (start !== 0) {
+            if (charType === UNICODE_DIGIT && getCharType(prevChar) === UNICODE_DIGIT) {
+                return NO_MATCH;
+            } else if (charType === UNICODE_LETTER && getCharType(prevChar) === UNICODE_LETTER) {
+                var isUpper = isUpperCase(input[start]);
+                if (isUpper && (isLowerCase(prevChar) || isLowerCase(nextChar))) {
+                    score -= 0.1;
+                } else if (isMatcherUpper && start === prevEnd) {
+                    score -= isUpper ? 0.1 : 1.0;
+                } else {
+                    return NO_MATCH;
+                }
+            }
+        }
+        prevEnd = start + match[i].length;
+        start += match[i].length + match[i + 1].length;
+
+        // lower score for parts of the name that are missing
+        if (match[i + 1] && prevEnd < endOfName) {
+            score -= rateNoise(match[i + 1]);
+        }
+    }
+    // lower score if a type name contains unmatched camel-case parts
+    if (input[matchEnd - 1] !== "." && endOfName > matchEnd)
+        score -= rateNoise(input.slice(matchEnd, endOfName));
+    score -= rateNoise(input.slice(0, Math.max(startOfName, match.index)));
+
+    if (score <= 0) {
+        return NO_MATCH;
+    }
+    return {
+        input: input,
+        score: score,
+        boundaries: boundaries
+    };
+}
+function isLetter(s) {
+    return /\p{L}/u.test(s);
+}
+function isUpperCase(s) {
+    return /\p{Lu}/u.test(s);
+}
+function isLowerCase(s) {
+    return /\p{Ll}/u.test(s);
+}
+function isDigit(s) {
+    return /\p{Nd}/u.test(s);
+}
+function getCharType(s) {
+    if (isLetter(s)) {
+        return UNICODE_LETTER;
+    } else if (isDigit(s)) {
+        return UNICODE_DIGIT;
+    } else {
+        return UNICODE_OTHER;
+    }
+}
+function rateNoise(str) {
+    return (str.match(/([.(])/g) || []).length / 5
+         + (str.match(/(\p{Lu}+)/gu) || []).length / 10
+         +  str.length / 20;
+}
+function doSearch(request, response) {
+    var term = request.term.trim();
+    var maxResults = request.maxResults || MAX_RESULTS;
+    if (term.length === 0) {
+        return this.close();
+    }
+    var matcher = {
+        plainMatcher: createMatcher(term, false),
+        camelCaseMatcher: createMatcher(term, true)
+    }
+    var indexLoaded = indexFilesLoaded();
+
+    function getPrefix(item, category) {
+        switch (category) {
+            case "packages":
+                return checkUnnamed(item.m, "/");
+            case "types":
+                return checkUnnamed(item.p, ".");
+            case "members":
+                return checkUnnamed(item.p, ".") + item.c + ".";
+            default:
+                return "";
+        }
+    }
+    function useQualifiedName(category) {
+        switch (category) {
+            case "packages":
+                return /[\s/]/.test(term);
+            case "types":
+            case "members":
+                return /[\s.]/.test(term);
+            default:
+                return false;
+        }
+    }
+    function searchIndex(indexArray, category) {
+        var matches = [];
+        if (!indexArray) {
+            if (!indexLoaded) {
+                matches.push({ l: messages.loading, category: category });
+            }
+            return matches;
+        }
+        $.each(indexArray, function (i, item) {
+            var prefix = getPrefix(item, category);
+            var simpleName = item.l;
+            var qualifiedName = prefix + simpleName;
+            var useQualified = useQualifiedName(category);
+            var input = useQualified ? qualifiedName : simpleName;
+            var startOfName = useQualified ? prefix.length : 0;
+            var endOfName = category === "members" && input.indexOf("(", startOfName) > -1
+                ? input.indexOf("(", startOfName) : input.length;
+            var m = findMatch(matcher.plainMatcher, input, startOfName, endOfName);
+            if (m === NO_MATCH && matcher.camelCaseMatcher) {
+                m = findMatch(matcher.camelCaseMatcher, input, startOfName, endOfName);
+            }
+            if (m !== NO_MATCH) {
+                m.indexItem = item;
+                m.prefix = prefix;
+                m.category = category;
+                if (!useQualified) {
+                    m.input = qualifiedName;
+                    m.boundaries = m.boundaries.map(function(b) {
+                        return b + prefix.length;
+                    });
+                }
+                matches.push(m);
+            }
+            return true;
+        });
+        return matches.sort(function(e1, e2) {
+            return e2.score - e1.score;
+        }).slice(0, maxResults);
+    }
+
+    var result = searchIndex(moduleSearchIndex, "modules")
+         .concat(searchIndex(packageSearchIndex, "packages"))
+         .concat(searchIndex(typeSearchIndex, "types"))
+         .concat(searchIndex(memberSearchIndex, "members"))
+         .concat(searchIndex(tagSearchIndex, "searchTags"));
+
+    if (!indexLoaded) {
+        updateSearchResults = function() {
+            doSearch(request, response);
+        }
+    } else {
+        updateSearchResults = function() {};
+    }
+    response(result);
+}
+// JQuery search menu implementation
+$.widget("custom.catcomplete", $.ui.autocomplete, {
+    _create: function() {
+        this._super();
+        this.widget().menu("option", "items", "> .result-item");
+        // workaround for search result scrolling
+        this.menu._scrollIntoView = function _scrollIntoView( item ) {
+            var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
+            if ( this._hasScroll() ) {
+                borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0;
+                paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0;
+                offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
+                scroll = this.activeMenu.scrollTop();
+                elementHeight = this.activeMenu.height() - 26;
+                itemHeight = item.outerHeight();
+
+                if ( offset < 0 ) {
+                    this.activeMenu.scrollTop( scroll + offset );
+                } else if ( offset + itemHeight > elementHeight ) {
+                    this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
+                }
+            }
+        };
+    },
+    _renderMenu: function(ul, items) {
+        var currentCategory = "";
+        var widget = this;
+        widget.menu.bindings = $();
+        $.each(items, function(index, item) {
+            if (item.category && item.category !== currentCategory) {
+                ul.append("<li class='ui-autocomplete-category'>" + categories[item.category] + "</li>");
+                currentCategory = item.category;
+            }
+            var li = widget._renderItemData(ul, item);
+            if (item.category) {
+                li.attr("aria-label", categories[item.category] + " : " + item.l);
+            } else {
+                li.attr("aria-label", item.l);
+            }
+            li.attr("class", "result-item");
+        });
+        ul.append("<li class='ui-static-link'><a href='" + pathtoroot + "search.html?q="
+            + encodeURI(widget.term) + "'>Go to search page</a></li>");
+    },
+    _renderItem: function(ul, item) {
+        var li = $("<li/>").appendTo(ul);
+        var div = $("<div/>").appendTo(li);
+        var label = item.l
+            ? item.l
+            : getHighlightedText(item.input, item.boundaries, 0, item.input.length);
+        var idx = item.indexItem;
+        if (item.category === "searchTags" && idx && idx.h) {
+            if (idx.d) {
+                div.html(label + "<span class='search-tag-holder-result'> (" + idx.h + ")</span><br><span class='search-tag-desc-result'>"
+                    + idx.d + "</span><br>");
+            } else {
+                div.html(label + "<span class='search-tag-holder-result'> (" + idx.h + ")</span>");
+            }
+        } else {
+            div.html(label);
+        }
+        return li;
+    }
+});
+$(function() {
+    var expanded = false;
+    var windowWidth;
+    function collapse() {
+        if (expanded) {
+            $("div#navbar-top").removeAttr("style");
+            $("button#navbar-toggle-button")
+                .removeClass("expanded")
+                .attr("aria-expanded", "false");
+            expanded = false;
+        }
+    }
+    $("button#navbar-toggle-button").click(function (e) {
+        if (expanded) {
+            collapse();
+        } else {
+            var navbar = $("div#navbar-top");
+            navbar.height(navbar.prop("scrollHeight"));
+            $("button#navbar-toggle-button")
+                .addClass("expanded")
+                .attr("aria-expanded", "true");
+            expanded = true;
+            windowWidth = window.innerWidth;
+        }
+    });
+    $("ul.sub-nav-list-small li a").click(collapse);
+    $("input#search-input").focus(collapse);
+    $("main").click(collapse);
+    $("section[id] > :header, :header[id], :header:has(a[id])").each(function(idx, el) {
+        // Create anchor links for headers with an associated id attribute
+        var hdr = $(el);
+        var id = hdr.attr("id") || hdr.parent("section").attr("id") || hdr.children("a").attr("id");
+        if (id) {
+            hdr.append(" <a href='#" + id + "' class='anchor-link' aria-label='" + messages.linkToSection
+                + "'><img src='" + pathtoroot + "resource-files/link.svg' alt='" + messages.linkIcon +"' tabindex='0'"
+                + " width='16' height='16'></a>");
+        }
+    });
+    $(window).on("orientationchange", collapse).on("resize", function(e) {
+        if (expanded && windowWidth !== window.innerWidth) collapse();
+    });
+    var search = $("#search-input");
+    var reset = $("#reset-button");
+    search.catcomplete({
+        minLength: 1,
+        delay: 200,
+        source: doSearch,
+        response: function(event, ui) {
+            if (!ui.content.length) {
+                ui.content.push({ l: messages.noResult });
+            } else {
+                $("#search-input").empty();
+            }
+        },
+        autoFocus: true,
+        focus: function(event, ui) {
+            return false;
+        },
+        position: {
+            collision: "flip"
+        },
+        select: function(event, ui) {
+            if (ui.item.indexItem) {
+                var url = getURL(ui.item.indexItem, ui.item.category);
+                window.location.href = pathtoroot + url;
+                $("#search-input").focus();
+            }
+        }
+    });
+    search.val('');
+    search.prop("disabled", false);
+    reset.prop("disabled", false);
+    reset.click(function() {
+        search.val('').focus();
+    });
+    search.focus();
+});