').attr('class', 'item-title').text(itemTitle);
+ const itemBriefNode = $('
').attr('class', 'item-brief').text(itemBrief);
+ itemNode.append(itemTitleNode).append(itemBriefNode);
+
+ return itemNode;
+ })
+ );
+ query.split(/\s+/).forEach(function (word) {
+ if (word !== '') {
+ word = word.replace(/\*/g, '');
+ $('#search-results>.sr-items *').mark(word);
+ }
+ });
+ }
+ }
+}
+
+function getAbsolutePath(href) {
+ // Use anchor to normalize href
+ const anchor = $('
')[0];
+ // Ignore protocal, remove search and query
+ return anchor.host + anchor.pathname;
+}
+
+function isRelativePath(href) {
+ if (href === undefined || href === '' || href[0] === '/') {
+ return false;
+ }
+ return !isAbsolutePath(href);
+}
+
+function isAbsolutePath(href) {
+ return (/^(?:[a-z]+:)?\/\//i).test(href);
+}
+
+function getDirectory(href) {
+ if (!href) {
+ return '';
+ }
+
+ const index = href.lastIndexOf('/');
+
+ if (index === -1) {
+ return '';
+ }
+
+ if (index > -1) {
+ return href.substr(0, index);
+ }
+}
+
+function formList(item, classes) {
+ let level = 1;
+ const model = {
+ items: item
+ };
+
+ const cls = [].concat(classes).join(" ");
+ return getList(model, cls);
+
+ function getList(model, cls) {
+
+ if (!model || !model.items) {
+ return null;
+ }
+
+ const l = model.items.length;
+
+ if (l === 0) {
+ return null;
+ }
+
+ let html = '
';
+ level++;
+
+ for (let i = 0; i < l; i++) {
+ const item = model.items[i];
+ const href = item.href;
+ const name = item.name;
+
+ if (!name) {
+ continue;
+ }
+
+ html += href ? '- ' + name + '' : '
- ' + name;
+ html += getList(item, cls) || '';
+ html += '
';
+ }
+
+ html += '
';
+ return html;
+ }
+}
+
+
+/**
+ * Add
into long word.
+ * @param {String} text - The word to break. It should be in plain text without HTML tags.
+ */
+function breakPlainText(text) {
+ if (!text) return text;
+ return text.replace(/([a-z])([A-Z])|(\.)(\w)/g, '$1$3$2$4')
+}
+
+/**
+ * Add into long word. The jQuery element should contain no html tags.
+ * If the jQuery element contains tags, this function will not change the element.
+ */
+function breakWord() {
+ if (this.html() === this.text()) {
+ this.html(function (index, text) {
+ return breakPlainText(text);
+ })
+ }
+
+ return this;
+}
+
+/**
+ * adjusted from https://stackoverflow.com/a/13067009/1523776
+ */
+function workAroundFixedHeaderForAnchors() {
+ const HISTORY_SUPPORT = !!(history && history.pushState);
+ const ANCHOR_REGEX = /^#[^ ]+$/;
+
+ function getFixedOffset() {
+ return $('header').first().height();
+ }
+
+ /**
+ * If the provided href is an anchor which resolves to an element on the
+ * page, scroll to it.
+ * @param {String} href destination
+ * @param {Boolean} pushToHistory push to history
+ * @return {Boolean} - Was the href an anchor.
+ */
+ function scrollIfAnchor(href, pushToHistory) {
+ let match, rect, anchorOffset;
+
+ if (!ANCHOR_REGEX.test(href)) {
+ return false;
+ }
+
+ match = document.getElementById(href.slice(1));
+
+ if (match) {
+ rect = match.getBoundingClientRect();
+ anchorOffset = window.pageYOffset + rect.top - getFixedOffset();
+ window.scrollTo(window.pageXOffset, anchorOffset);
+
+ // Add the state to history as-per normal anchor links
+ if (HISTORY_SUPPORT && pushToHistory) {
+ history.pushState({}, document.title, location.pathname + href);
+ }
+ }
+
+ return !!match;
+ }
+
+ /**
+ * Attempt to scroll to the current location's hash.
+ */
+ function scrollToCurrent() {
+ scrollIfAnchor(window.location.hash, false);
+ }
+
+ $(window).on('hashchange', () => scrollToCurrent());
+ // Exclude tabbed content case
+ scrollToCurrent();
+
+ $(document).on('ready', function () {
+ $('body').scrollspy({offset: 150});
+ });
+}
+
+function breakText() {
+ $(".xref").addClass("text-break");
+ const texts = $(".text-break");
+ texts.each(function () {
+ $(this).breakWord();
+ });
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["constant.js","render.js","component/affix.js","component/alerts.js","component/breadcrumb.js","component/footer.js","component/links.js","component/navbar.js","component/sidebar.js","component/tab.js","component/tables.js","service/globalevents.js","service/search.js","service/utility.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACpMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"docfx.js","sourcesContent":["const active = 'active';\r\nconst expanded = 'in';\r\nconst filtered = 'filtered';\r\nconst show = 'show';\r\nconst hide = 'hide';\r\nconst collapsed = 'collapsed';\r\n","// workaround for gulp-uglify changing order of execution on $.fn func assignments\r\nObject.assign($.fn, { breakWord });\r\n\r\nworkAroundFixedHeaderForAnchors();\r\nhighlight();\r\nenableSearch();\r\n\r\nrenderTables();\r\nrenderAlerts();\r\nupdateAlertHeightOnResize();\r\nrenderLinks();\r\nrenderSidebar();\r\nrenderAffix();\r\n\r\nrenderNavbar();\r\nrenderLogo();\r\nupdateLogo()\r\nupdateLogoOnResize();\r\nupdateNavbarHeightOnResize();\r\nupdateTocHeightOnResize();\r\nupdateSidenavTopOnResize();\r\nrenderFooter();\r\nbreakText();\r\nrenderTabs();\r\nupdateLogo();\r\n","//Setup Affix\r\nfunction renderAffix() {\r\n    const hierarchy = getHierarchy();\r\n\r\n    if (hierarchy && hierarchy.length > 0) {\r\n        let html = '<h5 class=\"title\">In This Article</h5>'\r\n        html += formList(hierarchy, ['nav', 'bs-docs-sidenav']);\r\n\r\n        $(\"#affix\").empty().append(html);\r\n\r\n        if ($('footer').is(':visible')) {\r\n            $(\".sideaffix\").css(\"bottom\", \"70px\");\r\n        }\r\n\r\n        $('#affix a').on('click', function (e) {\r\n            const scrollspy = $('[data-spy=\"scroll\"]').data()['bs.scrollspy'];\r\n            const target = e.target.hash;\r\n            if (scrollspy && target) {\r\n                scrollspy.activate(target);\r\n            }\r\n        });\r\n\r\n        const contribution = $('.contribution');\r\n        const contributionDiv = contribution.get(0).outerHTML;\r\n        contribution.remove();\r\n        $('.sideaffix').append(contributionDiv);\r\n\r\n    }\r\n\r\n    function getHierarchy() {\r\n        // supported headers are h1, h2, h3, and h4\r\n        const $headers = $($.map(['h1', 'h2', 'h3', 'h4'], function (h) { return \".article article \" + h; }).join(\", \"));\r\n\r\n        // a stack of hierarchy items that are currently being built\r\n        const stack = [];\r\n        $headers.each(function (i, e) {\r\n            if (!e.id) {\r\n                return;\r\n            }\r\n\r\n            const item = {\r\n                name: htmlEncode($(e).text()),\r\n                href: \"#\" + e.id,\r\n                items: []\r\n            };\r\n\r\n            if (!stack.length) {\r\n                stack.push({ type: e.tagName, siblings: [item] });\r\n                return;\r\n            }\r\n\r\n            const frame = stack[stack.length - 1];\r\n            if (e.tagName === frame.type) {\r\n                frame.siblings.push(item);\r\n            } else if (e.tagName[1] > frame.type[1]) {\r\n                // we are looking at a child of the last element of frame.siblings.\r\n                // push a frame onto the stack. After we've finished building this item's children,\r\n                // we'll attach it as a child of the last element\r\n                stack.push({ type: e.tagName, siblings: [item] });\r\n            } else {  // e.tagName[1] < frame.type[1]\r\n                // we are looking at a sibling of an ancestor of the current item.\r\n                // pop frames from the stack, building items as we go, until we reach the correct level at which to attach this item.\r\n                while (e.tagName[1] < stack[stack.length - 1].type[1]) {\r\n                    buildParent();\r\n                }\r\n                if (e.tagName === stack[stack.length - 1].type) {\r\n                    stack[stack.length - 1].siblings.push(item);\r\n                } else {\r\n                    stack.push({ type: e.tagName, siblings: [item] });\r\n                }\r\n            }\r\n        });\r\n        while (stack.length > 1) {\r\n            buildParent();\r\n        }\r\n\r\n        function buildParent() {\r\n            const childrenToAttach = stack.pop();\r\n            const parentFrame = stack[stack.length - 1];\r\n            const parent = parentFrame.siblings[parentFrame.siblings.length - 1];\r\n            $.each(childrenToAttach.siblings, function (i, child) {\r\n                parent.items.push(child);\r\n            });\r\n        }\r\n        if (stack.length > 0) {\r\n\r\n            const topLevel = stack.pop().siblings;\r\n            if (topLevel.length === 1) {  // if there's only one topmost header, dump it\r\n                return topLevel[0].items;\r\n            }\r\n            return topLevel;\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    function htmlEncode(str) {\r\n        if (!str) return str;\r\n        return str\r\n            .replace(/&/g, '&amp;')\r\n            .replace(/\"/g, '&quot;')\r\n            .replace(/'/g, '&#39;')\r\n            .replace(/</g, '&lt;')\r\n            .replace(/>/g, '&gt;');\r\n    }\r\n\r\n    function htmlDecode(str) {\r\n        if (!str) return str;\r\n        return str\r\n            .replace(/&quot;/g, '\"')\r\n            .replace(/&#39;/g, \"'\")\r\n            .replace(/&lt;/g, '<')\r\n            .replace(/&gt;/g, '>')\r\n            .replace(/&amp;/g, '&');\r\n    }\r\n\r\n    function cssEscape(str) {\r\n        // see: http://stackoverflow.com/questions/2786538/need-to-escape-a-special-character-in-a-jquery-selector-string#answer-2837646\r\n        if (!str) return str;\r\n        return str\r\n            .replace(/[!\"#$%&'()*+,.\\/:;<=>?@[\\\\\\]^`{|}~]/g, \"\\\\$&\");\r\n    }\r\n}\r\n","// Styling for alerts.\r\nfunction setAlertHeight(){\r\n    var maxHeight = Math.max.apply(null, $(\".col-md-6 div.alert\").map(function ()\r\n    {\r\n        return $(this).outerHeight();\r\n    }).get());\r\n\r\n    $('.alert').css('height', maxHeight);\r\n    \r\n}\r\n\r\nfunction updateAlertHeightOnResize() {\r\n    $(window).on('resize', function () {\r\n        $('.alert').css('height', 'auto');\r\n        setAlertHeight();\r\n    });\r\n}\r\n\r\nfunction renderAlerts() {\r\n    $('.NOTE, .TIP').addClass('alert alert-info');\r\n    $('.WARNING').addClass('alert alert-warning');\r\n    $('.IMPORTANT, .CAUTION').addClass('alert alert-danger');\r\n    setAlertHeight();\r\n\r\n}\r\n","function renderBreadcrumb() {\r\n    const breadcrumb = [];\r\n\r\n    $('#navbar a.active').each(function (i, e) {\r\n        breadcrumb.push({\r\n            href: e.href,\r\n            name: e.innerHTML\r\n        });\r\n    })\r\n    $('#toc a.active').each(function (i, e) {\r\n        breadcrumb.push({\r\n            href: e.href,\r\n            name: e.innerHTML\r\n        });\r\n    })\r\n\r\n    const html = formList(breadcrumb, 'breadcrumb');\r\n    $('#breadcrumb').html(html);\r\n}\r\n","// Show footer\r\nfunction renderFooter() {\r\n    initFooter();\r\n    $(window).on(\"scroll\", () => showFooterCore());\r\n\r\n    function initFooter() {\r\n        if (needFooter()) {\r\n            shiftUpBottomCss();\r\n            $(\"footer\").show();\r\n        } else {\r\n            resetBottomCss();\r\n            $(\"footer\").hide();\r\n        }\r\n    }\r\n\r\n    function showFooterCore() {\r\n        if (needFooter()) {\r\n            shiftUpBottomCss();\r\n            $(\"footer\").fadeIn();\r\n        } else {\r\n            resetBottomCss();\r\n            $(\"footer\").fadeOut();\r\n        }\r\n    }\r\n\r\n    function needFooter() {\r\n        const scrollHeight = $(document).height();\r\n        const scrollPosition = $(window).height() + $(window).scrollTop();\r\n        return (scrollHeight - scrollPosition) < 1;\r\n    }\r\n\r\n    function resetBottomCss() {\r\n        $(\".sidetoc\").removeClass(\"shiftup\");\r\n        $(\".sideaffix\").removeClass(\"shiftup\");\r\n    }\r\n\r\n    function shiftUpBottomCss() {\r\n        $(\".sidetoc\").addClass(\"shiftup\");\r\n        $(\".sideaffix\").addClass(\"shiftup\");\r\n    }\r\n}\r\n","// Open links to different host in a new window.\r\nfunction renderLinks() {\r\n    if ($(\"meta[property='docfx:newtab']\").attr(\"content\") === \"true\") {\r\n        $(document.links).filter(function () {\r\n            return this.hostname !== window.location.hostname;\r\n        }).attr('target', '_blank');\r\n    }\r\n}\r\n","function setNavbarHeight() {\r\n    let headerHeight = $(\"#header-container\").outerHeight();\r\n    let intViewportHeight = window.innerHeight;\r\n    let maxHeightNavbar = intViewportHeight - headerHeight;\r\n    $(\"#navbar\").css(\"max-height\", maxHeightNavbar);\r\n}\r\n\r\n\r\n/**\r\n * Load the navbar from the uno website\r\n */\r\nfunction initializeNavbar() {\r\n\r\n    const navbar = document.querySelector(\"header > .navbar\");\r\n    if (document.body.classList.contains(\"front-page\")) {\r\n        let last_known_scroll_position = 0;\r\n        let ticking = false;\r\n\r\n        function doSomething(scroll_pos) {\r\n            if (scroll_pos >= 100) navbar.classList.add(\"scrolled\");\r\n            else navbar.classList.remove(\"scrolled\");\r\n        }\r\n\r\n        window.addEventListener(\"scroll\", function () {\r\n            last_known_scroll_position = window.scrollY;\r\n\r\n            if (!ticking) {\r\n                window.requestAnimationFrame(function () {\r\n                    doSomething(last_known_scroll_position);\r\n                    ticking = false;\r\n                });\r\n\r\n                ticking = true;\r\n            }\r\n        });\r\n    }\r\n\r\n    const unoMenuReq = new XMLHttpRequest();\r\n    const unoMenuEndpoint = \"https://platform.uno/wp-json/wp/v2/menu\";\r\n    const $navbar = document.getElementById(\"navbar\");\r\n    let wordpressMenuHasLoaded = false;\r\n\r\n    unoMenuReq.open(\"get\", unoMenuEndpoint, true);\r\n\r\n    if (typeof navbar !== \"undefined\") {\r\n        unoMenuReq.onload = function () {\r\n            if (unoMenuReq.status === 200 && unoMenuReq.responseText) {\r\n                $navbar.innerHTML = JSON.parse(\r\n                    unoMenuReq.responseText\r\n                );\r\n                wordpressMenuHasLoaded = true;\r\n                $(document).trigger(\"wordpressMenuHasLoaded\");\r\n            }\r\n        };\r\n        unoMenuReq.onerror = function (e) {\r\n        };\r\n        unoMenuReq.send();\r\n    }\r\n\r\n    $(document).ajaxComplete(function (event, xhr, settings) {\r\n        const docFxNavbarHasLoaded = settings.url === \"toc.html\";\r\n\r\n        if (docFxNavbarHasLoaded && wordpressMenuHasLoaded) {\r\n            const $docfxNavbar = $navbar.getElementsByClassName(\"navbar-nav\");\r\n            $docfxNavbar[0].className += \" hidden\";\r\n\r\n        }\r\n    });\r\n\r\n    setNavbarHeight();\r\n\r\n}\r\n\r\n/**\r\n * Changes the logo on resize\r\n*/\r\n\r\nfunction updateLogo() {\r\n    const curWidth = window.innerWidth;\r\n    const headerLogo = document.getElementById('logo');\r\n    if (curWidth < 980) {\r\n        const mobileLogo = new URL('UnoLogoSmall.png', headerLogo.src).href;\r\n        headerLogo.src = mobileLogo;\r\n    } else {\r\n        const deskLogo = new URL('uno-logo.svg', headerLogo.src).href;\r\n        headerLogo.src = deskLogo;\r\n    }\r\n}\r\n\r\nfunction updateLogoOnResize() {\r\n    $(window).on('resize', function () {\r\n        updateLogo();\r\n    });\r\n}\r\n\r\n\r\nfunction updateNavbarHeightOnResize() {\r\n    $(window).on('resize', function () {\r\n        setNavbarHeight();\r\n    });\r\n}\r\n\r\n\r\n// Update href in navbar\r\nfunction renderNavbar() {\r\n    const navbar = $('#navbar ul')[0];\r\n    if (typeof (navbar) === 'undefined') {\r\n        loadNavbar();\r\n    } else {\r\n        $('#navbar ul a.active').parents('li').addClass(active);\r\n        renderBreadcrumb();\r\n    }\r\n\r\n    function loadNavbar() {\r\n        let navbarPath = $(\"meta[property='docfx\\\\:navrel']\").attr(\"content\");\r\n        if (!navbarPath) {\r\n            return;\r\n        }\r\n        navbarPath = navbarPath.replace(/\\\\/g, '/');\r\n        let tocPath = $(\"meta[property='docfx\\\\:tocrel']\").attr(\"content\") || '';\r\n        if (tocPath) tocPath = tocPath.replace(/\\\\/g, '/');\r\n        $.get(navbarPath, function (data) {\r\n            $(data).find(\"#toc>ul\").appendTo(\"#navbar\");\r\n            const index = navbarPath.lastIndexOf('/');\r\n            let navrel = '';\r\n            if (index > -1) {\r\n                navrel = navbarPath.substr(0, index + 1);\r\n            }\r\n            $('#navbar>ul').addClass('navbar-nav');\r\n\r\n            const currentAbsPath = getAbsolutePath(window.location.pathname);\r\n\r\n            // set active item\r\n            $('#navbar').find('a[href]').each(function (i, e) {\r\n                let href = $(e).attr(\"href\");\r\n                if (isRelativePath(href)) {\r\n                    href = navrel + href;\r\n                    $(e).attr(\"href\", href);\r\n\r\n                    // TODO: currently only support one level navbar\r\n                    let isActive = false;\r\n                    let originalHref = e.name;\r\n                    if (originalHref) {\r\n                        originalHref = navrel + originalHref;\r\n                        if (getDirectory(getAbsolutePath(originalHref)) === getDirectory(getAbsolutePath(tocPath))) {\r\n                            isActive = true;\r\n                        }\r\n                    } else {\r\n                        if (getAbsolutePath(href) === currentAbsPath) {\r\n\r\n                            const dropdown = $(e).attr('data-toggle') === \"dropdown\";\r\n\r\n                            if (!dropdown) {\r\n                                isActive = true;\r\n                            }\r\n                        }\r\n                    }\r\n                    if (isActive) {\r\n                        $(e).addClass(active);\r\n                    }\r\n                }\r\n            });\r\n            renderNavbar();\r\n        });\r\n    }\r\n}\r\n\r\nfunction renderLogo() {\r\n    // For LOGO SVG\r\n    // Replace SVG with inline SVG\r\n    // http://stackoverflow.com/questions/11978995/how-to-change-color-of-svg-image-using-css-jquery-svg-image-replacement\r\n    $('img.svg').each(function () {\r\n        const $img = jQuery(this);\r\n        const imgID = $img.attr('id');\r\n        const imgClass = $img.attr('class');\r\n        const imgURL = $img.attr('src');\r\n\r\n        jQuery.get(imgURL, function (data) {\r\n            // Get the SVG tag, ignore the rest\r\n            let $svg = $(data).find('svg');\r\n\r\n            // Add replaced image's ID to the new SVG\r\n            if (typeof imgID !== 'undefined') {\r\n                $svg = $svg.attr('id', imgID);\r\n            }\r\n            // Add replaced image's classes to the new SVG\r\n            if (typeof imgClass !== 'undefined') {\r\n                $svg = $svg.attr('class', imgClass + ' replaced-svg');\r\n            }\r\n\r\n            // Remove any invalid XML tags as per http://validator.w3.org\r\n            $svg = $svg.removeAttr('xmlns:a');\r\n\r\n            // Replace image with new SVG\r\n            $img.replaceWith($svg);\r\n\r\n        }, 'xml');\r\n    });\r\n}\r\n","function setTocHeight() {\r\n    if($(window).width() < 767) {\r\n        let headerHeight = $(\"#header-container\").outerHeight();\r\n        let breadcrumbHeight = $(\"#breadcrumb\").outerHeight();\r\n        let tocToggleHeight = $(\".btn.toc-toggle.collapse\").outerHeight();\r\n        let sidefilterHeight = 65; //65px from sidefilter height\r\n        let intViewportHeight = window.innerHeight;\r\n        let sidenavPaddingTop = parseInt($(\".sidenav\").css('padding-top'));\r\n        let maxHeightToc = intViewportHeight - (headerHeight + breadcrumbHeight + tocToggleHeight + sidefilterHeight + sidenavPaddingTop);\r\n        $(\".sidetoc\").css(\"max-height\", maxHeightToc);\r\n    } else {\r\n        $(\".sidetoc\").css(\"max-height\", \"none\");\r\n    }\r\n}\r\n\r\nfunction updateTocHeightOnResize() {\r\n    $(window).on('resize', function () {\r\n        setTocHeight();\r\n    });\r\n}\r\n\r\nfunction setSidenavTop() {\r\n    let headerHeight = $(\"#header-container\").outerHeight();\r\n    let breadcrumbHeight = $(\"#breadcrumb\").outerHeight();\r\n    let tocToggleHeight = $(\".btn.toc-toggle.collapse\").outerHeight();\r\n    let sidefilterHeight = $(\".sidefilter\").outerHeight();\r\n    let sidenavTop = headerHeight + breadcrumbHeight;\r\n    let sidefilterTop = headerHeight + breadcrumbHeight;\r\n    let sidetocTop = sidefilterTop + sidefilterHeight;\r\n    let articleMarginTopDesk = sidenavTop + tocToggleHeight + 30; //30px from .sidenav padding top and bottom\r\n    let articleMarginTopMobile = sidenavTop;\r\n    $(\".sidenav\").css(\"top\", sidenavTop);\r\n    $(\".sidefilter\").css(\"top\", sidenavTop);\r\n    $(\".sidetoc\").css(\"top\", sidetocTop);\r\n    if($(window).width() < 767) {\r\n        $(\".body-content .article\").attr(\"style\", \"margin-top:\" + (articleMarginTopDesk + 5) + \"px !important\");\r\n    } else {\r\n        $(\".body-content .article\").attr(\"style\", \"margin-top:\" + (articleMarginTopMobile + 5) + \"px !important\");\r\n    }\r\n}\r\n\r\nfunction updateSidenavTopOnResize() {\r\n    $(window).on('resize', function () {\r\n        setSidenavTop();\r\n    });\r\n}\r\n\r\nfunction renderSidebar() {\r\n\r\n    const sideToggleSideToc = $('#sidetoggle .sidetoc')[0];\r\n    const footer = $('footer');\r\n    const sidetoc = $('.sidetoc');\r\n\r\n    if (typeof (sideToggleSideToc) === 'undefined') {\r\n        loadToc();\r\n    } else {\r\n        registerTocEvents();\r\n        if (footer.is(':visible')) {\r\n            sidetoc.addClass('shiftup');\r\n        }\r\n\r\n        // Scroll to active item\r\n        let top = 0;\r\n        $('#toc a.active').parents('li').each(function (i, e) {\r\n            $(e).addClass(active).addClass(expanded);\r\n            $(e).children('a').addClass(active);\r\n            top += $(e).position().top;\r\n        })\r\n\r\n        sidetoc.scrollTop(top - 50);\r\n\r\n        if (footer.is(':visible')) {\r\n            sidetoc.addClass('shiftup');\r\n        }\r\n\r\n        if (window.location.href.indexOf(\"articles/intro.html\") > -1 && $(window).width() > 850) {\r\n            $('.nav.level1 li:eq(1)').addClass(expanded);\r\n        }\r\n\r\n        renderBreadcrumb();\r\n        setSidenavTop();\r\n        setTocHeight();\r\n    }\r\n\r\n    function registerTocEvents() {\r\n        $('.toc .nav > li > .expand-stub').on('click', function (e) {\r\n            $(e.target).parent().toggleClass(expanded);\r\n        });\r\n        $('.toc .nav > li > .expand-stub + a:not([href])').on('click', function (e) {\r\n            $(e.target).parent().toggleClass(expanded);\r\n        });\r\n        $('#toc_filter_input').on('input', function () {\r\n            const val = this.value;\r\n            if (val === '') {\r\n                // Clear 'filtered' class\r\n                $('#toc li').removeClass(filtered).removeClass(hide);\r\n                return;\r\n            }\r\n\r\n            // Get leaf nodes\r\n            const tocLineAnchor = $('#toc li>a');\r\n\r\n            tocLineAnchor.filter(function (i, e) {\r\n                return $(e).siblings().length === 0\r\n            }).each(function (j, anchor) {\r\n                let text = $(anchor).attr('title');\r\n                const parent = $(anchor).parent();\r\n                const parentNodes = parent.parents('ul>li');\r\n                for (let k = 0; k < parentNodes.length; k++) {\r\n                    let parentText = $(parentNodes[k]).children('a').attr('title');\r\n                    if (parentText) text = parentText + '.' + text;\r\n                }\r\n\r\n                if (filterNavItem(text, val)) {\r\n                    parent.addClass(show);\r\n                    parent.removeClass(hide);\r\n                } else {\r\n                    parent.addClass(hide);\r\n                    parent.removeClass(show);\r\n                }\r\n            });\r\n\r\n            tocLineAnchor.filter(function (i, e) {\r\n                return $(e).siblings().length > 0\r\n            }).each(function (i, anchor) {\r\n                const parent = $(anchor).parent();\r\n                if (parent.find('li.show').length > 0) {\r\n                    parent.addClass(show);\r\n                    parent.addClass(filtered);\r\n                    parent.removeClass(hide);\r\n                } else {\r\n                    parent.addClass(hide);\r\n                    parent.removeClass(show);\r\n                    parent.removeClass(filtered);\r\n                }\r\n            })\r\n\r\n            function filterNavItem(name, text) {\r\n\r\n                if (!text) return true;\r\n\r\n                return name && name.toLowerCase().indexOf(text.toLowerCase()) > -1;\r\n\r\n            }\r\n        });\r\n    }\r\n\r\n    function loadToc() {\r\n        let tocPath = $(\"meta[property='docfx\\\\:tocrel']\").attr(\"content\");\r\n\r\n        if (!tocPath) {\r\n            return;\r\n        }\r\n        tocPath = tocPath.replace(/\\\\/g, '/');\r\n        $('#sidetoc').load(tocPath + \" #sidetoggle > div\", function () {\r\n            const index = tocPath.lastIndexOf('/');\r\n            let tocrel = '';\r\n\r\n            if (index > -1) {\r\n                tocrel = tocPath.substr(0, index + 1);\r\n            }\r\n\r\n            const currentHref = getAbsolutePath(window.location.pathname);\r\n\r\n            $('#sidetoc').find('a[href]').each(function (i, e) {\r\n                let href = $(e).attr(\"href\");\r\n                if (isRelativePath(href)) {\r\n                    href = tocrel + href;\r\n                    $(e).attr(\"href\", href);\r\n                }\r\n\r\n                if (getAbsolutePath(e.href) === currentHref) {\r\n                    $(e).addClass(active);\r\n                }\r\n\r\n                $(e).breakWord();\r\n            });\r\n\r\n            renderSidebar();\r\n            const body = $('body');\r\n            const searchResult = $('#search-results');\r\n\r\n            if (searchResult.length !== 0) {\r\n                $('#search').show();\r\n                body.trigger(\"searchEvent\");\r\n            }\r\n\r\n            // if the target of the click isn't the container nor a descendant of the container\r\n            body.on('mouseup', function (e) {\r\n                if (!searchResult.is(e.target) && searchResult.has(e.target).length === 0) {\r\n                    searchResult.hide();\r\n                }\r\n            });\r\n        });\r\n    }\r\n}\r\n","function renderTabs() {\r\n\r\n    const contentAttrs = {\r\n        id: 'data-bi-id',\r\n        name: 'data-bi-name',\r\n        type: 'data-bi-type'\r\n    };\r\n\r\n    const Tab = (function () {\r\n        function Tab(li, a, section) {\r\n            this.li = li;\r\n            this.a = a;\r\n            this.section = section;\r\n        }\r\n\r\n        Object.defineProperty(Tab.prototype, \"tabIds\", {\r\n            get: function () {\r\n                return this.a.getAttribute('data-tab').split(' ');\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n\r\n        Object.defineProperty(Tab.prototype, \"condition\", {\r\n            get: function () {\r\n                return this.a.getAttribute('data-condition');\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n\r\n        Object.defineProperty(Tab.prototype, \"visible\", {\r\n            get: function () {\r\n                return !this.li.hasAttribute('hidden');\r\n            },\r\n            set: function (value) {\r\n                if (value) {\r\n                    this.li.removeAttribute('hidden');\r\n                    this.li.removeAttribute('aria-hidden');\r\n                } else {\r\n                    this.li.setAttribute('hidden', 'hidden');\r\n                    this.li.setAttribute('aria-hidden', 'true');\r\n                }\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n\r\n        Object.defineProperty(Tab.prototype, \"selected\", {\r\n            get: function () {\r\n                return !this.section.hasAttribute('hidden');\r\n            },\r\n            set: function (value) {\r\n                if (value) {\r\n                    this.a.setAttribute('aria-selected', 'true');\r\n                    this.a.tabIndex = 0;\r\n                    this.section.removeAttribute('hidden');\r\n                    this.section.removeAttribute('aria-hidden');\r\n                } else {\r\n                    this.a.setAttribute('aria-selected', 'false');\r\n                    this.a.tabIndex = -1;\r\n                    this.section.setAttribute('hidden', 'hidden');\r\n                    this.section.setAttribute('aria-hidden', 'true');\r\n                }\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n\r\n        Tab.prototype.focus = function () {\r\n            this.a.focus();\r\n        };\r\n\r\n        return Tab;\r\n\r\n    }());\r\n\r\n    initTabs(document.body);\r\n\r\n    function initTabs(container) {\r\n        const queryStringTabs = readTabsQueryStringParam();\r\n        const elements = container.querySelectorAll('.tabGroup');\r\n        const state = {groups: [], selectedTabs: []};\r\n        for (let i = 0; i < elements.length; i++) {\r\n            const group = initTabGroup(elements.item(i));\r\n            if (!group.independent) {\r\n                updateVisibilityAndSelection(group, state);\r\n                state.groups.push(group);\r\n            }\r\n        }\r\n        container.addEventListener('click', function (event) {\r\n            return handleClick(event, state);\r\n        });\r\n        if (state.groups.length === 0) {\r\n            return state;\r\n        }\r\n        selectTabs(queryStringTabs, container);\r\n        updateTabsQueryStringParam(state);\r\n        notifyContentUpdated();\r\n        return state;\r\n    }\r\n\r\n    function initTabGroup(element) {\r\n\r\n        const group = {\r\n            independent: element.hasAttribute('data-tab-group-independent'),\r\n            tabs: []\r\n        };\r\n\r\n        let li = element.firstElementChild.firstElementChild;\r\n        while (li) {\r\n            const a = li.firstElementChild;\r\n            a.setAttribute(contentAttrs.name, 'tab');\r\n\r\n            const dataTab = a.getAttribute('data-tab').replace(/\\+/g, ' ');\r\n            a.setAttribute('data-tab', dataTab);\r\n\r\n            const section = element.querySelector(\"[id=\\\"\" + a.getAttribute('aria-controls') + \"\\\"]\");\r\n            const tab = new Tab(li, a, section);\r\n            group.tabs.push(tab);\r\n\r\n            li = li.nextElementSibling;\r\n        }\r\n\r\n        element.setAttribute(contentAttrs.name, 'tab-group');\r\n        element.tabGroup = group;\r\n\r\n        return group;\r\n    }\r\n\r\n    function updateVisibilityAndSelection(group, state) {\r\n        let anySelected = false;\r\n        let firstVisibleTab;\r\n\r\n        for (let _i = 0, _a = group.tabs; _i < _a.length; _i++) {\r\n            let tab = _a[_i];\r\n            tab.visible = tab.condition === null || state.selectedTabs.indexOf(tab.condition) !== -1;\r\n            if (tab.visible) {\r\n                if (!firstVisibleTab) {\r\n                    firstVisibleTab = tab;\r\n                }\r\n            }\r\n            tab.selected = tab.visible && arraysIntersect(state.selectedTabs, tab.tabIds);\r\n            anySelected = anySelected || tab.selected;\r\n        }\r\n\r\n        if (!anySelected) {\r\n            for (let _b = 0, _c = group.tabs; _b < _c.length; _b++) {\r\n                const tabIds = _c[_b].tabIds;\r\n                for (let _d = 0, tabIds_1 = tabIds; _d < tabIds_1.length; _d++) {\r\n                    const tabId = tabIds_1[_d];\r\n                    const index = state.selectedTabs.indexOf(tabId);\r\n                    if (index === -1) {\r\n                        continue;\r\n                    }\r\n                    state.selectedTabs.splice(index, 1);\r\n                }\r\n            }\r\n            const tab = firstVisibleTab;\r\n            tab.selected = true;\r\n            state.selectedTabs.push(tab.tabIds[0]);\r\n        }\r\n    }\r\n\r\n    function getTabInfoFromEvent(event) {\r\n\r\n        if (!(event.target instanceof HTMLElement)) {\r\n            return null;\r\n        }\r\n\r\n        const anchor = event.target.closest('a[data-tab]');\r\n\r\n        if (anchor === null) {\r\n            return null;\r\n        }\r\n\r\n        const tabIds = anchor.getAttribute('data-tab').split(' ');\r\n        const group = anchor.parentElement.parentElement.parentElement.tabGroup;\r\n\r\n        if (group === undefined) {\r\n            return null;\r\n        }\r\n\r\n        return {tabIds: tabIds, group: group, anchor: anchor};\r\n    }\r\n\r\n    function handleClick(event, state) {\r\n        const info = getTabInfoFromEvent(event);\r\n\r\n        if (info === null) {\r\n            return;\r\n        }\r\n\r\n        event.preventDefault();\r\n        info.anchor.href = 'javascript:';\r\n\r\n        setTimeout(function () {\r\n            return info.anchor.href = '#' + info.anchor.getAttribute('aria-controls');\r\n        });\r\n\r\n        const tabIds = info.tabIds, group = info.group;\r\n        const originalTop = info.anchor.getBoundingClientRect().top;\r\n\r\n        if (group.independent) {\r\n            for (let _i = 0, _a = group.tabs; _i < _a.length; _i++) {\r\n                const tab = _a[_i];\r\n                tab.selected = arraysIntersect(tab.tabIds, tabIds);\r\n            }\r\n        } else {\r\n            if (arraysIntersect(state.selectedTabs, tabIds)) {\r\n                return;\r\n            }\r\n            const previousTabId = group.tabs.filter(function (t) {\r\n                return t.selected;\r\n            })[0].tabIds[0];\r\n            state.selectedTabs.splice(state.selectedTabs.indexOf(previousTabId), 1, tabIds[0]);\r\n            for (let _b = 0, _c = state.groups; _b < _c.length; _b++) {\r\n                const group_1 = _c[_b];\r\n                updateVisibilityAndSelection(group_1, state);\r\n            }\r\n            updateTabsQueryStringParam(state);\r\n        }\r\n        notifyContentUpdated();\r\n        const top = info.anchor.getBoundingClientRect().top;\r\n        if (top !== originalTop && event instanceof MouseEvent) {\r\n            window.scrollTo(0, window.pageYOffset + top - originalTop);\r\n        }\r\n    }\r\n\r\n    function selectTabs(tabIds) {\r\n        for (let _i = 0, tabIds_1 = tabIds; _i < tabIds_1.length; _i++) {\r\n            const tabId = tabIds_1[_i];\r\n            const a = document.querySelector(\".tabGroup > ul > li > a[data-tab=\\\"\" + tabId + \"\\\"]:not([hidden])\");\r\n\r\n            if (a === null) {\r\n                return;\r\n            }\r\n\r\n            a.dispatchEvent(new CustomEvent('click', {bubbles: true}));\r\n        }\r\n    }\r\n\r\n    function readTabsQueryStringParam() {\r\n        const qs = parseQueryString();\r\n        const t = qs.tabs;\r\n\r\n        if (t === undefined || t === '') {\r\n            return [];\r\n        }\r\n\r\n        return t.split(',');\r\n    }\r\n\r\n    function updateTabsQueryStringParam(state) {\r\n        const qs = parseQueryString();\r\n        qs.tabs = state.selectedTabs.join();\r\n\r\n        const url = location.protocol + \"//\" + location.host + location.pathname + \"?\" + toQueryString(qs) + location.hash;\r\n\r\n        if (location.href === url) {\r\n            return;\r\n        }\r\n\r\n        history.replaceState({}, document.title, url);\r\n    }\r\n\r\n    function toQueryString(args) {\r\n        const parts = [];\r\n\r\n        for (let name_1 in args) {\r\n            if (args.hasOwnProperty(name_1) && args[name_1] !== '' && args[name_1] !== null && args[name_1] !== undefined) {\r\n                parts.push(encodeURIComponent(name_1) + '=' + encodeURIComponent(args[name_1]));\r\n            }\r\n        }\r\n\r\n        return parts.join('&');\r\n    }\r\n\r\n    function parseQueryString(queryString) {\r\n        let match;\r\n        const pl = /\\+/g;\r\n        const search = /([^&=]+)=?([^&]*)/g;\r\n\r\n        const decode = function (s) {\r\n            return decodeURIComponent(s.replace(pl, ' '));\r\n        };\r\n\r\n        if (queryString === undefined) {\r\n            queryString = '';\r\n        }\r\n\r\n        queryString = queryString.substring(1);\r\n        const urlParams = {};\r\n\r\n        while (match = search.exec(queryString)) {\r\n            urlParams[decode(match[1])] = decode(match[2]);\r\n        }\r\n\r\n        return urlParams;\r\n    }\r\n\r\n    function arraysIntersect(a, b) {\r\n        for (let _i = 0, a_1 = a; _i < a_1.length; _i++) {\r\n            const itemA = a_1[_i];\r\n\r\n            for (let _a = 0, b_1 = b; _a < b_1.length; _a++) {\r\n                const itemB = b_1[_a];\r\n                if (itemA === itemB) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    function notifyContentUpdated() {\r\n        // Dispatch this event when needed\r\n        // window.dispatchEvent(new CustomEvent('content-update'));\r\n    }\r\n}\r\n","/**\r\n * Styling for tables in conceptual documents using Bootstrap.\r\n * See http://getbootstrap.com/css/#tables\r\n */\r\nfunction renderTables() {\r\n    $('table').addClass('table table-bordered table-striped table-condensed').wrap('<div class=\\\"table-responsive\\\"></div>');\r\n}\r\n","window.refresh = function (article) {\r\n\r\n    // Update markup result\r\n    if (typeof article == 'undefined' || typeof article.content == 'undefined') {\r\n        console.error(\"Null Argument\");\r\n    }\r\n\r\n    $(\"article.content\").html(article.content);\r\n\r\n    highlight();\r\n    renderTables();\r\n    renderAlerts();\r\n    renderAffix();\r\n    renderTabs();\r\n}\r\n\r\n$(document).on('wordpressMenuHasLoaded', function () {\r\n    const path = window.location.pathname;\r\n    const docsUrl = '/docs/articles/';\r\n    const wpNavBar = document.getElementById('menu-menu-principal');\r\n    const items = wpNavBar.getElementsByTagName('a');\r\n\r\n    for (let i = 0; i < items.length; i++) {\r\n\r\n        if (items[i].href.includes(docsUrl) && path.includes(docsUrl) && !items[i].href.includes('#')) {\r\n            $(items[i]).addClass('activepath');\r\n        }\r\n    }\r\n\r\n    const queryString = window.location.search;\r\n\r\n    if (queryString) {\r\n        const queryStringComponents = queryString.split('=');\r\n        const searchParam = queryStringComponents.slice(-1)[0];\r\n        $('#search-query').val(decodeURI(searchParam));\r\n    }\r\n\r\n});\r\n\r\n\r\n// Enable anchors for headings.\r\n(function () {\r\n    anchors.options = {\r\n        placement: 'right',\r\n        visible: 'hover',\r\n        icon: '#'\r\n    };\r\n    anchors.add('article h2:not(.no-anchor), article h3:not(.no-anchor), article h4:not(.no-anchor)');\r\n})();\r\n","// Enable highlight.js\r\nfunction highlight() {\r\n\r\n    $('pre code').each(function (i, block) {\r\n        hljs.highlightBlock(block);\r\n    });\r\n\r\n    $('pre code[highlight-lines]').each(function (i, block) {\r\n        if (block.innerHTML === \"\") return;\r\n        const lines = block.innerHTML.split('\\n');\r\n\r\n        const queryString = block.getAttribute('highlight-lines');\r\n        if (!queryString) return;\r\n\r\n        let rangesString = queryString.split(',');\r\n        let ranges = rangesString.map(Number);\r\n\r\n        for (let range of ranges) {\r\n            const found = range.match(/^(\\d+)\\-(\\d+)?$/);\r\n            let start = 0;\r\n            let end = 0;\r\n            if (found) {\r\n                // consider region as `{startlinenumber}-{endlinenumber}`, in which {endlinenumber} is optional\r\n                start = +found[1];\r\n                end = +found[2];\r\n                if (isNaN(end) || end > lines.length) {\r\n                    end = lines.length;\r\n                }\r\n            } else {\r\n                // consider region as a sigine line number\r\n                if (isNaN(range)) continue;\r\n                start = +range;\r\n                end = start;\r\n            }\r\n            if (start <= 0 || end <= 0 || start > end || start > lines.length) {\r\n                // skip current region if invalid\r\n                continue;\r\n            }\r\n            lines[start - 1] = '<span class=\"line-highlight\">' + lines[start - 1];\r\n            lines[end - 1] = lines[end - 1] + '</span>';\r\n        }\r\n\r\n        block.innerHTML = lines.join('\\n');\r\n    });\r\n}\r\n\r\n// Support full-text-search\r\nfunction enableSearch() {\r\n    let query;\r\n    const relHref = $(\"meta[property='docfx\\\\:rel']\").attr(\"content\");\r\n\r\n    if (typeof relHref === 'undefined') {\r\n        return;\r\n    }\r\n\r\n    try {\r\n        const worker = new Worker(relHref + 'styles/search-worker.js');\r\n        if (!worker && !window.worker) {\r\n            localSearch();\r\n        } else {\r\n            webWorkerSearch(worker);\r\n        }\r\n        renderSearchBox();\r\n        highlightKeywords();\r\n        addSearchEvent();\r\n    } catch (e) {\r\n        console.error(e);\r\n    }\r\n\r\n    //Adjust the position of search box in navbar\r\n    function renderSearchBox() {\r\n        autoCollapse();\r\n\r\n        $(window).on('resize', () => autoCollapse());\r\n\r\n        $(document).on('click', '.navbar-collapse.in', function (e) {\r\n            if ($(e.target).is('a')) {\r\n                $(this).collapse(hide);\r\n            }\r\n        });\r\n\r\n        function autoCollapse() {\r\n            const navbar = $('#autocollapse');\r\n            if (navbar.height() === null) {\r\n                setTimeout(autoCollapse, 300);\r\n            }\r\n            navbar.removeClass(collapsed);\r\n            if (navbar.height() > 60) {\r\n                navbar.addClass(collapsed);\r\n            }\r\n        }\r\n    }\r\n\r\n    // Search factory\r\n    function localSearch() {\r\n        const lunrIndex = lunr(function () {\r\n            this.ref('href');\r\n            this.field('title', {boost: 50});\r\n            this.field('keywords', {boost: 20});\r\n        });\r\n        lunr.tokenizer.seperator = /[\\s\\-\\.]+/;\r\n        let searchData = {};\r\n        const searchDataRequest = new XMLHttpRequest();\r\n\r\n        const indexPath = relHref + \"index.json\";\r\n        if (indexPath) {\r\n            searchDataRequest.open('GET', indexPath);\r\n            searchDataRequest.onload = function () {\r\n                if (this.status !== 200) {\r\n                    return;\r\n                }\r\n                searchData = JSON.parse(this.responseText);\r\n                for (let prop in searchData) {\r\n                    if (searchData.hasOwnProperty(prop)) {\r\n                        lunrIndex.add(searchData[prop]);\r\n                    }\r\n                }\r\n            }\r\n            searchDataRequest.send();\r\n        }\r\n\r\n        $(\"body\").on(\"queryReady\", function () {\r\n            const hits = lunrIndex.search(query);\r\n            const results = [];\r\n            hits.forEach(function (hit) {\r\n                const item = searchData[hit.ref];\r\n                results.push({'href': item.href, 'title': item.title, 'keywords': item.keywords});\r\n            });\r\n            handleSearchResults(results);\r\n        });\r\n    }\r\n\r\n    function webWorkerSearch(worker) {\r\n        const indexReady = $.Deferred();\r\n        worker.onmessage = function (oEvent) {\r\n            switch (oEvent.data.e) {\r\n                case 'index-ready':\r\n                    indexReady.resolve();\r\n                    break;\r\n                case 'query-ready':\r\n                    const hits = oEvent.data.d;\r\n                    handleSearchResults(hits);\r\n                    break;\r\n            }\r\n        }\r\n\r\n        indexReady.promise().done(function () {\r\n\r\n            $(\"body\").on(\"query-ready\", function () {\r\n                postSearchQuery(worker, query);\r\n            });\r\n\r\n            postSearchQuery(worker, query);\r\n\r\n        });\r\n    }\r\n\r\n    /**\r\n     * This function posts the message to the worker if the string has at least\r\n     * three characters.\r\n     *\r\n     * @param worker The search worker used by DocFx (lunr)\r\n     * @param searchQuery The string to post to the worker.\r\n     */\r\n    function postSearchQuery(worker, searchQuery) {\r\n        if (searchQuery && (searchQuery.length >= 3)) {\r\n            worker.postMessage({q: `${searchQuery}*`});\r\n        } else {\r\n            worker.postMessage({q: ''});\r\n        }\r\n    }\r\n\r\n    /**\r\n     *   Highlight the searching keywords\r\n     */\r\n    function highlightKeywords() {\r\n        const q = url('?q');\r\n        if (q != null) {\r\n            const keywords = q.split(\"%20\");\r\n            keywords.forEach(function (keyword) {\r\n                if (keyword !== \"\") {\r\n                    $('.data-searchable *').mark(keyword);\r\n                    $('article *').mark(keyword);\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    function addSearchEvent() {\r\n        $('body').on(\"searchEvent\", function () {\r\n            $('#search-results>.sr-items').html('<p>No results found</p>');\r\n\r\n            const searchQuery = $('#search-query');\r\n\r\n            searchQuery.on('input', function (e) {\r\n                return e.key !== 'Enter';\r\n            });\r\n\r\n            searchQuery.on(\"keyup\", function (e) {\r\n                $('#search-results').show();\r\n                query = `${e.target.value}`;\r\n                $(\"body\").trigger(\"query-ready\");\r\n                $('#search-results>.search-list').text('Search Results for \"' + query + '\"');\r\n            }).off(\"keydown\");\r\n        });\r\n    }\r\n\r\n    function relativeUrlToAbsoluteUrl(currentUrl, relativeUrl) {\r\n        const currentItems = currentUrl.split(/\\/+/);\r\n        const relativeItems = relativeUrl.split(/\\/+/);\r\n        let depth = currentItems.length - 1;\r\n        const items = [];\r\n        for (let i = 0; i < relativeItems.length; i++) {\r\n            if (relativeItems[i] === '..') {\r\n                depth--;\r\n            } else if (relativeItems[i] !== '.') {\r\n                items.push(relativeItems[i]);\r\n            }\r\n        }\r\n        return currentItems.slice(0, depth).concat(items).join('/');\r\n    }\r\n\r\n    function extractContentBrief(content) {\r\n        const briefOffset = 50;\r\n        const words = query.split(/\\s+/g);\r\n        const queryIndex = content.indexOf(words[0]);\r\n\r\n        if (queryIndex > briefOffset) {\r\n            return \"...\" + content.slice(queryIndex - briefOffset, queryIndex + briefOffset) + \"...\";\r\n        } else if (queryIndex <= briefOffset) {\r\n            return content.slice(0, queryIndex + briefOffset) + \"...\";\r\n        }\r\n    }\r\n\r\n    function handleSearchResults(hits) {\r\n        if (hits.length === 0) {\r\n            $('#search-results>.sr-items').html('<p>No results found</p>');\r\n        } else {\r\n            $('#search-results>.sr-items').empty().append(\r\n                hits.slice(0, 20).map(function (hit) {\r\n                    const currentUrl = window.location.href;\r\n\r\n                    const itemRawHref = relativeUrlToAbsoluteUrl(currentUrl, relHref + hit.href);\r\n                    const itemHref = relHref + hit.href + \"?q=\" + query;\r\n                    const itemTitle = hit.title;\r\n                    const itemBrief = extractContentBrief(hit.keywords);\r\n\r\n                    const itemNode = $('<a>').attr('class', 'sr-item').attr('href', itemHref);\r\n                    const itemTitleNode = $('<div>').attr('class', 'item-title').text(itemTitle);\r\n                    const itemBriefNode = $('<div>').attr('class', 'item-brief').text(itemBrief);\r\n                    itemNode.append(itemTitleNode).append(itemBriefNode);\r\n\r\n                    return itemNode;\r\n                })\r\n            );\r\n            query.split(/\\s+/).forEach(function (word) {\r\n                if (word !== '') {\r\n                    word = word.replace(/\\*/g, '');\r\n                    $('#search-results>.sr-items *').mark(word);\r\n                }\r\n            });\r\n        }\r\n    }\r\n}\r\n","function getAbsolutePath(href) {\r\n    // Use anchor to normalize href\r\n    const anchor = $('<a href=\"' + href + '\"></a>')[0];\r\n    // Ignore protocal, remove search and query\r\n    return anchor.host + anchor.pathname;\r\n}\r\n\r\nfunction isRelativePath(href) {\r\n    if (href === undefined || href === '' || href[0] === '/') {\r\n        return false;\r\n    }\r\n    return !isAbsolutePath(href);\r\n}\r\n\r\nfunction isAbsolutePath(href) {\r\n    return (/^(?:[a-z]+:)?\\/\\//i).test(href);\r\n}\r\n\r\nfunction getDirectory(href) {\r\n    if (!href) {\r\n        return '';\r\n    }\r\n\r\n    const index = href.lastIndexOf('/');\r\n\r\n    if (index === -1) {\r\n        return '';\r\n    }\r\n\r\n    if (index > -1) {\r\n        return href.substr(0, index);\r\n    }\r\n}\r\n\r\nfunction formList(item, classes) {\r\n    let level = 1;\r\n    const model = {\r\n        items: item\r\n    };\r\n\r\n    const cls = [].concat(classes).join(\" \");\r\n    return getList(model, cls);\r\n\r\n    function getList(model, cls) {\r\n\r\n        if (!model || !model.items) {\r\n            return null;\r\n        }\r\n\r\n        const l = model.items.length;\r\n\r\n        if (l === 0) {\r\n            return null;\r\n        }\r\n\r\n        let html = '<ul class=\"level' + level + ' ' + (cls || '') + '\">';\r\n        level++;\r\n\r\n        for (let i = 0; i < l; i++) {\r\n            const item = model.items[i];\r\n            const href = item.href;\r\n            const name = item.name;\r\n\r\n            if (!name) {\r\n                continue;\r\n            }\r\n\r\n            html += href ? '<li><a href=\"' + href + '\">' + name + '</a>' : '<li>' + name;\r\n            html += getList(item, cls) || '';\r\n            html += '</li>';\r\n        }\r\n\r\n        html += '</ul>';\r\n        return html;\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Add <wbr> into long word.\r\n * @param {String} text - The word to break. It should be in plain text without HTML tags.\r\n */\r\nfunction breakPlainText(text) {\r\n    if (!text) return text;\r\n    return text.replace(/([a-z])([A-Z])|(\\.)(\\w)/g, '$1$3<wbr>$2$4')\r\n}\r\n\r\n/**\r\n * Add <wbr> into long word. The jQuery element should contain no html tags.\r\n * If the jQuery element contains tags, this function will not change the element.\r\n */\r\nfunction breakWord() {\r\n    if (this.html() === this.text()) {\r\n        this.html(function (index, text) {\r\n            return breakPlainText(text);\r\n        })\r\n    }\r\n\r\n    return this;\r\n}\r\n\r\n/**\r\n * adjusted from https://stackoverflow.com/a/13067009/1523776\r\n */\r\nfunction workAroundFixedHeaderForAnchors() {\r\n    const HISTORY_SUPPORT = !!(history && history.pushState);\r\n    const ANCHOR_REGEX = /^#[^ ]+$/;\r\n\r\n    function getFixedOffset() {\r\n        return $('header').first().height();\r\n    }\r\n\r\n    /**\r\n     * If the provided href is an anchor which resolves to an element on the\r\n     * page, scroll to it.\r\n     * @param  {String} href destination\r\n     * @param  {Boolean} pushToHistory push to history\r\n     * @return {Boolean} - Was the href an anchor.\r\n     */\r\n    function scrollIfAnchor(href, pushToHistory) {\r\n        let match, rect, anchorOffset;\r\n\r\n        if (!ANCHOR_REGEX.test(href)) {\r\n            return false;\r\n        }\r\n\r\n        match = document.getElementById(href.slice(1));\r\n\r\n        if (match) {\r\n            rect = match.getBoundingClientRect();\r\n            anchorOffset = window.pageYOffset + rect.top - getFixedOffset();\r\n            window.scrollTo(window.pageXOffset, anchorOffset);\r\n\r\n            // Add the state to history as-per normal anchor links\r\n            if (HISTORY_SUPPORT && pushToHistory) {\r\n                history.pushState({}, document.title, location.pathname + href);\r\n            }\r\n        }\r\n\r\n        return !!match;\r\n    }\r\n\r\n    /**\r\n     * Attempt to scroll to the current location's hash.\r\n     */\r\n    function scrollToCurrent() {\r\n        scrollIfAnchor(window.location.hash, false);\r\n    }\r\n\r\n    $(window).on('hashchange', () => scrollToCurrent());\r\n    // Exclude tabbed content case\r\n    scrollToCurrent();\r\n\r\n    $(document).on('ready', function () {\r\n        $('body').scrollspy({offset: 150});\r\n    });\r\n}\r\n\r\nfunction breakText() {\r\n    $(\".xref\").addClass(\"text-break\");\r\n    const texts = $(\".text-break\");\r\n    texts.each(function () {\r\n        $(this).breakWord();\r\n    });\r\n}\r\n"]}
diff --git a/doc/templates/uno/styles/main.css b/doc/templates/uno/styles/main.css
index 23db05d2d0d565be4148429d442d2c3d3ac21675..918dc2a49d0528239686e941c8d78899f9a1b15a 100644
--- a/doc/templates/uno/styles/main.css
+++ b/doc/templates/uno/styles/main.css
@@ -1,11 +1,535 @@
-@import url("https://fonts.googleapis.com/css?family=Open+Sans:500,600,700,800,400italic,700italic,400");@import url("https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css");:target::before{content:'';display:block;margin-top:-130px;height:130px;width:1px}body{font-family:'Open Sans', sans-serif;color:#242424}body mark{background:rgba(21,155,255,0.25)}body .toc{background-color:transparent}.row:before{content:none}.row:after{content:''}a{color:#159bff}a:hover,a:active{color:#242424}h1{font-size:40px;font-weight:600;text-transform:none}@media only screen and (max-width: 767px){h1{font-size:32px}}h2{font-size:34px;font-weight:600;text-transform:none}@media only screen and (max-width: 767px){h2{font-size:28px}}h3{font-size:28px;font-weight:600;text-transform:none}@media only screen and (max-width: 767px){h3{font-size:22px}}@media screen{pre{overflow:auto}pre>code{white-space:pre}}.container{width:100%}#breadcrumb{padding:0 32px}.breadcrumb{white-space:inherit}.body-content .article{margin-right:0}@media only screen and (min-width: 769px){.sidefilter{width:24%}}@media (min-width: 769px) and (max-width: 991px){.sidefilter{width:30%}}@media only screen and (min-width: 769px){.article.grid-right{margin-left:26%}}@media (min-width: 769px) and (max-width: 991px){.article.grid-right{margin-left:32%}}.sidetoc{top:180px;background-color:white !important}@media only screen and (min-width: 769px){.sidetoc{width:24%}}@media (min-width: 769px) and (max-width: 991px){.sidetoc{width:30%}}.sidetoc .nav>li{line-height:1.79}.sidetoc .nav>li a{color:#242424}.sidetoc .nav>li.active>a{color:#242424;font-weight:bold}.sidetoc .nav>li.active>a:hover{color:#000}.sidetoc .toc .nav>li.filtered>ul,.sidetoc .toc .nav>li.in>ul{display:block}@media only screen and (max-width: 768px){.sidetoc .toc .nav>li.filtered>ul,.sidetoc .toc .nav>li.in>ul{display:grid}}@media only screen and (max-width: 768px){.sidetoc .toc li:after{display:none}}.sidetoc .toc .nav>li>.expand-stub::before{font-family:'Glyphicons Halflings', 'ui-sans-serif';content:'\e258';font-size:0.8em}.sidetoc .toc .nav>li.in>.expand-stub::before{font-family:'Glyphicons Halflings', 'ui-sans-serif';display:inline-block;content:'\e258';font-size:0.8em;transform:rotate(90deg)}.sidetoc .toc ul ul>li>a:before{content:''}.sidetoc .toc ul{padding-left:5px;text-align:left}@media only screen and (max-width: 768px){.sidetoc .toc ul{text-align:left}}.sidetoc .toc ul li a{padding-left:5px}@media only screen and (max-width: 768px){.sidetoc .toc{margin-left:0}.sidetoc .toc ul{margin:0}.sidetoc .toc ul li a{margin:0}}@media only screen and (max-width: 767px){.sidenav{position:fixed;width:100%;z-index:999}}.front-page article section{margin-left:auto}.front-page p{margin:20px auto}.front-page .subnav,.front-page .sideaffix,.front-page .footer{display:none}.front-page .body-content{width:100%;padding:0;overflow:hidden}.front-page .body-content .article{margin:0 !important}.front-page .body-content .article>[class*='col']{width:auto;padding:0;float:none}.front-page .button{display:inline-block}.front-page .button a{display:inline-block;padding:7px 17px;font-size:20px;font-weight:bold;box-shadow:0 2px 4px 0 rgba(31,31,31,0.25);border-radius:8px;transition:color 0.2s ease-in-out,
background-color 0.2s ease-in-out}.front-page .button.white a{background:#fff;color:#242424}.front-page .button.white a:hover{background:#7a67f8;color:#fff}.front-page .button.turquoise a{background:#7a67f8;color:#fff}.front-page .button.turquoise a:hover{background:#654ff7}.front-page .intro{padding:100px 15px 60px;text-align:center;font-size:18px;position:relative}@media screen and (min-width: 768px){.front-page .intro{padding:200px 15px 120px}}.front-page .intro h1{font-size:36px;text-transform:none;font-weight:600;width:auto;max-width:100%;margin:0 auto;letter-spacing:normal}@media screen and (min-width: 768px){.front-page .intro h1{font-size:44px}}.front-page .intro p{width:100%;font-size:22px}.front-page .intro strong{font-weight:bold}.front-page .intro .button a{margin-top:20px}.front-page .headerboxes{display:flex;flex-wrap:wrap;padding:40px 15px;background-color:#f4f2f3}@media screen and (min-width: 768px){.front-page .headerboxes{padding:80px 15px}}.front-page .headerboxes .headerbox{margin:40px auto}.front-page .headerboxes .headerbox-inner{padding:0;height:100%}.front-page .headerboxes h2{font-size:30px;font-weight:600;text-transform:none}.front-page .headerboxes h2 .anchorjs-link{display:none}.front-page .headerboxes p{font-size:16px;font-weight:600}.front-page .headerboxes .icon{margin:0}
+@import url("https://fonts.googleapis.com/css?family=Open+Sans:500,600,700,800,400italic,700italic,400");
+@import url("https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css");
+:target::before {
+ content: '';
+ display: block;
+ margin-top: -130px;
+ height: 130px;
+ width: 1px; }
+body {
+ font-family: 'Open Sans', sans-serif;
+ color: #242424; }
+ body mark {
+ background: rgba(21, 155, 255, 0.25); }
+ body .toc {
+ background-color: transparent; }
-.sideaffix{overflow:auto}.sideaffix .affix ul>li.active>ul,.sideaffix .affix ul>li.active>a:before,.sideaffix .affix ul>li>a:hover:before{white-space:normal}.sideaffix .contribution-link{font-size:16px !important}.sideaffix #affix{font-size:16px;font-weight:600;line-height:1.5;height:auto}.sideaffix #affix a{color:#242424}.sideaffix #affix ul>li.active>a{font-weight:bold}.sideaffix #affix ul>li.active>a:before{color:#242424}.sideaffix #affix ul>li.active>a ul>li.active>a{font-weight:bold}.sideaffix #affix ul>li.active>a ul>li.active>a:before{color:#242424}.sideaffix #affix ul ul>li>a:before{top:2px}.sideaffix #affix li:last-child{padding-bottom:16px;margin-bottom:0}.sideaffix #affix .title{text-transform:none;font-size:20px}.sideaffix #affix .level1::before{width:75%;border-top:1px solid #c4c4c4}.sideaffix #affix .level1::after{width:75%;border-top:1px solid #c4c4c4}
+.row:before {
+ content: none; }
-.alert{background-color:transparent;border-color:#c4c4c4;color:#242424;padding:16px 16px;transition:transform .2s}.alert-hover:hover{transform:scale(1.05);border-color:#159bff;box-shadow:0 5px 10px 0 rgba(0,0,0,0.2)}.alert-hover:hover h4{color:#159bff}
+.row:after {
+ content: ''; }
+a {
+ color: #159bff; }
+ a:hover, a:active {
+ color: #242424; }
-@media (min-width: 980px){.visibility-opacity-transition,#header-container nav>ul>li.has-children>ul,#header-container nav>ul>li.has-children>ul ul{visibility:hidden;list-style:none;transition:visibility 100ms, opacity 100ms ease-in-out;opacity:0}}#header-container{display:flex;position:fixed;background:#fff;width:100%;min-height:75px;padding:16px 32px;border-bottom:1px solid #f4f2f3;justify-content:space-between;z-index:9999}#header-container::after,#header-container::before{content:none}#header-container #menu-menu-principal{float:right;list-style:none}@media (max-width: 1023.98px){#header-container #menu-menu-principal{width:100%}}@media (min-width: 980px){#header-container #menu-menu-principal{display:flex}}#header-container #header-logo-container{width:36px;vertical-align:middle}#header-container #header-logo-container img{width:100%}@media (min-width: 980px){#header-container #header-logo-container{width:120px}}#header-container .navbar-toggle{padding:0;margin:10px 0;display:none !important}#header-container .navbar-toggle .icon-bar{background:#242424;width:20px}#header-container .navbar-toggle .icon-bar+.icon-bar{margin-top:3px}@media (max-width: 979px){#header-container .navbar-toggle{display:block !important}}#header-container .navbar-brand{height:auto}#header-container nav a{padding:10px;font-size:16px;font-weight:600;font-stretch:normal;font-style:normal;line-height:16px;letter-spacing:normal;text-transform:uppercase;color:#242424}#header-container nav a:hover,#header-container nav a:focus{border-radius:4px;background-color:rgba(103,229,173,0.2)}#header-container nav>ul>li{margin:0 16px;align-self:center}#header-container nav>ul>li.has-children{position:relative}#header-container nav>ul>li.has-children>ul{width:inherit}@media (min-width: 980px){#header-container nav>ul>li.has-children>ul{display:flex;position:absolute;padding:24px 48px;top:170% !important;left:-100% !important;flex-direction:column;border-radius:4px;box-shadow:0 0 20px 2px rgba(36,36,36,0.2);background-color:#fff}}#header-container nav>ul>li.has-children>ul li{display:flex}#header-container nav>ul>li.has-children>ul a{font-size:14px;font-weight:400;line-height:20px;text-transform:none;transition:0s}#header-container nav>ul>li.has-children>ul .column-title{flex-direction:column}#header-container nav>ul>li.has-children>ul .column-title>a{cursor:default;font-weight:700;line-height:normal !important;color:#242424}#header-container nav>ul>li.has-children>ul .column-title>a:hover,#header-container nav>ul>li.has-children>ul .column-title>a:focus{background-color:transparent}#header-container nav>ul>li.has-children>ul .column-title ul{width:192px;padding:0}#header-container nav>ul>li.has-children>ul ul{display:flex;position:inherit;flex-direction:column}#header-container nav>ul>li.has-children>ul ul a{border-left:0}#header-container nav>ul>li.has-children:hover>ul{visibility:visible;opacity:1}#header-container nav>ul>li.has-children:hover>ul:not([style*="display: none;"]) .has-children ul{visibility:visible;opacity:1}#header-container nav>ul>li.row-menu>ul{flex-direction:row}#header-container .get-started-btn a{display:block;border:none;border-radius:8px;margin-left:0;padding:8px 32px;font-size:16px;font-weight:700;min-width:125px;text-align:center;text-transform:none;color:#242424;background-color:#67e5ad;background:linear-gradient(to top, #159bff 50%, #67e5ad 50%);background-size:100% 200%;background-position:left top;transition:all 0.5s cubic-bezier(0.69, 0.04, 0.9, 0.65)}#header-container .get-started-btn a:hover{color:#fff;background-position:bottom left}@media (max-width: 979px){#navbar{overflow:auto !important;position:fixed;width:100%;margin:0;padding:0;top:75px;left:0;text-align:left;background:#fff}#navbar.collapse{display:none !important}#navbar.collapse.in{display:block !important}#navbar .menu{display:block;margin:0;padding:0 0 10px 0}#navbar .menu li{display:block;padding:0}#navbar .menu li.has-children{position:relative}#navbar .menu li.has-children ul{position:relative;max-height:0;padding:0;overflow:hidden;transition:all .5s ease}#navbar .menu li.has-children.open ul{max-height:1500px}#navbar .menu a{display:block;padding:10px 25px;line-height:1.4;font-weight:700}}.subnav{position:fixed;top:75px;width:100%;z-index:999;background-color:#f8f8f8}
+h1 {
+ font-size: 40px;
+ font-weight: 600;
+ text-transform: none; }
+ @media only screen and (max-width: 767px) {
+ h1 {
+ font-size: 32px; } }
-.sidefilter{top:116px;z-index:2;padding:10px;background-color:transparent !important}.sidefilter #search{display:block;border-radius:10px}.sidefilter #search input:focus{outline:none;border:2px solid #159bff}.sidefilter #search-query{border-radius:6px;height:45px;width:100%;padding:10px}.sidefilter #search-results{background:white;position:absolute;margin:5px 0 0 0;width:560px;max-height:calc(100vh - 250px);border:1px solid rgba(0,0,0,0.15);border-radius:10px;box-shadow:0 5px 10px 0 rgba(0,0,0,0.2);z-index:1;overflow-y:auto}.sidefilter #search-results .sr-items a{color:black}.sidefilter #search-results .sr-items a:last-child{margin-bottom:0}.sidefilter #search-results .sr-items p{margin:10px}.sidefilter #search-results .sr-items .sr-item{display:block;padding:15px;margin-bottom:10px}.sidefilter #search-results .sr-items .sr-item:hover{background-image:linear-gradient(to bottom, rgba(21,155,255,0.11) 0%, rgba(21,155,255,0.11) 100%),linear-gradient(to bottom, rgba(21,155,255,0.11) 0%, rgba(21,155,255,0.11) 100%)}.sidefilter #search-results .sr-items .item-title{font-size:16px;font-weight:bold}.sidefilter #search-results .sr-items .item-brief{font-size:16px;color:black}@media (max-width: 767px){.sidefilter #search-results{width:95%;overflow-y:scroll;max-height:400px}}
+h2 {
+ font-size: 34px;
+ font-weight: 600;
+ text-transform: none; }
+ @media only screen and (max-width: 767px) {
+ h2 {
+ font-size: 28px; } }
+
+h3 {
+ font-size: 28px;
+ font-weight: 600;
+ text-transform: none; }
+ @media only screen and (max-width: 767px) {
+ h3 {
+ font-size: 22px; } }
+
+@media screen {
+ pre {
+ overflow: auto; }
+ pre > code {
+ white-space: pre; } }
+
+.container {
+ width: 100%; }
+
+#breadcrumb {
+ padding: 0 32px; }
+
+.breadcrumb {
+ white-space: inherit; }
+
+.body-content .article {
+ margin-right: 0; }
+
+@media only screen and (min-width: 769px) {
+ .sidefilter {
+ width: 24%; } }
+
+@media (min-width: 769px) and (max-width: 991px) {
+ .sidefilter {
+ width: 30%; } }
+
+@media only screen and (min-width: 769px) {
+ .article.grid-right {
+ margin-left: 26%; } }
+
+@media (min-width: 769px) and (max-width: 991px) {
+ .article.grid-right {
+ margin-left: 32%; } }
+
+.sidetoc {
+ top: 180px;
+ background-color: white !important; }
+ @media only screen and (min-width: 769px) {
+ .sidetoc {
+ width: 24%; } }
+ @media (min-width: 769px) and (max-width: 991px) {
+ .sidetoc {
+ width: 30%; } }
+ .sidetoc .nav > li {
+ line-height: 1.79; }
+ .sidetoc .nav > li a {
+ color: #242424; }
+ .sidetoc .nav > li.active > a {
+ color: #242424;
+ font-weight: bold; }
+ .sidetoc .nav > li.active > a:hover {
+ color: #000; }
+ .sidetoc .toc .nav > li.filtered > ul, .sidetoc .toc .nav > li.in > ul {
+ display: block; }
+ @media only screen and (max-width: 768px) {
+ .sidetoc .toc .nav > li.filtered > ul, .sidetoc .toc .nav > li.in > ul {
+ display: grid; } }
+ @media only screen and (max-width: 768px) {
+ .sidetoc .toc li:after {
+ display: none; } }
+ .sidetoc .toc .nav > li > .expand-stub::before {
+ font-family: 'Glyphicons Halflings', 'ui-sans-serif';
+ content: '\e258';
+ font-size: 0.8em; }
+ .sidetoc .toc .nav > li.in > .expand-stub::before {
+ font-family: 'Glyphicons Halflings', 'ui-sans-serif';
+ display: inline-block;
+ content: '\e258';
+ font-size: 0.8em;
+ transform: rotate(90deg); }
+ .sidetoc .toc ul ul > li > a:before {
+ content: ''; }
+ .sidetoc .toc ul {
+ padding-left: 5px;
+ text-align: left; }
+ @media only screen and (max-width: 768px) {
+ .sidetoc .toc ul {
+ text-align: left; } }
+ .sidetoc .toc ul li a {
+ padding-left: 5px; }
+ @media only screen and (max-width: 768px) {
+ .sidetoc .toc {
+ margin-left: 0; }
+ .sidetoc .toc ul {
+ margin: 0; }
+ .sidetoc .toc ul li a {
+ margin: 0; } }
+
+@media only screen and (max-width: 767px) {
+ .sidenav {
+ position: fixed;
+ width: 100%;
+ z-index: 999; } }
+
+.front-page article section {
+ margin-left: auto; }
+
+.front-page p {
+ margin: 20px auto; }
+
+.front-page .subnav,
+.front-page .sideaffix,
+.front-page .footer {
+ display: none; }
+
+.front-page .body-content {
+ width: 100%;
+ padding: 0;
+ overflow: hidden; }
+ .front-page .body-content .article {
+ margin: 0 !important; }
+ .front-page .body-content .article > [class*='col'] {
+ width: auto;
+ padding: 0;
+ float: none; }
+
+.front-page .button {
+ display: inline-block; }
+ .front-page .button a {
+ display: inline-block;
+ padding: 7px 17px;
+ font-size: 20px;
+ font-weight: bold;
+ box-shadow: 0 2px 4px 0 rgba(31, 31, 31, 0.25);
+ border-radius: 8px;
+ transition: color 0.2s ease-in-out,
background-color 0.2s ease-in-out; }
+ .front-page .button.white a {
+ background: #fff;
+ color: #242424; }
+ .front-page .button.white a:hover {
+ background: #7a67f8;
+ color: #fff; }
+ .front-page .button.turquoise a {
+ background: #7a67f8;
+ color: #fff; }
+ .front-page .button.turquoise a:hover {
+ background: #654ff7; }
+
+.front-page .intro {
+ padding: 100px 15px 60px;
+ text-align: center;
+ font-size: 18px;
+ position: relative; }
+ @media screen and (min-width: 768px) {
+ .front-page .intro {
+ padding: 200px 15px 120px; } }
+ .front-page .intro h1 {
+ font-size: 36px;
+ text-transform: none;
+ font-weight: 600;
+ width: auto;
+ max-width: 100%;
+ margin: 0 auto;
+ letter-spacing: normal; }
+ @media screen and (min-width: 768px) {
+ .front-page .intro h1 {
+ font-size: 44px; } }
+ .front-page .intro p {
+ width: 100%;
+ font-size: 22px; }
+ .front-page .intro strong {
+ font-weight: bold; }
+ .front-page .intro .button a {
+ margin-top: 20px; }
+
+.front-page .headerboxes {
+ display: flex;
+ flex-wrap: wrap;
+ padding: 40px 15px;
+ background-color: #f4f2f3; }
+ @media screen and (min-width: 768px) {
+ .front-page .headerboxes {
+ padding: 80px 15px; } }
+ .front-page .headerboxes .headerbox {
+ margin: 40px auto; }
+ .front-page .headerboxes .headerbox-inner {
+ padding: 0;
+ height: 100%; }
+ .front-page .headerboxes h2 {
+ font-size: 30px;
+ font-weight: 600;
+ text-transform: none; }
+ .front-page .headerboxes h2 .anchorjs-link {
+ display: none; }
+ .front-page .headerboxes p {
+ font-size: 16px;
+ font-weight: 600; }
+ .front-page .headerboxes .icon {
+ margin: 0; }
+
+
+.sideaffix {
+ overflow: auto; }
+ .sideaffix .affix ul > li.active > ul, .sideaffix .affix ul > li.active > a:before, .sideaffix .affix ul > li > a:hover:before {
+ white-space: normal; }
+ .sideaffix .contribution-link {
+ font-size: 16px !important; }
+ .sideaffix #affix {
+ font-size: 16px;
+ font-weight: 600;
+ line-height: 1.5;
+ height: auto; }
+ .sideaffix #affix a {
+ color: #242424; }
+ .sideaffix #affix ul > li.active > a {
+ font-weight: bold; }
+ .sideaffix #affix ul > li.active > a:before {
+ color: #242424; }
+ .sideaffix #affix ul > li.active > a ul > li.active > a {
+ font-weight: bold; }
+ .sideaffix #affix ul > li.active > a ul > li.active > a:before {
+ color: #242424; }
+ .sideaffix #affix ul ul > li > a:before {
+ top: 2px; }
+ .sideaffix #affix li:last-child {
+ padding-bottom: 16px;
+ margin-bottom: 0; }
+ .sideaffix #affix .title {
+ text-transform: none;
+ font-size: 20px; }
+ .sideaffix #affix .level1::before {
+ width: 75%;
+ border-top: 1px solid #c4c4c4; }
+ .sideaffix #affix .level1::after {
+ width: 75%;
+ border-top: 1px solid #c4c4c4; }
+
+.alert {
+ background-color: transparent;
+ border-color: #c4c4c4;
+ color: #242424;
+ padding: 16px 16px;
+ transition: transform .2s; }
+
+.alert-hover:hover {
+ transform: scale(1.05);
+ border-color: #159bff;
+ box-shadow: 0 5px 10px 0 rgba(0, 0, 0, 0.2); }
+ .alert-hover:hover h4 {
+ color: #159bff; }
+
+
+/**
+ * General notes:
+ * This file is modifying the elementor menu as simply as it can. The selector are a bit hard to
+ * understand because we cannot add class or ids on the menu.
+ *
+ * This is a modified version of the css in the header.scss file from the main website.
+ * It was modified as little as possible, but they are quite different.
+ *
+ * Pixel are preferred as unit since the body font size is not the same as the website.
+ * This causes relative units (em, rem) to behave differently.
+ */
+@media (min-width: 980px) {
+ .visibility-opacity-transition, #header-container nav > ul > li.has-children > ul, #header-container nav > ul > li.has-children > ul ul {
+ visibility: hidden;
+ list-style: none;
+ transition: visibility 100ms, opacity 100ms ease-in-out;
+ opacity: 0; } }
+
+#header-container {
+ display: flex;
+ position: fixed;
+ background: #fff;
+ width: 100%;
+ min-height: 75px;
+ padding: 16px 32px;
+ border-bottom: 1px solid #f4f2f3;
+ justify-content: space-between;
+ z-index: 9999; }
+ #header-container::after, #header-container::before {
+ content: none; }
+ #header-container #menu-menu-principal {
+ float: right;
+ list-style: none; }
+ @media (max-width: 1023.98px) {
+ #header-container #menu-menu-principal {
+ width: 100%; } }
+ @media (min-width: 980px) {
+ #header-container #menu-menu-principal {
+ display: flex; } }
+ #header-container #header-logo-container {
+ width: 36px;
+ vertical-align: middle; }
+ #header-container #header-logo-container img {
+ width: 100%; }
+ @media (min-width: 980px) {
+ #header-container #header-logo-container {
+ width: 120px; } }
+ #header-container .navbar-toggle {
+ padding: 0;
+ margin: 10px 0;
+ display: none !important; }
+ #header-container .navbar-toggle .icon-bar {
+ background: #242424;
+ width: 20px; }
+ #header-container .navbar-toggle .icon-bar + .icon-bar {
+ margin-top: 3px; }
+ @media (max-width: 979px) {
+ #header-container .navbar-toggle {
+ display: block !important; } }
+ #header-container .navbar-brand {
+ height: auto; }
+ #header-container nav {
+ /**
+ * Top level menu items
+ */ }
+ #header-container nav a {
+ padding: 10px;
+ font-size: 16px;
+ font-weight: 600;
+ font-stretch: normal;
+ font-style: normal;
+ line-height: 16px;
+ letter-spacing: normal;
+ text-transform: uppercase;
+ color: #242424; }
+ #header-container nav a:hover, #header-container nav a:focus {
+ border-radius: 4px;
+ background-color: rgba(103, 229, 173, 0.2); }
+ #header-container nav > ul > li {
+ margin: 0 16px;
+ align-self: center;
+ /**
+ * has-children means there is a submenu
+ */
+ /**
+ * row-menu : the row menu class puts the first element of the menu in a row
+ * instead of a column (default). This makes it possible to have
+ * multiple columns side by side by add the row-menu class in wordpress.
+ */ }
+ #header-container nav > ul > li.has-children {
+ position: relative; }
+ #header-container nav > ul > li.has-children > ul {
+ width: inherit; }
+ @media (min-width: 980px) {
+ #header-container nav > ul > li.has-children > ul {
+ display: flex;
+ position: absolute;
+ padding: 24px 48px;
+ top: 170% !important;
+ left: -100% !important;
+ flex-direction: column;
+ border-radius: 4px;
+ box-shadow: 0 0 20px 2px rgba(36, 36, 36, 0.2);
+ background-color: #fff; } }
+ #header-container nav > ul > li.has-children > ul li {
+ display: flex; }
+ #header-container nav > ul > li.has-children > ul a {
+ font-size: 14px;
+ font-weight: 400;
+ line-height: 20px;
+ text-transform: none;
+ transition: 0s; }
+ #header-container nav > ul > li.has-children > ul .column-title {
+ flex-direction: column; }
+ #header-container nav > ul > li.has-children > ul .column-title > a {
+ cursor: default;
+ font-weight: 700;
+ line-height: normal !important;
+ color: #242424; }
+ #header-container nav > ul > li.has-children > ul .column-title > a:hover, #header-container nav > ul > li.has-children > ul .column-title > a:focus {
+ background-color: transparent; }
+ #header-container nav > ul > li.has-children > ul .column-title ul {
+ width: 192px;
+ padding: 0; }
+ #header-container nav > ul > li.has-children > ul ul {
+ display: flex;
+ position: inherit;
+ flex-direction: column; }
+ #header-container nav > ul > li.has-children > ul ul a {
+ border-left: 0; }
+ #header-container nav > ul > li.has-children:hover > ul {
+ visibility: visible;
+ opacity: 1;
+ /**
+ * This selector makes sure the submenu of a submenu appears under it
+ * instead of on hover. This is to displays submenus as columns.
+ */ }
+ #header-container nav > ul > li.has-children:hover > ul:not([style*="display: none;"]) .has-children ul {
+ visibility: visible;
+ opacity: 1; }
+ #header-container nav > ul > li.row-menu > ul {
+ flex-direction: row; }
+ #header-container .get-started-btn a {
+ display: block;
+ border: none;
+ border-radius: 8px;
+ margin-left: 0;
+ padding: 8px 32px;
+ font-size: 16px;
+ font-weight: 700;
+ min-width: 125px;
+ text-align: center;
+ text-transform: none;
+ color: #242424;
+ background-color: #67e5ad;
+ background: linear-gradient(to top, #159bff 50%, #67e5ad 50%);
+ background-size: 100% 200%;
+ background-position: left top;
+ transition: all 0.5s cubic-bezier(0.69, 0.04, 0.9, 0.65); }
+ #header-container .get-started-btn a:hover {
+ color: #fff;
+ background-position: bottom left; }
+
+@media (max-width: 979px) {
+ #navbar {
+ overflow: auto !important;
+ position: fixed;
+ width: 100%;
+ margin: 0;
+ padding: 0;
+ top: 75px;
+ left: 0;
+ text-align: left;
+ background: #fff; }
+ #navbar.collapse {
+ display: none !important; }
+ #navbar.collapse.in {
+ display: block !important; }
+ #navbar .menu {
+ display: block;
+ margin: 0;
+ padding: 0 0 10px 0; }
+ #navbar .menu li {
+ display: block;
+ padding: 0; }
+ #navbar .menu li.has-children {
+ position: relative; }
+ #navbar .menu li.has-children ul {
+ position: relative;
+ max-height: 0;
+ padding: 0;
+ overflow: hidden;
+ transition: all .5s ease; }
+ #navbar .menu li.has-children.open ul {
+ max-height: 1500px; }
+ #navbar .menu a {
+ display: block;
+ padding: 10px 25px;
+ line-height: 1.4;
+ font-weight: 700; } }
+
+.subnav {
+ position: fixed;
+ top: 75px;
+ width: 100%;
+ z-index: 999;
+ background-color: #f8f8f8; }
+
+:root {
+ --docsearch-primary-color: #159bff !important;
+ --docsearch-logo-color: #159bff !important; }
+
+.sidefilter {
+ background-color: transparent;
+ height: 60px;
+ padding: 10px; }
+ .sidefilter .DocSearch-Button {
+ background: transparent;
+ border: 2px inset #242424;
+ border-radius: 6px;
+ margin: 0;
+ min-height: 45px;
+ padding: 10px;
+ width: 100%; }
+ .sidefilter .DocSearch-Button:active, .sidefilter .DocSearch-Button:focus, .sidefilter .DocSearch-Button:hover {
+ border: 2px solid #159bff;
+ box-shadow: none; }
+ .sidefilter .DocSearch-Button .DocSearch-Search-Icon {
+ display: none; }
+ .sidefilter .DocSearch-Button-Placeholder {
+ color: #757575;
+ font-family: "Open Sans", sans-serif;
+ font-size: 14px;
+ line-height: 20px;
+ padding: 10px;
+ display: block; }
+
+.DocSearch.DocSearch-Container {
+ z-index: 9999; }
+
+/*# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../main.scss","../variables.scss","variables.css","../component/affix.scss","../component/alerts.scss","component/breakpoints.css","../component/navbar.scss","../component/navbar.css","../component/breakpoints.scss","../service/search.scss"],"names":[],"mappings":"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","file":"main.css","sourcesContent":["@import url('https://fonts.googleapis.com/css?family=Open+Sans:500,600,700,800,400italic,700italic,400');\r\n@import url(\"https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css\");\r\n@import \"variables\";\r\n\r\n:target::before {\r\n  content: '';\r\n  display: block;\r\n  margin-top: -130px;\r\n  height: 130px;\r\n  width: 1px;\r\n}\r\n\r\nbody {\r\n  font-family: 'Open Sans', sans-serif;\r\n  color: $darkgray;\r\n\r\n  mark {\r\n    background: rgba(21, 155, 255, 0.25);\r\n  }\r\n\r\n  .toc {\r\n    background-color: transparent;\r\n  }\r\n}\r\n\r\n.row {\r\n  &:before {\r\n    content: none;\r\n  }\r\n\r\n  &:after {\r\n    content: '';\r\n  }\r\n}\r\n\r\na {\r\n  color: $blue;\r\n\r\n  &:hover,\r\n  &:active {\r\n    color: $darkgray;\r\n  }\r\n}\r\n\r\nh1 {\r\n  font-size: 40px;\r\n  @media only screen and (max-width: 767px) {\r\n    font-size: 32px;\r\n  }\r\n  font-weight: 600;\r\n  text-transform: none;\r\n}\r\n\r\nh2 {\r\n  font-size: 34px;\r\n  @media only screen and (max-width: 767px) {\r\n    font-size: 28px;\r\n  }\r\n  font-weight: 600;\r\n  text-transform: none;\r\n}\r\n\r\nh3 {\r\n  font-size: 28px;\r\n  @media only screen and (max-width: 767px) {\r\n    font-size: 22px;\r\n  }\r\n  font-weight: 600;\r\n  text-transform: none;\r\n}\r\n\r\n@media screen {\r\n  pre {\r\n    overflow: auto;\r\n\r\n    > code {\r\n      white-space: pre;\r\n    }\r\n  }\r\n}\r\n\r\n.container {\r\n  width:100%;\r\n}\r\n\r\n#breadcrumb {\r\n  padding: 0 32px;\r\n}\r\n\r\n.breadcrumb {\r\n  white-space: inherit;\r\n}\r\n\r\n.body-content .article {\r\n  margin-right: 0;\r\n}\r\n\r\n.sidefilter {\r\n  @media only screen and (min-width: 769px) {\r\n    width: 24%;\r\n  }\r\n  @media (min-width: 769px) and (max-width: 991px){\r\n    width: 30%;\r\n  }\r\n}\r\n\r\n.article.grid-right {\r\n  @media only screen and (min-width: 769px) {\r\n    margin-left: 26%;\r\n  }\r\n  @media (min-width: 769px) and (max-width: 991px){\r\n    margin-left: 32%;\r\n  }\r\n}\r\n\r\n.sidetoc {\r\n  top: 180px;\r\n  background-color: white !important;\r\n  @media only screen and (min-width: 769px) {\r\n    width: 24%;\r\n  }\r\n  @media (min-width: 769px) and (max-width: 991px){\r\n    width: 30%;  \r\n  }\r\n\r\n  .nav > li {\r\n    line-height: 1.79;\r\n\r\n    a {\r\n      color: $darkgray;\r\n    }\r\n  }\r\n\r\n  .nav > li.active > a {\r\n    color: $darkgray;\r\n    font-weight: bold;\r\n\r\n    &:hover {\r\n      color: #000;\r\n    }\r\n  }\r\n\r\n  .toc .nav > li.filtered > ul, .toc .nav > li.in > ul {\r\n    display: block;\r\n    @media only screen and (max-width: 768px) {\r\n      display: grid;\r\n    }\r\n  }\r\n\r\n  \r\n  .toc li:after {\r\n    @media only screen and (max-width: 768px) {\r\n      display: none;\r\n    }\r\n  }\r\n\r\n  .toc {\r\n    .nav > li > .expand-stub::before {\r\n      font-family: 'Glyphicons Halflings', 'ui-sans-serif';\r\n      content: '\\e258';\r\n      font-size: 0.8em;\r\n    }\r\n\r\n    .nav > li.in > .expand-stub::before {\r\n      font-family: 'Glyphicons Halflings', 'ui-sans-serif';\r\n      display: inline-block;\r\n      content: '\\e258';\r\n      font-size: 0.8em;\r\n      transform: rotate(90deg);\r\n    }\r\n\r\n    ul ul > li > a:before {\r\n      content: '';\r\n    }\r\n\r\n    ul {\r\n      padding-left: 5px;\r\n      text-align: left;\r\n      @media only screen and (max-width: 768px) {\r\n        text-align: left;\r\n      }\r\n\r\n      li a {\r\n        padding-left: 5px;\r\n      }\r\n    }\r\n\r\n    @media only screen and (max-width: 768px) {\r\n      margin-left: 0;\r\n\r\n      ul {\r\n        margin: 0;\r\n\r\n        li a {\r\n          margin: 0;\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n.sidenav {\r\n  @media only screen and (max-width: 767px) {\r\n    position: fixed;\r\n    width: 100%;\r\n    z-index: 999;\r\n  }\r\n}\r\n\r\n.front-page {\r\n  article section {\r\n    margin-left: auto;\r\n  }\r\n\r\n  p {\r\n    margin: 20px auto;\r\n  }\r\n\r\n  .subnav,\r\n  .sideaffix,\r\n  .footer {\r\n    display: none;\r\n  }\r\n\r\n\r\n  .body-content {\r\n    width: 100%;\r\n    padding: 0;\r\n    overflow: hidden;\r\n\r\n    .article {\r\n      margin: 0 !important;\r\n\r\n      & > [class*='col'] {\r\n        width: auto;\r\n        padding: 0;\r\n        float: none;\r\n      }\r\n    }\r\n  }\r\n\r\n  .button {\r\n    display: inline-block;\r\n\r\n    a {\r\n      display: inline-block;\r\n      padding: 7px 17px;\r\n      font-size: 20px;\r\n      font-weight: bold;\r\n      box-shadow: 0 2px 4px 0 rgba(31, 31, 31, 0.25);\r\n      border-radius: 8px;\r\n      transition: color 0.2s ease-in-out,\r\n      background-color 0.2s ease-in-out;\r\n    }\r\n\r\n    &.white a {\r\n      background: #fff;\r\n      color: $darkgray;\r\n\r\n      &:hover {\r\n        background: $purple;\r\n        color: #fff;\r\n      }\r\n    }\r\n\r\n    &.turquoise a {\r\n      background: $purple;\r\n      color: #fff;\r\n\r\n      &:hover {\r\n        background: darken($purple, 5);\r\n      }\r\n    }\r\n  }\r\n\r\n  .intro {\r\n    padding: 100px 15px 60px;\r\n    @media screen and (min-width: 768px) {\r\n      padding: 200px 15px 120px;\r\n    }\r\n    text-align: center;\r\n    font-size: 18px;\r\n    position: relative;\r\n\r\n    h1 {\r\n      font-size: 36px;\r\n      @media screen and (min-width: 768px) {\r\n        font-size: 44px;\r\n      }\r\n\r\n      text-transform: none;\r\n      font-weight: 600;\r\n      width: auto;\r\n      max-width: 100%;\r\n      margin: 0 auto;\r\n      letter-spacing: normal;\r\n    }\r\n\r\n    p {\r\n      width: 100%;\r\n      font-size: 22px;\r\n    }\r\n\r\n    strong {\r\n      font-weight: bold;\r\n    }\r\n\r\n    .button a {\r\n      margin-top: 20px;\r\n    }\r\n  }\r\n\r\n  .headerboxes {\r\n    display: flex;\r\n    flex-wrap: wrap;\r\n    padding: 40px 15px;\r\n    @media screen and (min-width: 768px) {\r\n      padding: 80px 15px;\r\n    }\r\n\r\n    background-color: #f4f2f3;\r\n\r\n    .headerbox {\r\n      margin: 40px auto;\r\n\r\n    }\r\n\r\n    .headerbox-inner {\r\n      padding: 0;\r\n      height: 100%;\r\n    }\r\n\r\n    h2 {\r\n      font-size: 30px;\r\n      font-weight: 600;\r\n      text-transform: none;\r\n\r\n      .anchorjs-link {\r\n        display: none;\r\n      }\r\n    }\r\n\r\n    p {\r\n      font-size: 16px;\r\n      font-weight: 600;\r\n    }\r\n\r\n    .icon {\r\n      margin: 0;\r\n    }\r\n  }\r\n}\r\n","$blue: #159bff;\r\n$purple: #7a67f8;\r\n$turquoise: #67e5ad;\r\n$darkgray: #242424;\r\n$lightgray: #c4c4c4;\r\n$white: #fff;\r\n$black: #242424;\r\n",null,"@import \"../variables\";\r\n\r\n.sideaffix {\r\n  overflow: auto;\r\n\r\n  .affix ul > li.active > ul, .affix ul > li.active > a:before, .affix ul > li > a:hover:before {\r\n    white-space: normal;\r\n  }\r\n\r\n  .contribution-link {\r\n    font-size: 16px !important;\r\n  }\r\n\r\n  #affix {\r\n    font-size: 16px;\r\n    font-weight: 600;\r\n    line-height: 1.5;\r\n    height: auto;\r\n    a {\r\n      color: $darkgray;\r\n    }\r\n\r\n    ul > li.active > a {\r\n      font-weight: bold;\r\n      &:before {\r\n        color: $darkgray;\r\n      }\r\n      ul > li.active > a {\r\n        font-weight: bold;\r\n        &:before {\r\n          color: $darkgray;\r\n        }\r\n      }\r\n    }\r\n\r\n    ul ul > li > a:before {\r\n      top: 2px;\r\n    }\r\n    li:last-child {\r\n      padding-bottom: 16px;\r\n      margin-bottom: 0;\r\n    }\r\n\r\n    .title {\r\n      text-transform: none;\r\n      font-size: 20px;\r\n    }\r\n\r\n    .level1::before {\r\n      width: 75%;\r\n      border-top: 1px solid $lightgray;\r\n    }\r\n\r\n    .level1::after {\r\n      width: 75%;\r\n      border-top: 1px solid $lightgray;\r\n    }\r\n  }\r\n}\r\n\r\n","@import '../variables';\r\n\r\n.alert {\r\n  background-color: transparent;\r\n  border-color: $lightgray;\r\n  color: $darkgray;\r\n  padding: 16px 16px;\r\n  transition: transform .2s;\r\n}\r\n\r\n.alert-hover {\r\n  &:hover {\r\n    transform: scale(1.05);\r\n    border-color: $blue;\r\n    box-shadow: 0 5px 10px 0 rgba(0, 0, 0, 0.2);\r\n    h4{\r\n      color: $blue;\r\n    }\r\n  }\r\n}\r\n",null,"@import \"../variables\";\r\n@import \"breakpoints\";\r\n\r\n/**\r\n * General notes:\r\n * This file is modifying the elementor menu as simply as it can. The selector are a bit hard to\r\n * understand because we cannot add class or ids on the menu.\r\n *\r\n * This is a modified version of the css in the header.scss file from the main website.\r\n * It was modified as little as possible, but they are quite different.\r\n *\r\n * Pixel are preferred as unit since the body font size is not the same as the website.\r\n * This causes relative units (em, rem) to behave differently.\r\n */\r\n\r\n.visibility-opacity-transition {\r\n  @include media-breakpoint-up(lg) {\r\n    visibility: hidden;\r\n\r\n    list-style: none;\r\n\r\n    transition: visibility 100ms, opacity 100ms ease-in-out;\r\n    opacity: 0;\r\n  }\r\n}\r\n\r\n#header-container {\r\n  display: flex;\r\n  position: fixed;\r\n  background: #fff;\r\n\r\n  width: 100%;\r\n  min-height: 75px;\r\n\r\n  padding: 16px 32px;\r\n  border-bottom: 1px solid #f4f2f3;\r\n\r\n  justify-content: space-between;\r\n\r\n  z-index: 9999;\r\n\r\n  &::after,\r\n  &::before {\r\n    content: none;\r\n  }\r\n\r\n  #menu-menu-principal {\r\n    float: right;\r\n\r\n    list-style: none;\r\n\r\n    @include media-breakpoint-down(lg) {\r\n      width: 100%;\r\n    }\r\n\r\n    @include media-breakpoint-up(lg) {\r\n      display: flex;\r\n    }\r\n  }\r\n\r\n\r\n  #header-logo-container {\r\n    width: 36px;\r\n    vertical-align: middle;\r\n\r\n    img {\r\n      width: 100%;\r\n    }\r\n\r\n    @include media-breakpoint-up(lg) {\r\n      width: 120px;\r\n    }\r\n  }\r\n\r\n  .navbar-toggle {\r\n    padding: 0;\r\n    margin: 10px 0;\r\n    display: none !important;\r\n\r\n    .icon-bar {\r\n      background: $darkgray;\r\n      width: 20px;\r\n    }\r\n\r\n    .icon-bar + .icon-bar {\r\n      margin-top: 3px;\r\n    }\r\n\r\n    @media (max-width: 979px) {\r\n      display: block !important;\r\n    }\r\n  }\r\n\r\n  .navbar-brand {\r\n    height: auto;\r\n  }\r\n\r\n  nav {\r\n    a {\r\n      padding: 10px;\r\n\r\n      font-size: 16px;\r\n      font-weight: 600;\r\n      font-stretch: normal;\r\n      font-style: normal;\r\n      line-height: 16px;\r\n      letter-spacing: normal;\r\n      text-transform: uppercase;\r\n      color: $black;\r\n\r\n      &:hover,\r\n      &:focus {\r\n        border-radius: 4px;\r\n        background-color: transparentize($turquoise, 0.8);\r\n      }\r\n    }\r\n\r\n    /**\r\n     * Top level menu items\r\n     */\r\n    & > ul > li {\r\n      margin: 0 16px;\r\n      align-self: center;\r\n\r\n      /**\r\n       * has-children means there is a submenu\r\n       */\r\n      &.has-children {\r\n        // actual submenu\r\n        position: relative;\r\n\r\n        & > ul {\r\n          @extend .visibility-opacity-transition;\r\n          width: inherit;\r\n\r\n          @include media-breakpoint-up(lg) {\r\n            display: flex;\r\n            position: absolute;\r\n            padding: 24px 48px;\r\n            top: 170% !important;\r\n            left: -100% !important;\r\n\r\n            flex-direction: column;\r\n\r\n            border-radius: 4px;\r\n            box-shadow: 0 0 20px 2px rgba(36, 36, 36, 0.2);\r\n            background-color: $white;\r\n          }\r\n\r\n          li {\r\n            display: flex;\r\n          }\r\n\r\n          a {\r\n            font-size: 14px;\r\n            font-weight: 400;\r\n            line-height: 20px;\r\n            text-transform: none;\r\n\r\n            transition: 0s;\r\n          }\r\n\r\n          .column-title {\r\n            flex-direction: column;\r\n\r\n            & > a {\r\n              cursor: default;\r\n\r\n              font-weight: 700;\r\n              line-height: normal !important;\r\n              color: $black;\r\n\r\n              &:hover,\r\n              &:focus {\r\n                background-color: transparent;\r\n              }\r\n            }\r\n\r\n            ul {\r\n              width: 192px;\r\n              padding: 0;\r\n            }\r\n          }\r\n\r\n          // sub-menu columns\r\n          ul {\r\n            @extend .visibility-opacity-transition;\r\n            display: flex;\r\n            position: inherit;\r\n\r\n            flex-direction: column;\r\n\r\n            a {\r\n              border-left: 0;\r\n            }\r\n          }\r\n        }\r\n\r\n        // shows the submenu\r\n        &:hover > ul {\r\n          visibility: visible;\r\n          opacity: 1;\r\n\r\n          /**\r\n           * This selector makes sure the submenu of a submenu appears under it\r\n           * instead of on hover. This is to displays submenus as columns.\r\n           */\r\n          &:not([style*=\"display: none;\"]) {\r\n            .has-children {\r\n              ul {\r\n                visibility: visible;\r\n                opacity: 1;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      /**\r\n       * row-menu : the row menu class puts the first element of the menu in a row\r\n       *            instead of a column (default). This makes it possible to have\r\n       *            multiple columns side by side by add the row-menu class in wordpress.\r\n       */\r\n      &.row-menu > ul {\r\n        flex-direction: row;\r\n      }\r\n\r\n    }\r\n  }\r\n\r\n  .get-started-btn {\r\n    a {\r\n      display: block;\r\n      border: none;\r\n      border-radius: 8px;\r\n\r\n      margin-left: 0;\r\n      padding: 8px 32px;\r\n\r\n      font-size: 16px;\r\n      font-weight: 700;\r\n      min-width: 125px;\r\n      text-align: center;\r\n      text-transform: none;\r\n      color: $black;\r\n\r\n      background-color: $turquoise;\r\n      background: linear-gradient(to top, $blue 50%, $turquoise 50%);\r\n      background-size: 100% 200%;\r\n      background-position:left top;\r\n      transition:all 0.5s cubic-bezier(.69,.04,.9,.65);\r\n\r\n      &:hover {\r\n        color: $white;\r\n        background-position:bottom left;\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n#navbar {\r\n  @media (max-width: 979px) {\r\n\r\n    overflow: auto !important;\r\n    \r\n    position: fixed;\r\n    width: 100%;\r\n    margin: 0;\r\n    padding: 0;\r\n\r\n    top: 75px;\r\n    left: 0;\r\n\r\n    text-align: left;\r\n\r\n    background: #fff;\r\n\r\n    &.collapse {\r\n      display: none!important;\r\n    }\r\n    &.collapse.in {\r\n      display: block!important;\r\n    }\r\n\r\n    .menu {\r\n      display: block;\r\n      margin: 0;\r\n      padding: 0 0 10px 0;\r\n\r\n      li {\r\n        display: block;\r\n        padding: 0;\r\n\r\n        &.has-children {\r\n          position: relative;\r\n\r\n          ul {\r\n            position: relative;\r\n            max-height: 0;\r\n            padding: 0;\r\n\r\n            overflow: hidden;\r\n            transition: all .5s ease;\r\n          }\r\n\r\n          &.open {\r\n            ul {\r\n              max-height: 1500px;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      a {\r\n        display: block;\r\n        padding: 10px 25px;\r\n\r\n        line-height: 1.4;\r\n        font-weight: 700;\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n.subnav {\r\n  position: fixed;\r\n  top: 75px;\r\n  width: 100%;\r\n  z-index: 999;\r\n  background-color: #f8f8f8;\r\n}\r\n","/**\r\n * General notes:\r\n * This file is modifying the elementor menu as simply as it can. The selector are a bit hard to\r\n * understand because we cannot add class or ids on the menu.\r\n *\r\n * This is a modified version of the css in the header.scss file from the main website.\r\n * It was modified as little as possible, but they are quite different.\r\n *\r\n * Pixel are preferred as unit since the body font size is not the same as the website.\r\n * This causes relative units (em, rem) to behave differently.\r\n */\n@media (min-width: 980px) {\n  .visibility-opacity-transition, #header-container nav > ul > li.has-children > ul, #header-container nav > ul > li.has-children > ul ul {\n    visibility: hidden;\n    list-style: none;\n    transition: visibility 100ms, opacity 100ms ease-in-out;\n    opacity: 0; } }\n\n#header-container {\n  display: flex;\n  position: fixed;\n  background: #fff;\n  width: 100%;\n  min-height: 75px;\n  padding: 16px 32px;\n  border-bottom: 1px solid #f4f2f3;\n  justify-content: space-between;\n  z-index: 9999; }\n  #header-container::after, #header-container::before {\n    content: none; }\n  #header-container #menu-menu-principal {\n    float: right;\n    list-style: none; }\n    @media (max-width: 1023.98px) {\n      #header-container #menu-menu-principal {\n        width: 100%; } }\n    @media (min-width: 980px) {\n      #header-container #menu-menu-principal {\n        display: flex; } }\n  #header-container #header-logo-container {\n    width: 36px;\n    vertical-align: middle; }\n    #header-container #header-logo-container img {\n      width: 100%; }\n    @media (min-width: 980px) {\n      #header-container #header-logo-container {\n        width: 120px; } }\n  #header-container .navbar-toggle {\n    padding: 0;\n    margin: 10px 0;\n    display: none !important; }\n    #header-container .navbar-toggle .icon-bar {\n      background: #242424;\n      width: 20px; }\n    #header-container .navbar-toggle .icon-bar + .icon-bar {\n      margin-top: 3px; }\n    @media (max-width: 979px) {\n      #header-container .navbar-toggle {\n        display: block !important; } }\n  #header-container .navbar-brand {\n    height: auto; }\n  #header-container nav {\n    /**\r\n     * Top level menu items\r\n     */ }\n    #header-container nav a {\n      padding: 10px;\n      font-size: 16px;\n      font-weight: 600;\n      font-stretch: normal;\n      font-style: normal;\n      line-height: 16px;\n      letter-spacing: normal;\n      text-transform: uppercase;\n      color: #242424; }\n      #header-container nav a:hover, #header-container nav a:focus {\n        border-radius: 4px;\n        background-color: rgba(103, 229, 173, 0.2); }\n    #header-container nav > ul > li {\n      margin: 0 16px;\n      align-self: center;\n      /**\r\n       * has-children means there is a submenu\r\n       */\n      /**\r\n       * row-menu : the row menu class puts the first element of the menu in a row\r\n       *            instead of a column (default). This makes it possible to have\r\n       *            multiple columns side by side by add the row-menu class in wordpress.\r\n       */ }\n      #header-container nav > ul > li.has-children {\n        position: relative; }\n        #header-container nav > ul > li.has-children > ul {\n          width: inherit; }\n          @media (min-width: 980px) {\n            #header-container nav > ul > li.has-children > ul {\n              display: flex;\n              position: absolute;\n              padding: 24px 48px;\n              top: 170% !important;\n              left: -100% !important;\n              flex-direction: column;\n              border-radius: 4px;\n              box-shadow: 0 0 20px 2px rgba(36, 36, 36, 0.2);\n              background-color: #fff; } }\n          #header-container nav > ul > li.has-children > ul li {\n            display: flex; }\n          #header-container nav > ul > li.has-children > ul a {\n            font-size: 14px;\n            font-weight: 400;\n            line-height: 20px;\n            text-transform: none;\n            transition: 0s; }\n          #header-container nav > ul > li.has-children > ul .column-title {\n            flex-direction: column; }\n            #header-container nav > ul > li.has-children > ul .column-title > a {\n              cursor: default;\n              font-weight: 700;\n              line-height: normal !important;\n              color: #242424; }\n              #header-container nav > ul > li.has-children > ul .column-title > a:hover, #header-container nav > ul > li.has-children > ul .column-title > a:focus {\n                background-color: transparent; }\n            #header-container nav > ul > li.has-children > ul .column-title ul {\n              width: 192px;\n              padding: 0; }\n          #header-container nav > ul > li.has-children > ul ul {\n            display: flex;\n            position: inherit;\n            flex-direction: column; }\n            #header-container nav > ul > li.has-children > ul ul a {\n              border-left: 0; }\n        #header-container nav > ul > li.has-children:hover > ul {\n          visibility: visible;\n          opacity: 1;\n          /**\r\n           * This selector makes sure the submenu of a submenu appears under it\r\n           * instead of on hover. This is to displays submenus as columns.\r\n           */ }\n          #header-container nav > ul > li.has-children:hover > ul:not([style*=\"display: none;\"]) .has-children ul {\n            visibility: visible;\n            opacity: 1; }\n      #header-container nav > ul > li.row-menu > ul {\n        flex-direction: row; }\n  #header-container .get-started-btn a {\n    display: block;\n    border: none;\n    border-radius: 8px;\n    margin-left: 0;\n    padding: 8px 32px;\n    font-size: 16px;\n    font-weight: 700;\n    min-width: 125px;\n    text-align: center;\n    text-transform: none;\n    color: #242424;\n    background-color: #67e5ad;\n    background: linear-gradient(to top, #159bff 50%, #67e5ad 50%);\n    background-size: 100% 200%;\n    background-position: left top;\n    transition: all 0.5s cubic-bezier(0.69, 0.04, 0.9, 0.65); }\n    #header-container .get-started-btn a:hover {\n      color: #fff;\n      background-position: bottom left; }\n\n@media (max-width: 979px) {\n  #navbar {\n    overflow: auto !important;\n    position: fixed;\n    width: 100%;\n    margin: 0;\n    padding: 0;\n    top: 75px;\n    left: 0;\n    text-align: left;\n    background: #fff; }\n    #navbar.collapse {\n      display: none !important; }\n    #navbar.collapse.in {\n      display: block !important; }\n    #navbar .menu {\n      display: block;\n      margin: 0;\n      padding: 0 0 10px 0; }\n      #navbar .menu li {\n        display: block;\n        padding: 0; }\n        #navbar .menu li.has-children {\n          position: relative; }\n          #navbar .menu li.has-children ul {\n            position: relative;\n            max-height: 0;\n            padding: 0;\n            overflow: hidden;\n            transition: all .5s ease; }\n          #navbar .menu li.has-children.open ul {\n            max-height: 1500px; }\n      #navbar .menu a {\n        display: block;\n        padding: 10px 25px;\n        line-height: 1.4;\n        font-weight: 700; } }\n\n.subnav {\n  position: fixed;\n  top: 75px;\n  width: 100%;\n  z-index: 999;\n  background-color: #f8f8f8; }\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n// Grid breakpoints\r\n//\r\n// There are two breakpoints that fit with the new elementor plugin.\r\n//\r\n//  (mobile: 767px, tablet: 1024 px)\r\n//\r\n// Define the minimum dimensions at which your layout will change,\r\n// adapting to different screen sizes, for use in media queries.\r\n\r\n$grid-breakpoints: (xs: 0,\r\n        sm: 576px,\r\n        mobile: 767px,\r\n        md: 768px,\r\n        lg: 980px,\r\n        tablet: 1024px,\r\n        xl: 1200px) !default;\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n !=null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min !=0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  }\r\n\r\n  @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  }\r\n\r\n  @else {\r\n    @content;\r\n  }\r\n}\r\n","@import \"../variables\";\r\n\r\n:root {\r\n  --docsearch-primary-color: #{$blue} !important;\r\n  --docsearch-logo-color: #{$blue} !important;\r\n}\r\n\r\n.sidefilter {\r\n\r\n  background-color: transparent;\r\n  height: 60px;\r\n  padding: 10px;\r\n\r\n  .DocSearch-Button {\r\n    background: transparent;\r\n    border: 2px inset $darkgray;\r\n    border-radius: 6px;\r\n    margin: 0;\r\n    min-height: 45px;\r\n    padding: 10px;\r\n    width: 100%;\r\n  }\r\n\r\n  .DocSearch-Button:active, .DocSearch-Button:focus, .DocSearch-Button:hover {\r\n    border: 2px solid $blue;\r\n    box-shadow: none;\r\n  }\r\n\r\n  .DocSearch-Button .DocSearch-Search-Icon {\r\n    display: none;\r\n  }\r\n\r\n  .DocSearch-Button-Placeholder {\r\n    color: rgb(117, 117, 117);\r\n    font-family: \"Open Sans\", sans-serif;\r\n    font-size: 14px;\r\n    line-height: 20px;\r\n    padding: 10px;\r\n    display: block;\r\n  }\r\n}\r\n\r\n.DocSearch.DocSearch-Container {\r\n  z-index: 9999;\r\n}\r\n"]} */
diff --git a/doc/templates/uno/styles/main.js b/doc/templates/uno/styles/main.js
index eed7ba9f5a56779e1260b22f4faddee429fc457d..61b81040e7c3eb62b1052b52803ac7de33a4b2d1 100644
--- a/doc/templates/uno/styles/main.js
+++ b/doc/templates/uno/styles/main.js
@@ -1 +1,26 @@
-document.addEventListener("DOMContentLoaded",function(){initializeNavbar(),document.addEventListener("click",function(e){var n=e.target;980<=window.innerWidth||!n.matches("#navbar .has-children a")||(e.stopImmediatePropagation(),n.parentElement.classList.toggle("open"))},!0)},!1);
\ No newline at end of file
+// Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+document.addEventListener(
+ "DOMContentLoaded",
+ function () {
+
+ initializeNavbar();
+
+ document.addEventListener(
+ "click",
+ function (e) {
+ const t = e.target;
+ if (
+ window.innerWidth >= 980 ||
+ !t.matches("#navbar .has-children a")
+ )
+ return;
+ e.stopImmediatePropagation();
+ t.parentElement.classList.toggle("open");
+ },
+ true
+ );
+ },
+ false
+);
+
diff --git a/doc/templates/uno/toc.html.tmpl b/doc/templates/uno/toc.html.tmpl
index 687edd8d3ddea1827eabb65b7234cf222ef7a619..e77107e362b89f1472d2413e775844d389bb2930 100644
--- a/doc/templates/uno/toc.html.tmpl
+++ b/doc/templates/uno/toc.html.tmpl
@@ -3,18 +3,12 @@
{{^leaf}}
- {{>partials/li}}
+ {{>partials/li}}
{{/leaf}}