',
+ options: { disabled: !1, create: null },
+ _createWidget: function (n, r) {
+ (r = e(r || this.defaultElement || this)[0]),
+ (this.element = e(r)),
+ (this.uuid = t++),
+ (this.eventNamespace = `.${this.widgetName}${this.uuid}`),
+ (this.bindings = e()),
+ (this.hoverable = e()),
+ (this.focusable = e()),
+ r !== this &&
+ (e.data(r, this.widgetFullName, this),
+ this._on(!0, this.element, {
+ remove: function (e) {
+ e.target === r && this.destroy();
+ },
+ }),
+ (this.document = e(r.style ? r.ownerDocument : r.document || r)),
+ (this.window = e(
+ this.document[0].defaultView || this.document[0].parentWindow,
+ ))),
+ (this.options = e.widget.extend(
+ {},
+ this.options,
+ this._getCreateOptions(),
+ n,
+ )),
+ this._create(),
+ this._trigger('create', null, this._getCreateEventData()),
+ this._init();
+ },
+ _getCreateOptions: e.noop,
+ _getCreateEventData: e.noop,
+ _create: e.noop,
+ _init: e.noop,
+ destroy: function () {
+ this._destroy(),
+ this.element
+ .unbind(this.eventNamespace)
+ .removeData(this.widgetFullName)
+ .removeData(e.camelCase(this.widgetFullName)),
+ this.widget()
+ .unbind(this.eventNamespace)
+ .removeAttr('aria-disabled')
+ .removeClass(`${this.widgetFullName}-disabled ui-state-disabled`),
+ this.bindings.unbind(this.eventNamespace),
+ this.hoverable.removeClass('ui-state-hover'),
+ this.focusable.removeClass('ui-state-focus');
+ },
+ _destroy: e.noop,
+ widget: function () {
+ return this.element;
+ },
+ option: function (t, n) {
+ let r;
+ let i;
+ let o;
+ let s = t;
+ if (arguments.length === 0) return e.widget.extend({}, this.options);
+ if (typeof t === 'string')
+ if (((s = {}), (r = t.split('.')), (t = r.shift()), r.length)) {
+ for (
+ i = s[t] = e.widget.extend({}, this.options[t]), o = 0;
+ o < r.length - 1;
+ o++
+ )
+ (i[r[o]] = i[r[o]] || {}), (i = i[r[o]]);
+ if (((t = r.pop()), arguments.length === 1))
+ return void 0 === i[t] ? null : i[t];
+ i[t] = n;
+ } else {
+ if (arguments.length === 1)
+ return void 0 === this.options[t] ? null : this.options[t];
+ s[t] = n;
+ }
+ return this._setOptions(s), this;
+ },
+ _setOptions: function (e) {
+ let t;
+ for (t in e) this._setOption(t, e[t]);
+ return this;
+ },
+ _setOption: function (e, t) {
+ return (
+ (this.options[e] = t),
+ e === 'disabled' &&
+ (this.widget().toggleClass(
+ `${this.widgetFullName}-disabled`,
+ !!t,
+ ),
+ t &&
+ (this.hoverable.removeClass('ui-state-hover'),
+ this.focusable.removeClass('ui-state-focus'))),
+ this
+ );
+ },
+ enable: function () {
+ return this._setOptions({ disabled: !1 });
+ },
+ disable: function () {
+ return this._setOptions({ disabled: !0 });
+ },
+ _on: function (t, n, r) {
+ let i;
+ const o = this;
+ typeof t !== 'boolean' && ((r = n), (n = t), (t = !1)),
+ r
+ ? ((n = i = e(n)), (this.bindings = this.bindings.add(n)))
+ : ((r = n), (n = this.element), (i = this.widget())),
+ e.each(r, (r, s) => {
+ function a() {
+ return t ||
+ (o.options.disabled !== !0 &&
+ !e(this).hasClass('ui-state-disabled'))
+ ? (typeof s === 'string' ? o[s] : s).apply(o, arguments)
+ : void 0;
+ }
+ typeof s !== 'string' &&
+ (a.guid = s.guid = s.guid || a.guid || e.guid++);
+ const c = r.match(/^([\w:-]*)\s*(.*)$/);
+ const l = c[1] + o.eventNamespace;
+ const u = c[2];
+ u ? i.delegate(u, l, a) : n.bind(l, a);
+ });
+ },
+ _off: function (t, n) {
+ (n =
+ (n || '').split(' ').join(`${this.eventNamespace} `) +
+ this.eventNamespace),
+ t.unbind(n).undelegate(n),
+ (this.bindings = e(this.bindings.not(t).get())),
+ (this.focusable = e(this.focusable.not(t).get())),
+ (this.hoverable = e(this.hoverable.not(t).get()));
+ },
+ _delay: function (e, t) {
+ function n() {
+ return (typeof e === 'string' ? r[e] : e).apply(r, arguments);
+ }
+ var r = this;
+ return setTimeout(n, t || 0);
+ },
+ _hoverable: function (t) {
+ (this.hoverable = this.hoverable.add(t)),
+ this._on(t, {
+ mouseenter: function (t) {
+ e(t.currentTarget).addClass('ui-state-hover');
+ },
+ mouseleave: function (t) {
+ e(t.currentTarget).removeClass('ui-state-hover');
+ },
+ });
+ },
+ _focusable: function (t) {
+ (this.focusable = this.focusable.add(t)),
+ this._on(t, {
+ focusin: function (t) {
+ e(t.currentTarget).addClass('ui-state-focus');
+ },
+ focusout: function (t) {
+ e(t.currentTarget).removeClass('ui-state-focus');
+ },
+ });
+ },
+ _trigger: function (t, n, r) {
+ let i;
+ let o;
+ const s = this.options[t];
+ if (
+ ((r = r || {}),
+ (n = e.Event(n)),
+ (n.type = (
+ t === this.widgetEventPrefix ? t : this.widgetEventPrefix + t
+ ).toLowerCase()),
+ (n.target = this.element[0]),
+ (o = n.originalEvent))
+ )
+ for (i in o) i in n || (n[i] = o[i]);
+ return (
+ this.element.trigger(n, r),
+ !(
+ (e.isFunction(s) &&
+ s.apply(this.element[0], [n].concat(r)) === !1) ||
+ n.isDefaultPrevented()
+ )
+ );
+ },
+ }),
+ e.each({ show: 'fadeIn', hide: 'fadeOut' }, (t, n) => {
+ e.Widget.prototype[`_${t}`] = function (r, i, o) {
+ typeof i === 'string' && (i = { effect: i });
+ let s;
+ const a = i
+ ? i === !0 || typeof i === 'number'
+ ? n
+ : i.effect || n
+ : t;
+ (i = i || {}),
+ typeof i === 'number' && (i = { duration: i }),
+ (s = !e.isEmptyObject(i)),
+ (i.complete = o),
+ i.delay && r.delay(i.delay),
+ s && e.effects && e.effects.effect[a]
+ ? r[t](i)
+ : a !== t && r[a]
+ ? r[a](i.duration, i.easing, o)
+ : r.queue(function (n) {
+ e(this)[t](), o && o.call(r[0]), n();
+ });
+ };
+ });
+ e.widget;
+ }),
+ (function (e) {
+ 'use strict';
+
+ e(window.jQuery, window, document);
+ })((e, t, n, r) => {
+ 'use strict';
+
+ const i = 'tocify';
+ const o = 'tocify-focus';
+ const s = 'tocify-hover';
+ const a = 'tocify-hide';
+ const c = 'tocify-header';
+ const l = `.${c}`;
+ const u = 'tocify-subheader';
+ const d = `.${u}`;
+ const f = 'tocify-item';
+ const p = `.${f}`;
+ const h = 'tocify-extend-page';
+ const g = `.${h}`;
+ e.widget('toc.tocify', {
+ version: '1.8.0',
+ options: {
+ context: 'body',
+ ignoreSelector: null,
+ selectors: 'h1, h2, h3',
+ showAndHide: !0,
+ showEffect: 'slideDown',
+ showEffectSpeed: 'medium',
+ hideEffect: 'slideUp',
+ hideEffectSpeed: 'medium',
+ smoothScroll: !0,
+ smoothScrollSpeed: 'medium',
+ scrollTo: 0,
+ showAndHideOnScroll: !0,
+ highlightOnScroll: !0,
+ highlightOffset: 40,
+ theme: 'bootstrap',
+ extendPage: !0,
+ extendPageOffset: 100,
+ history: !0,
+ scrollHistory: !1,
+ hashGenerator: 'compact',
+ highlightDefault: !0,
+ },
+ _create: function () {
+ const n = this;
+ (n.tocifyWrapper = e('.tocify-wrapper')),
+ (n.extendPageScroll = !0),
+ (n.items = []),
+ n._generateToc(),
+ (n.cachedHeights = []),
+ (n.cachedAnchors = []),
+ n._addCSSClasses(),
+ (n.webkit = (function () {
+ for (const e in t)
+ if (e && e.toLowerCase().indexOf('webkit') !== -1) return !0;
+ return !1;
+ })()),
+ n._setEventHandlers(),
+ e(t).load(() => {
+ n._setActiveElement(!0),
+ e('html, body')
+ .promise()
+ .done(() => {
+ setTimeout(() => {
+ n.extendPageScroll = !1;
+ }, 0);
+ });
+ });
+ },
+ _generateToc: function () {
+ let t;
+ let n;
+ const r = this;
+ const o = r.options.ignoreSelector;
+ return (
+ (t =
+ this.options.selectors.indexOf(',') !== -1
+ ? e(this.options.context).find(
+ this.options.selectors
+ .replace(/ /g, '')
+ .substr(0, this.options.selectors.indexOf(',')),
+ )
+ : e(this.options.context).find(
+ this.options.selectors.replace(/ /g, ''),
+ )),
+ t.length
+ ? (r.element.addClass(i),
+ void t.each(function (t) {
+ e(this).is(o) ||
+ ((n = e('
', { id: c + t, class: c }).append(
+ r._nestElements(e(this), t),
+ )),
+ r.element.append(n),
+ e(this)
+ .nextUntil(this.nodeName.toLowerCase())
+ .each(function () {
+ e(this).find(r.options.selectors).length === 0
+ ? e(this)
+ .filter(r.options.selectors)
+ .each(function () {
+ e(this).is(o) ||
+ r._appendSubheaders.call(this, r, n);
+ })
+ : e(this)
+ .find(r.options.selectors)
+ .each(function () {
+ e(this).is(o) ||
+ r._appendSubheaders.call(this, r, n);
+ });
+ }));
+ }))
+ : void r.element.addClass(a)
+ );
+ },
+ _setActiveElement: function (e) {
+ const n = this;
+ const r = t.location.hash.substring(1);
+ const i = n.element.find(`li[data-unique='${r}']`);
+ return (
+ r.length
+ ? (n.element.find(`.${n.focusClass}`).removeClass(n.focusClass),
+ i.addClass(n.focusClass),
+ n.options.showAndHide && i.click())
+ : (n.element.find(`.${n.focusClass}`).removeClass(n.focusClass),
+ !r.length &&
+ e &&
+ n.options.highlightDefault &&
+ n.element.find(p).first().addClass(n.focusClass)),
+ n
+ );
+ },
+ _nestElements: function (t, n) {
+ let r;
+ let i;
+ let o;
+ return (
+ (r = e.grep(this.items, (e) => e === t.text())),
+ r.length ? this.items.push(t.text() + n) : this.items.push(t.text()),
+ (o = this._generateHashValue(r, t, n)),
+ (i = e('
', { class: f, 'data-unique': o }).append(
+ e('
', { text: t.text() }),
+ )),
+ t.before(e('
', { name: o, 'data-unique': o })),
+ i
+ );
+ },
+ _generateHashValue: function (e, t, n) {
+ let r = '';
+ const i = this.options.hashGenerator;
+ if (i === 'pretty') {
+ for (
+ r = t.text().toLowerCase().replace(/\s/g, '-'),
+ r = r.replace(/[^\x00-\x7F]/g, '');
+ r.indexOf('--') > -1;
+
+ )
+ r = r.replace(/--/g, '-');
+ for (; r.indexOf(':-') > -1; ) r = r.replace(/:-/g, '-');
+ } else
+ r =
+ typeof i === 'function'
+ ? i(t.text(), t)
+ : t.text().replace(/\s/g, '');
+ return e.length && (r += `${n}`), r;
+ },
+ _appendSubheaders: function (t, n) {
+ const r = e(this).index(t.options.selectors);
+ const i = e(t.options.selectors).eq(r - 1);
+ const o = +e(this).prop('tagName').charAt(1);
+ const s = +i.prop('tagName').charAt(1);
+ s > o
+ ? t.element
+ .find(`${d}[data-tag=${o}]`)
+ .last()
+ .append(t._nestElements(e(this), r))
+ : o === s
+ ? n
+ .find(p)
+ .last()
+ .after(t._nestElements(e(this), r))
+ : n
+ .find(p)
+ .last()
+ .after(e('
', { class: u, 'data-tag': o }))
+ .next(d)
+ .append(t._nestElements(e(this), r));
+ },
+ _setEventHandlers: function () {
+ const i = this;
+ this.element.on('click.tocify', 'li', function (n) {
+ if (
+ (i.options.history &&
+ (t.location.hash = e(this).attr('data-unique')),
+ i.element.find(`.${i.focusClass}`).removeClass(i.focusClass),
+ e(this).addClass(i.focusClass),
+ i.options.showAndHide)
+ ) {
+ const r = e(`li[data-unique="${e(this).attr('data-unique')}"]`);
+ i._triggerShow(r);
+ }
+ i._scrollTo(e(this));
+ }),
+ this.element.find('li').on({
+ 'mouseenter.tocify': function () {
+ e(this).addClass(i.hoverClass), e(this).css('cursor', 'pointer');
+ },
+ 'mouseleave.tocify': function () {
+ i.options.theme !== 'bootstrap' &&
+ e(this).removeClass(i.hoverClass);
+ },
+ }),
+ e(t).on('resize', () => {
+ i.calculateHeights();
+ }),
+ e(t).on('scroll.tocify', () => {
+ e('html, body')
+ .promise()
+ .done(() => {
+ let o;
+ let s;
+ let a;
+ let c;
+ const l = e(t).scrollTop();
+ const u = e(t).height();
+ const d = e(n).height();
+ const f = e('body')[0].scrollHeight;
+ if (
+ i.options.extendPage &&
+ ((i.webkit && l >= f - u - i.options.extendPageOffset) ||
+ (!i.webkit && u + l > d - i.options.extendPageOffset)) &&
+ !e(g).length
+ ) {
+ if (
+ ((s = e(
+ `div[data-unique="${e(p).last().attr('data-unique')}"]`,
+ )),
+ !s.length)
+ )
+ return;
+ (a = s.offset().top),
+ e(i.options.context).append(
+ e('
', {
+ class: h,
+ height: `${Math.abs(a - l)}px`,
+ 'data-unique': h,
+ }),
+ ),
+ i.extendPageScroll &&
+ ((c = i.element.find('li.active')),
+ i._scrollTo(
+ e(`div[data-unique=${c.attr('data-unique')}]`),
+ ));
+ }
+ setTimeout(() => {
+ let s;
+ let a = null;
+ i.cachedHeights.length == 0 && i.calculateHeights();
+ const c = e(t).scrollTop();
+ if (
+ (i.cachedAnchors.each((e) =>
+ i.cachedHeights[e] - c < 0 ? void (a = e) : !1,
+ ),
+ (s = e(i.cachedAnchors[a]).attr('data-unique')),
+ (o = e(`li[data-unique="${s}"]`)),
+ i.options.highlightOnScroll &&
+ o.length &&
+ !o.hasClass(i.focusClass))
+ ) {
+ i.element
+ .find(`.${i.focusClass}`)
+ .removeClass(i.focusClass),
+ o.addClass(i.focusClass);
+ const l = i.tocifyWrapper;
+ const u = e(o).closest('.tocify-header');
+ const d = u.offset().top;
+ const f = l.offset().top;
+ const p = d - f;
+ if (p >= e(t).height()) {
+ const h = p + l.scrollTop();
+ l.scrollTop(h);
+ } else p < 0 && l.scrollTop(0);
+ }
+ i.options.scrollHistory &&
+ t.location.hash !== `#${s}` &&
+ s !== r &&
+ (history.replaceState
+ ? history.replaceState({}, '', `#${s}`)
+ : ((scrollV = n.body.scrollTop),
+ (scrollH = n.body.scrollLeft),
+ (location.hash = `#${s}`),
+ (n.body.scrollTop = scrollV),
+ (n.body.scrollLeft = scrollH))),
+ i.options.showAndHideOnScroll &&
+ i.options.showAndHide &&
+ i._triggerShow(o, !0);
+ }, 0);
+ });
+ });
+ },
+ calculateHeights: function () {
+ const t = this;
+ (t.cachedHeights = []), (t.cachedAnchors = []);
+ const n = e(t.options.context).find('div[data-unique]');
+ n.each(function (n) {
+ const r =
+ (e(this).next().length ? e(this).next() : e(this)).offset().top -
+ t.options.highlightOffset;
+ t.cachedHeights[n] = r;
+ }),
+ (t.cachedAnchors = n);
+ },
+ show: function (t, n) {
+ const r = this;
+ if (!t.is(':visible'))
+ switch (
+ (t.find(d).length || t.parent().is(l) || t.parent().is(':visible')
+ ? t.children(d).length || t.parent().is(l) || (t = t.closest(d))
+ : (t = t.parents(d).add(t)),
+ r.options.showEffect)
+ ) {
+ case 'none':
+ t.show();
+ break;
+ case 'show':
+ t.show(r.options.showEffectSpeed);
+ break;
+ case 'slideDown':
+ t.slideDown(r.options.showEffectSpeed);
+ break;
+ case 'fadeIn':
+ t.fadeIn(r.options.showEffectSpeed);
+ break;
+ default:
+ t.show();
+ }
+ return (
+ t.parent().is(l)
+ ? r.hide(e(d).not(t))
+ : r.hide(e(d).not(t.closest(l).find(d).not(t.siblings()))),
+ r
+ );
+ },
+ hide: function (e) {
+ const t = this;
+ switch (t.options.hideEffect) {
+ case 'none':
+ e.hide();
+ break;
+ case 'hide':
+ e.hide(t.options.hideEffectSpeed);
+ break;
+ case 'slideUp':
+ e.slideUp(t.options.hideEffectSpeed);
+ break;
+ case 'fadeOut':
+ e.fadeOut(t.options.hideEffectSpeed);
+ break;
+ default:
+ e.hide();
+ }
+ return t;
+ },
+ _triggerShow: function (e, t) {
+ const n = this;
+ return (
+ e.parent().is(l) || e.next().is(d)
+ ? n.show(e.next(d), t)
+ : e.parent().is(d) && n.show(e.parent(), t),
+ n
+ );
+ },
+ _addCSSClasses: function () {
+ return (
+ this.options.theme === 'jqueryui'
+ ? ((this.focusClass = 'ui-state-default'),
+ (this.hoverClass = 'ui-state-hover'),
+ this.element
+ .addClass('ui-widget')
+ .find('.toc-title')
+ .addClass('ui-widget-header')
+ .end()
+ .find('li')
+ .addClass('ui-widget-content'))
+ : this.options.theme === 'bootstrap'
+ ? (this.element.find(`${l},${d}`).addClass('nav nav-list'),
+ (this.focusClass = 'active'))
+ : ((this.focusClass = o), (this.hoverClass = s)),
+ this
+ );
+ },
+ setOption: function () {
+ e.Widget.prototype._setOption.apply(this, arguments);
+ },
+ setOptions: function () {
+ e.Widget.prototype._setOptions.apply(this, arguments);
+ },
+ _scrollTo: function (t) {
+ const n = this;
+ const r = n.options.smoothScroll || 0;
+ const i = n.options.scrollTo;
+ return (
+ e('html, body')
+ .promise()
+ .done(() => {
+ e('html, body').animate(
+ {
+ scrollTop: `${
+ e(`div[data-unique="${t.attr('data-unique')}"]`)
+ .next()
+ .offset().top - (e.isFunction(i) ? i.call() : i)
+ }px`,
+ },
+ { duration: r },
+ );
+ }),
+ n
+ );
+ },
+ });
+ }),
+ (function () {
+ const e = function (t) {
+ const n = new e.Index();
+ return (
+ n.pipeline.add(e.trimmer, e.stopWordFilter, e.stemmer),
+ t && t.call(n, n),
+ n
+ );
+ };
+ (e.version = '0.5.7'),
+ (e.utils = {}),
+ (e.utils.warn = (function (e) {
+ return function (t) {
+ e.console && console.warn;
+ };
+ })(this)),
+ (e.EventEmitter = function () {
+ this.events = {};
+ }),
+ (e.EventEmitter.prototype.addListener = function () {
+ const e = Array.prototype.slice.call(arguments);
+ const t = e.pop();
+ const n = e;
+ if (typeof t !== 'function')
+ throw new TypeError('last argument must be a function');
+ n.forEach(function (e) {
+ this.hasHandler(e) || (this.events[e] = []), this.events[e].push(t);
+ }, this);
+ }),
+ (e.EventEmitter.prototype.removeListener = function (e, t) {
+ if (this.hasHandler(e)) {
+ const n = this.events[e].indexOf(t);
+ this.events[e].splice(n, 1),
+ this.events[e].length || delete this.events[e];
+ }
+ }),
+ (e.EventEmitter.prototype.emit = function (e) {
+ if (this.hasHandler(e)) {
+ const t = Array.prototype.slice.call(arguments, 1);
+ this.events[e].forEach((e) => {
+ e.apply(void 0, t);
+ });
+ }
+ }),
+ (e.EventEmitter.prototype.hasHandler = function (e) {
+ return e in this.events;
+ }),
+ (e.tokenizer = function (e) {
+ if (!arguments.length || e == null || void 0 == e) return [];
+ if (Array.isArray(e)) return e.map((e) => e.toLowerCase());
+ for (
+ var t = e.toString().replace(/^\s+/, ''), n = t.length - 1;
+ n >= 0;
+ n--
+ )
+ if (/\S/.test(t.charAt(n))) {
+ t = t.substring(0, n + 1);
+ break;
+ }
+ return t
+ .split(/(?:\s+|\-)/)
+ .filter((e) => !!e)
+ .map((e) => e.toLowerCase());
+ }),
+ (e.Pipeline = function () {
+ this._stack = [];
+ }),
+ (e.Pipeline.registeredFunctions = {}),
+ (e.Pipeline.registerFunction = function (t, n) {
+ n in this.registeredFunctions &&
+ e.utils.warn(`Overwriting existing registered function: ${n}`),
+ (t.label = n),
+ (e.Pipeline.registeredFunctions[t.label] = t);
+ }),
+ (e.Pipeline.warnIfFunctionNotRegistered = function (t) {
+ const n = t.label && t.label in this.registeredFunctions;
+ n ||
+ e.utils.warn(
+ 'Function is not registered with pipeline. This may cause problems when serialising the index.\n',
+ t,
+ );
+ }),
+ (e.Pipeline.load = function (t) {
+ const n = new e.Pipeline();
+ return (
+ t.forEach((t) => {
+ const r = e.Pipeline.registeredFunctions[t];
+ if (!r) throw new Error(`Cannot load un-registered function: ${t}`);
+ n.add(r);
+ }),
+ n
+ );
+ }),
+ (e.Pipeline.prototype.add = function () {
+ const t = Array.prototype.slice.call(arguments);
+ t.forEach(function (t) {
+ e.Pipeline.warnIfFunctionNotRegistered(t), this._stack.push(t);
+ }, this);
+ }),
+ (e.Pipeline.prototype.after = function (t, n) {
+ e.Pipeline.warnIfFunctionNotRegistered(n);
+ const r = this._stack.indexOf(t) + 1;
+ this._stack.splice(r, 0, n);
+ }),
+ (e.Pipeline.prototype.before = function (t, n) {
+ e.Pipeline.warnIfFunctionNotRegistered(n);
+ const r = this._stack.indexOf(t);
+ this._stack.splice(r, 0, n);
+ }),
+ (e.Pipeline.prototype.remove = function (e) {
+ const t = this._stack.indexOf(e);
+ this._stack.splice(t, 1);
+ }),
+ (e.Pipeline.prototype.run = function (e) {
+ for (
+ var t = [], n = e.length, r = this._stack.length, i = 0;
+ n > i;
+ i++
+ ) {
+ for (
+ var o = e[i], s = 0;
+ r > s && ((o = this._stack[s](o, i, e)), void 0 !== o);
+ s++
+ );
+ void 0 !== o && t.push(o);
+ }
+ return t;
+ }),
+ (e.Pipeline.prototype.reset = function () {
+ this._stack = [];
+ }),
+ (e.Pipeline.prototype.toJSON = function () {
+ return this._stack.map(
+ (t) => (e.Pipeline.warnIfFunctionNotRegistered(t), t.label),
+ );
+ }),
+ (e.Vector = function () {
+ (this._magnitude = null), (this.list = void 0), (this.length = 0);
+ }),
+ (e.Vector.Node = function (e, t, n) {
+ (this.idx = e), (this.val = t), (this.next = n);
+ }),
+ (e.Vector.prototype.insert = function (t, n) {
+ const r = this.list;
+ if (!r) return (this.list = new e.Vector.Node(t, n, r)), this.length++;
+ for (var i = r, o = r.next; void 0 != o; ) {
+ if (t < o.idx)
+ return (i.next = new e.Vector.Node(t, n, o)), this.length++;
+ (i = o), (o = o.next);
+ }
+ return (i.next = new e.Vector.Node(t, n, o)), this.length++;
+ }),
+ (e.Vector.prototype.magnitude = function () {
+ if (this._magniture) return this._magnitude;
+ for (var e, t = this.list, n = 0; t; )
+ (e = t.val), (n += e * e), (t = t.next);
+ return (this._magnitude = Math.sqrt(n));
+ }),
+ (e.Vector.prototype.dot = function (e) {
+ for (var t = this.list, n = e.list, r = 0; t && n; )
+ t.idx < n.idx
+ ? (t = t.next)
+ : t.idx > n.idx
+ ? (n = n.next)
+ : ((r += t.val * n.val), (t = t.next), (n = n.next));
+ return r;
+ }),
+ (e.Vector.prototype.similarity = function (e) {
+ return this.dot(e) / (this.magnitude() * e.magnitude());
+ }),
+ (e.SortedSet = function () {
+ (this.length = 0), (this.elements = []);
+ }),
+ (e.SortedSet.load = function (e) {
+ const t = new this();
+ return (t.elements = e), (t.length = e.length), t;
+ }),
+ (e.SortedSet.prototype.add = function () {
+ Array.prototype.slice.call(arguments).forEach(function (e) {
+ ~this.indexOf(e) || this.elements.splice(this.locationFor(e), 0, e);
+ }, this),
+ (this.length = this.elements.length);
+ }),
+ (e.SortedSet.prototype.toArray = function () {
+ return this.elements.slice();
+ }),
+ (e.SortedSet.prototype.map = function (e, t) {
+ return this.elements.map(e, t);
+ }),
+ (e.SortedSet.prototype.forEach = function (e, t) {
+ return this.elements.forEach(e, t);
+ }),
+ (e.SortedSet.prototype.indexOf = function (e, t, n) {
+ var t = t || 0;
+ var n = n || this.elements.length;
+ const r = n - t;
+ const i = t + Math.floor(r / 2);
+ const o = this.elements[i];
+ return r <= 1
+ ? o === e
+ ? i
+ : -1
+ : e > o
+ ? this.indexOf(e, i, n)
+ : o > e
+ ? this.indexOf(e, t, i)
+ : o === e
+ ? i
+ : void 0;
+ }),
+ (e.SortedSet.prototype.locationFor = function (e, t, n) {
+ var t = t || 0;
+ var n = n || this.elements.length;
+ const r = n - t;
+ const i = t + Math.floor(r / 2);
+ const o = this.elements[i];
+ if (r <= 1) {
+ if (o > e) return i;
+ if (e > o) return i + 1;
+ }
+ return e > o
+ ? this.locationFor(e, i, n)
+ : o > e
+ ? this.locationFor(e, t, i)
+ : void 0;
+ }),
+ (e.SortedSet.prototype.intersect = function (t) {
+ for (
+ var n = new e.SortedSet(),
+ r = 0,
+ i = 0,
+ o = this.length,
+ s = t.length,
+ a = this.elements,
+ c = t.elements;
+ ;
+
+ ) {
+ if (r > o - 1 || i > s - 1) break;
+ a[r] !== c[i]
+ ? a[r] < c[i]
+ ? r++
+ : a[r] > c[i] && i++
+ : (n.add(a[r]), r++, i++);
+ }
+ return n;
+ }),
+ (e.SortedSet.prototype.clone = function () {
+ const t = new e.SortedSet();
+ return (t.elements = this.toArray()), (t.length = t.elements.length), t;
+ }),
+ (e.SortedSet.prototype.union = function (e) {
+ let t;
+ let n;
+ let r;
+ return (
+ this.length >= e.length
+ ? ((t = this), (n = e))
+ : ((t = e), (n = this)),
+ (r = t.clone()),
+ r.add.apply(r, n.toArray()),
+ r
+ );
+ }),
+ (e.SortedSet.prototype.toJSON = function () {
+ return this.toArray();
+ }),
+ (e.Index = function () {
+ (this._fields = []),
+ (this._ref = 'id'),
+ (this.pipeline = new e.Pipeline()),
+ (this.documentStore = new e.Store()),
+ (this.tokenStore = new e.TokenStore()),
+ (this.corpusTokens = new e.SortedSet()),
+ (this.eventEmitter = new e.EventEmitter()),
+ (this._idfCache = {}),
+ this.on('add', 'remove', 'update', () => {
+ this._idfCache = {};
+ });
+ }),
+ (e.Index.prototype.on = function () {
+ const e = Array.prototype.slice.call(arguments);
+ return this.eventEmitter.addListener.apply(this.eventEmitter, e);
+ }),
+ (e.Index.prototype.off = function (e, t) {
+ return this.eventEmitter.removeListener(e, t);
+ }),
+ (e.Index.load = function (t) {
+ t.version !== e.version &&
+ e.utils.warn(
+ `version mismatch: current ${e.version} importing ${t.version}`,
+ );
+ const n = new this();
+ return (
+ (n._fields = t.fields),
+ (n._ref = t.ref),
+ (n.documentStore = e.Store.load(t.documentStore)),
+ (n.tokenStore = e.TokenStore.load(t.tokenStore)),
+ (n.corpusTokens = e.SortedSet.load(t.corpusTokens)),
+ (n.pipeline = e.Pipeline.load(t.pipeline)),
+ n
+ );
+ }),
+ (e.Index.prototype.field = function (e, t) {
+ var t = t || {};
+ const n = { name: e, boost: t.boost || 1 };
+ return this._fields.push(n), this;
+ }),
+ (e.Index.prototype.ref = function (e) {
+ return (this._ref = e), this;
+ }),
+ (e.Index.prototype.add = function (t, n) {
+ const r = {};
+ const i = new e.SortedSet();
+ const o = t[this._ref];
+ var n = void 0 === n ? !0 : n;
+ this._fields.forEach(function (n) {
+ const o = this.pipeline.run(e.tokenizer(t[n.name]));
+ (r[n.name] = o), e.SortedSet.prototype.add.apply(i, o);
+ }, this),
+ this.documentStore.set(o, i),
+ e.SortedSet.prototype.add.apply(this.corpusTokens, i.toArray());
+ for (let s = 0; s < i.length; s++) {
+ var a = i.elements[s];
+ const c = this._fields.reduce((e, t) => {
+ const n = r[t.name].length;
+ if (!n) return e;
+ const i = r[t.name].filter((e) => e === a).length;
+ return e + (i / n) * t.boost;
+ }, 0);
+ this.tokenStore.add(a, { ref: o, tf: c });
+ }
+ n && this.eventEmitter.emit('add', t, this);
+ }),
+ (e.Index.prototype.remove = function (e, t) {
+ const n = e[this._ref];
+ var t = void 0 === t ? !0 : t;
+ if (this.documentStore.has(n)) {
+ const r = this.documentStore.get(n);
+ this.documentStore.remove(n),
+ r.forEach(function (e) {
+ this.tokenStore.remove(e, n);
+ }, this),
+ t && this.eventEmitter.emit('remove', e, this);
+ }
+ }),
+ (e.Index.prototype.update = function (e, t) {
+ var t = void 0 === t ? !0 : t;
+ this.remove(e, !1),
+ this.add(e, !1),
+ t && this.eventEmitter.emit('update', e, this);
+ }),
+ (e.Index.prototype.idf = function (e) {
+ const t = `@${e}`;
+ if (Object.prototype.hasOwnProperty.call(this._idfCache, t))
+ return this._idfCache[t];
+ const n = this.tokenStore.count(e);
+ let r = 1;
+ return (
+ n > 0 && (r = 1 + Math.log(this.tokenStore.length / n)),
+ (this._idfCache[t] = r)
+ );
+ }),
+ (e.Index.prototype.search = function (t) {
+ const n = this.pipeline.run(e.tokenizer(t));
+ const r = new e.Vector();
+ const i = [];
+ const o = this._fields.reduce((e, t) => e + t.boost, 0);
+ const s = n.some(function (e) {
+ return this.tokenStore.has(e);
+ }, this);
+ if (!s) return [];
+ n.forEach(function (t, n, s) {
+ const a = (1 / s.length) * this._fields.length * o;
+ const c = this;
+ const l = this.tokenStore.expand(t).reduce((n, i) => {
+ const o = c.corpusTokens.indexOf(i);
+ const s = c.idf(i);
+ let l = 1;
+ const u = new e.SortedSet();
+ if (i !== t) {
+ const d = Math.max(3, i.length - t.length);
+ l = 1 / Math.log(d);
+ }
+ return (
+ o > -1 && r.insert(o, a * s * l),
+ Object.keys(c.tokenStore.get(i)).forEach((e) => {
+ u.add(e);
+ }),
+ n.union(u)
+ );
+ }, new e.SortedSet());
+ i.push(l);
+ }, this);
+ const a = i.reduce((e, t) => e.intersect(t));
+ return a
+ .map(function (e) {
+ return { ref: e, score: r.similarity(this.documentVector(e)) };
+ }, this)
+ .sort((e, t) => t.score - e.score);
+ }),
+ (e.Index.prototype.documentVector = function (t) {
+ for (
+ var n = this.documentStore.get(t),
+ r = n.length,
+ i = new e.Vector(),
+ o = 0;
+ r > o;
+ o++
+ ) {
+ const s = n.elements[o];
+ const a = this.tokenStore.get(s)[t].tf;
+ const c = this.idf(s);
+ i.insert(this.corpusTokens.indexOf(s), a * c);
+ }
+ return i;
+ }),
+ (e.Index.prototype.toJSON = function () {
+ return {
+ version: e.version,
+ fields: this._fields,
+ ref: this._ref,
+ documentStore: this.documentStore.toJSON(),
+ tokenStore: this.tokenStore.toJSON(),
+ corpusTokens: this.corpusTokens.toJSON(),
+ pipeline: this.pipeline.toJSON(),
+ };
+ }),
+ (e.Index.prototype.use = function (e) {
+ const t = Array.prototype.slice.call(arguments, 1);
+ t.unshift(this), e.apply(this, t);
+ }),
+ (e.Store = function () {
+ (this.store = {}), (this.length = 0);
+ }),
+ (e.Store.load = function (t) {
+ const n = new this();
+ return (
+ (n.length = t.length),
+ (n.store = Object.keys(t.store).reduce(
+ (n, r) => ((n[r] = e.SortedSet.load(t.store[r])), n),
+ {},
+ )),
+ n
+ );
+ }),
+ (e.Store.prototype.set = function (e, t) {
+ this.has(e) || this.length++, (this.store[e] = t);
+ }),
+ (e.Store.prototype.get = function (e) {
+ return this.store[e];
+ }),
+ (e.Store.prototype.has = function (e) {
+ return e in this.store;
+ }),
+ (e.Store.prototype.remove = function (e) {
+ this.has(e) && (delete this.store[e], this.length--);
+ }),
+ (e.Store.prototype.toJSON = function () {
+ return { store: this.store, length: this.length };
+ }),
+ (e.stemmer = (function () {
+ const e = {
+ ational: 'ate',
+ tional: 'tion',
+ enci: 'ence',
+ anci: 'ance',
+ izer: 'ize',
+ bli: 'ble',
+ alli: 'al',
+ entli: 'ent',
+ eli: 'e',
+ ousli: 'ous',
+ ization: 'ize',
+ ation: 'ate',
+ ator: 'ate',
+ alism: 'al',
+ iveness: 'ive',
+ fulness: 'ful',
+ ousness: 'ous',
+ aliti: 'al',
+ iviti: 'ive',
+ biliti: 'ble',
+ logi: 'log',
+ };
+ const t = {
+ icate: 'ic',
+ ative: '',
+ alize: 'al',
+ iciti: 'ic',
+ ical: 'ic',
+ ful: '',
+ ness: '',
+ };
+ const n = '[^aeiou]';
+ const r = '[aeiouy]';
+ const i = `${n}[^aeiouy]*`;
+ const o = `${r}[aeiou]*`;
+ const s = `^(${i})?${o}${i}`;
+ const a = `^(${i})?${o}${i}(${o})?$`;
+ const c = `^(${i})?${o}${i}${o}${i}`;
+ const l = `^(${i})?${r}`;
+ const u = new RegExp(s);
+ const d = new RegExp(c);
+ const f = new RegExp(a);
+ const p = new RegExp(l);
+ const h = /^(.+?)(ss|i)es$/;
+ const g = /^(.+?)([^s])s$/;
+ const m = /^(.+?)eed$/;
+ const v = /^(.+?)(ed|ing)$/;
+ const y = /.$/;
+ const b = /(at|bl|iz)$/;
+ const w = new RegExp('([^aeiouylsz])\\1$');
+ const x = new RegExp(`^${i}${r}[^aeiouwxy]$`);
+ const _ = /^(.+?[^aeiou])y$/;
+ const k =
+ /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+ const C = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+ const N =
+ /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ const E = /^(.+?)(s|t)(ion)$/;
+ const S = /^(.+?)e$/;
+ const T = /ll$/;
+ const A = new RegExp(`^${i}${r}[^aeiouwxy]$`);
+ const L = function (n) {
+ let r;
+ let i;
+ let o;
+ let s;
+ let a;
+ let c;
+ let l;
+ if (n.length < 3) return n;
+ if (
+ ((o = n.substr(0, 1)),
+ o == 'y' && (n = o.toUpperCase() + n.substr(1)),
+ (s = h),
+ (a = g),
+ s.test(n)
+ ? (n = n.replace(s, '$1$2'))
+ : a.test(n) && (n = n.replace(a, '$1$2')),
+ (s = m),
+ (a = v),
+ s.test(n))
+ ) {
+ var L = s.exec(n);
+ (s = u), s.test(L[1]) && ((s = y), (n = n.replace(s, '')));
+ } else if (a.test(n)) {
+ var L = a.exec(n);
+ (r = L[1]),
+ (a = p),
+ a.test(r) &&
+ ((n = r),
+ (a = b),
+ (c = w),
+ (l = x),
+ a.test(n)
+ ? (n += 'e')
+ : c.test(n)
+ ? ((s = y), (n = n.replace(s, '')))
+ : l.test(n) && (n += 'e'));
+ }
+ if (((s = _), s.test(n))) {
+ var L = s.exec(n);
+ (r = L[1]), (n = `${r}i`);
+ }
+ if (((s = k), s.test(n))) {
+ var L = s.exec(n);
+ (r = L[1]), (i = L[2]), (s = u), s.test(r) && (n = r + e[i]);
+ }
+ if (((s = C), s.test(n))) {
+ var L = s.exec(n);
+ (r = L[1]), (i = L[2]), (s = u), s.test(r) && (n = r + t[i]);
+ }
+ if (((s = N), (a = E), s.test(n))) {
+ var L = s.exec(n);
+ (r = L[1]), (s = d), s.test(r) && (n = r);
+ } else if (a.test(n)) {
+ var L = a.exec(n);
+ (r = L[1] + L[2]), (a = d), a.test(r) && (n = r);
+ }
+ if (((s = S), s.test(n))) {
+ var L = s.exec(n);
+ (r = L[1]),
+ (s = d),
+ (a = f),
+ (c = A),
+ (s.test(r) || (a.test(r) && !c.test(r))) && (n = r);
+ }
+ return (
+ (s = T),
+ (a = d),
+ s.test(n) && a.test(n) && ((s = y), (n = n.replace(s, ''))),
+ o == 'y' && (n = o.toLowerCase() + n.substr(1)),
+ n
+ );
+ };
+ return L;
+ })()),
+ e.Pipeline.registerFunction(e.stemmer, 'stemmer'),
+ (e.stopWordFilter = function (t) {
+ return e.stopWordFilter.stopWords.indexOf(t) === -1 ? t : void 0;
+ }),
+ (e.stopWordFilter.stopWords = new e.SortedSet()),
+ (e.stopWordFilter.stopWords.length = 119),
+ (e.stopWordFilter.stopWords.elements = [
+ '',
+ 'a',
+ 'able',
+ 'about',
+ 'across',
+ 'after',
+ 'all',
+ 'almost',
+ 'also',
+ 'am',
+ 'among',
+ 'an',
+ 'and',
+ 'any',
+ 'are',
+ 'as',
+ 'at',
+ 'be',
+ 'because',
+ 'been',
+ 'but',
+ 'by',
+ 'can',
+ 'cannot',
+ 'could',
+ 'dear',
+ 'did',
+ 'do',
+ 'does',
+ 'either',
+ 'else',
+ 'ever',
+ 'every',
+ 'for',
+ 'from',
+ 'get',
+ 'got',
+ 'had',
+ 'has',
+ 'have',
+ 'he',
+ 'her',
+ 'hers',
+ 'him',
+ 'his',
+ 'how',
+ 'however',
+ 'i',
+ 'if',
+ 'in',
+ 'into',
+ 'is',
+ 'it',
+ 'its',
+ 'just',
+ 'least',
+ 'let',
+ 'like',
+ 'likely',
+ 'may',
+ 'me',
+ 'might',
+ 'most',
+ 'must',
+ 'my',
+ 'neither',
+ 'no',
+ 'nor',
+ 'not',
+ 'of',
+ 'off',
+ 'often',
+ 'on',
+ 'only',
+ 'or',
+ 'other',
+ 'our',
+ 'own',
+ 'rather',
+ 'said',
+ 'say',
+ 'says',
+ 'she',
+ 'should',
+ 'since',
+ 'so',
+ 'some',
+ 'than',
+ 'that',
+ 'the',
+ 'their',
+ 'them',
+ 'then',
+ 'there',
+ 'these',
+ 'they',
+ 'this',
+ 'tis',
+ 'to',
+ 'too',
+ 'twas',
+ 'us',
+ 'wants',
+ 'was',
+ 'we',
+ 'were',
+ 'what',
+ 'when',
+ 'where',
+ 'which',
+ 'while',
+ 'who',
+ 'whom',
+ 'why',
+ 'will',
+ 'with',
+ 'would',
+ 'yet',
+ 'you',
+ 'your',
+ ]),
+ e.Pipeline.registerFunction(e.stopWordFilter, 'stopWordFilter'),
+ (e.trimmer = function (e) {
+ return e.replace(/^\W+/, '').replace(/\W+$/, '');
+ }),
+ e.Pipeline.registerFunction(e.trimmer, 'trimmer'),
+ (e.TokenStore = function () {
+ (this.root = { docs: {} }), (this.length = 0);
+ }),
+ (e.TokenStore.load = function (e) {
+ const t = new this();
+ return (t.root = e.root), (t.length = e.length), t;
+ }),
+ (e.TokenStore.prototype.add = function (e, t, n) {
+ var n = n || this.root;
+ const r = e[0];
+ const i = e.slice(1);
+ return (
+ r in n || (n[r] = { docs: {} }),
+ i.length === 0
+ ? ((n[r].docs[t.ref] = t), void (this.length += 1))
+ : this.add(i, t, n[r])
+ );
+ }),
+ (e.TokenStore.prototype.has = function (e) {
+ if (!e) return !1;
+ for (let t = this.root, n = 0; n < e.length; n++) {
+ if (!t[e[n]]) return !1;
+ t = t[e[n]];
+ }
+ return !0;
+ }),
+ (e.TokenStore.prototype.getNode = function (e) {
+ if (!e) return {};
+ for (var t = this.root, n = 0; n < e.length; n++) {
+ if (!t[e[n]]) return {};
+ t = t[e[n]];
+ }
+ return t;
+ }),
+ (e.TokenStore.prototype.get = function (e, t) {
+ return this.getNode(e, t).docs || {};
+ }),
+ (e.TokenStore.prototype.count = function (e, t) {
+ return Object.keys(this.get(e, t)).length;
+ }),
+ (e.TokenStore.prototype.remove = function (e, t) {
+ if (e) {
+ for (var n = this.root, r = 0; r < e.length; r++) {
+ if (!(e[r] in n)) return;
+ n = n[e[r]];
+ }
+ delete n.docs[t];
+ }
+ }),
+ (e.TokenStore.prototype.expand = function (e, t) {
+ const n = this.getNode(e);
+ const r = n.docs || {};
+ var t = t || [];
+ return (
+ Object.keys(r).length && t.push(e),
+ Object.keys(n).forEach(function (n) {
+ n !== 'docs' && t.concat(this.expand(e + n, t));
+ }, this),
+ t
+ );
+ }),
+ (e.TokenStore.prototype.toJSON = function () {
+ return { root: this.root, length: this.length };
+ }),
+ (function (e, t) {
+ typeof define === 'function' && define.amd
+ ? define(t)
+ : typeof exports === 'object'
+ ? (module.exports = t())
+ : (e.lunr = t());
+ })(this, () => e);
+ })(),
+ (function (e) {
+ 'use strict';
+
+ function t(t) {
+ if (t && t !== '') {
+ $('.lang-selector a').removeClass('active'),
+ $(`.lang-selector a[data-language-name='${t}']`).addClass('active');
+ for (let n = 0; n < u.length; n++)
+ $(`code.language-${u[n]}`).parent().hide();
+ $(`code.language-${t}`).parent().show(),
+ e.toc.calculateHeights(),
+ $(window.location.hash).get(0) &&
+ $(window.location.hash).get(0).scrollIntoView(!0);
+ }
+ }
+ function n(e) {
+ return typeof e !== 'string'
+ ? {}
+ : ((e = e.trim().replace(/^(\?|#|&)/, '')),
+ e
+ ? e.split('&').reduce((e, t) => {
+ const n = t.replace(/\+/g, ' ').split('=');
+ let r = n[0];
+ let i = n[1];
+ return (
+ (r = decodeURIComponent(r)),
+ (i = void 0 === i ? null : decodeURIComponent(i)),
+ e.hasOwnProperty(r)
+ ? Array.isArray(e[r])
+ ? e[r].push(i)
+ : (e[r] = [e[r], i])
+ : (e[r] = i),
+ e
+ );
+ }, {})
+ : {});
+ }
+ function r(e) {
+ return e
+ ? Object.keys(e)
+ .sort()
+ .map((t) => {
+ const n = e[t];
+ return Array.isArray(n)
+ ? n
+ .sort()
+ .map(
+ (e) =>
+ `${encodeURIComponent(t)}=${encodeURIComponent(e)}`,
+ )
+ .join('&')
+ : `${encodeURIComponent(t)}=${encodeURIComponent(n)}`;
+ })
+ .join('&')
+ : '';
+ }
+ function i() {
+ if (location.search.length >= 1) {
+ const e = n(location.search).language;
+ if (e) return e;
+ if (jQuery.inArray(location.search.substr(1), u) != -1)
+ return location.search.substr(1);
+ }
+ return !1;
+ }
+ function o(e) {
+ const t = n(location.search);
+ return t.language ? ((t.language = e), r(t)) : e;
+ }
+ function s(e) {
+ if (history) {
+ let t = window.location.hash;
+ t && (t = t.replace(/^#+/, '')),
+ history.pushState({}, '', `?${o(e)}#${t}`),
+ localStorage.setItem('language', e);
+ }
+ }
+ function a(e) {
+ const n = localStorage.getItem('language');
+ u = e;
+ const r = i();
+ r
+ ? (t(r), localStorage.setItem('language', r))
+ : t(n !== null && jQuery.inArray(n, u) != -1 ? n : u[0]);
+ }
+ function c(e) {
+ return e
+ .toString()
+ .toLowerCase()
+ .replace(/\s+/g, '-')
+ .replace(/[^\w\-]+/g, '')
+ .replace(/\-\-+/g, '-')
+ .replace(/^-+/, '')
+ .replace(/-+$/, '');
+ }
+ function l() {
+ setTimeout(() => {
+ toc.setOption('showEffectSpeed', 180);
+ }, 50);
+ }
+ hljs.initHighlightingOnLoad();
+ var u = [];
+ (e.setupLanguages = a),
+ (e.activateLanguage = t),
+ $(() => {
+ $('h1, h2').each(function () {
+ $(this).prop('id', c($(this).text()));
+ }),
+ $('.lang-selector a').on('click', function () {
+ const e = $(this).data('language-name');
+ return s(e), t(e), !1;
+ }),
+ (window.onpopstate = function () {
+ t(i());
+ });
+ });
+ const d = function () {
+ $('.tocify-wrapper').removeClass('open'),
+ $('#nav-button').removeClass('open');
+ };
+ const f = function () {
+ (e.toc = $('#toc')
+ .tocify({
+ selectors: 'h1, h2',
+ extendPage: !1,
+ theme: 'none',
+ smoothScroll: !1,
+ showEffectSpeed: 0,
+ hideEffectSpeed: 180,
+ ignoreSelector: '.toc-ignore',
+ highlightOffset: 60,
+ scrollTo: -1,
+ scrollHistory: !0,
+ hashGenerator: function (e, t) {
+ return t.prop('id');
+ },
+ })
+ .data('toc-tocify')),
+ $('#nav-button').click(
+ () => (
+ $('.tocify-wrapper').toggleClass('open'),
+ $('#nav-button').toggleClass('open'),
+ !1
+ ),
+ ),
+ $('.page-wrapper').click(d),
+ $('.tocify-item').click(d);
+ };
+ $(() => {
+ f(),
+ l(),
+ $('.content').imagesLoaded(() => {
+ e.toc.calculateHeights();
+ });
+ });
+ })(window),
+ (function () {
+ 'use strict';
+
+ function e() {
+ $('h1, h2').each(function () {
+ const e = $(this);
+ const t = e.nextUntil('h1, h2');
+ c.add({ id: e.prop('id'), title: e.text(), body: t.text() });
+ });
+ }
+ function t() {
+ (o = $('.content')),
+ (s = $('.search-results')),
+ $('#input-search').on('keyup', n);
+ }
+ function n(e) {
+ if (
+ (i(),
+ s.addClass('visible'),
+ e.keyCode === 27 && (this.value = ''),
+ this.value)
+ ) {
+ const t = c.search(this.value).filter((e) => e.score > 1e-4);
+ t.length
+ ? (s.empty(),
+ $.each(t, (e, t) => {
+ const n = document.getElementById(t.ref);
+ s.append(`
${$(n).text()}`);
+ }),
+ r.call(this))
+ : (s.html('
'),
+ $('.search-results li').text(
+ `No Results Found for "${this.value}"`,
+ ));
+ } else i(), s.removeClass('visible');
+ }
+ function r() {
+ this.value && o.highlight(this.value, a);
+ }
+ function i() {
+ o.unhighlight(a);
+ }
+ let o;
+ let s;
+ var a = { element: 'span', className: 'search-highlight' };
+ var c = new lunr.Index();
+ c.ref('id'),
+ c.field('title', { boost: 10 }),
+ c.field('body'),
+ c.pipeline.add(lunr.trimmer, lunr.stopWordFilter),
+ $(e),
+ $(t);
+ })();
diff --git a/public/docs/js/tryitout-2.0.2.js b/public/docs/js/tryitout-2.0.2.js
new file mode 100644
index 00000000..69607206
--- /dev/null
+++ b/public/docs/js/tryitout-2.0.2.js
@@ -0,0 +1,241 @@
+window.abortControllers = {};
+
+function tryItOut(endpointId) {
+ document.querySelector(`#btn-tryout-${endpointId}`).hidden = true;
+ document.querySelector(`#btn-executetryout-${endpointId}`).hidden = false;
+ document.querySelector(`#btn-canceltryout-${endpointId}`).hidden = false;
+
+ // Show all input fields
+ document
+ .querySelectorAll(
+ `input[data-endpoint=${endpointId}],label[data-endpoint=${endpointId}]`,
+ )
+ .forEach((el) => (el.hidden = false));
+
+ if (document.querySelector(`#form-${endpointId}`).dataset.authed === '1') {
+ const authElement = document.querySelector(`#auth-${endpointId}`);
+ authElement && (authElement.hidden = false);
+ }
+ // Expand all nested fields
+ document
+ .querySelectorAll(`#form-${endpointId} details`)
+ .forEach((el) => (el.open = true));
+}
+
+function cancelTryOut(endpointId) {
+ if (window.abortControllers[endpointId]) {
+ window.abortControllers[endpointId].abort();
+ delete window.abortControllers[endpointId];
+ }
+
+ document.querySelector(`#btn-tryout-${endpointId}`).hidden = false;
+ const executeBtn = document.querySelector(`#btn-executetryout-${endpointId}`);
+ executeBtn.hidden = true;
+ executeBtn.textContent = 'Send Request 💥';
+ document.querySelector(`#btn-canceltryout-${endpointId}`).hidden = true;
+ // Hide inputs
+ document
+ .querySelectorAll(
+ `input[data-endpoint=${endpointId}],label[data-endpoint=${endpointId}]`,
+ )
+ .forEach((el) => (el.hidden = true));
+ document
+ .querySelectorAll(`#form-${endpointId} details`)
+ .forEach((el) => (el.open = false));
+ const authElement = document.querySelector(`#auth-${endpointId}`);
+ authElement && (authElement.hidden = true);
+
+ document.querySelector(`#execution-results-${endpointId}`).hidden = true;
+ document.querySelector(`#execution-error-${endpointId}`).hidden = true;
+
+ // Revert to sample code blocks
+ document.querySelector(`#example-requests-${endpointId}`).hidden = false;
+ document.querySelector(`#example-responses-${endpointId}`).hidden = false;
+}
+
+function makeAPICall(method, path, body, query, headers, endpointId) {
+ console.log({ endpointId, path, body, query, headers });
+
+ if (!(body instanceof FormData)) {
+ body = JSON.stringify(body);
+ }
+
+ const url = new URL(`${window.baseUrl}/${path.replace(/^\//, '')}`);
+
+ // We need this function because if you try to set an array or object directly to a URLSearchParams object,
+ // you'll get [object Object] or the array.toString()
+ function addItemToSearchParamsObject(key, value, searchParams) {
+ if (Array.isArray(value)) {
+ value.forEach((v, i) => {
+ // Append {filters: [first, second]} as filters[0]=first&filters[1]second
+ addItemToSearchParamsObject(`${key}[${i}]`, v, searchParams);
+ });
+ } else if (typeof value === 'object' && value !== null) {
+ Object.keys(value).forEach((i) => {
+ // Append {filters: {name: first}} as filters[name]=first
+ addItemToSearchParamsObject(`${key}[${i}]`, value[i], searchParams);
+ });
+ } else {
+ searchParams.append(key, value);
+ }
+ }
+
+ Object.keys(query).forEach((key) =>
+ addItemToSearchParamsObject(key, query[key], url.searchParams),
+ );
+
+ window.abortControllers[endpointId] = new AbortController();
+
+ return fetch(url, {
+ method,
+ headers,
+ body: method === 'GET' ? undefined : body,
+ signal: window.abortControllers[endpointId].signal,
+ }).then((response) =>
+ Promise.all([response.status, response.text(), response.headers]),
+ );
+}
+
+function hideCodeSamples(endpointId) {
+ document.querySelector(`#example-requests-${endpointId}`).hidden = true;
+ document.querySelector(`#example-responses-${endpointId}`).hidden = true;
+}
+
+function handleResponse(endpointId, response, status, headers) {
+ hideCodeSamples(endpointId);
+
+ // Hide error views
+ document.querySelector(`#execution-error-${endpointId}`).hidden = true;
+
+ const responseContentEl = document.querySelector(
+ `#execution-response-content-${endpointId}`,
+ );
+
+ // Prettify it if it's JSON
+ let isJson = false;
+ try {
+ const jsonParsed = JSON.parse(response);
+ if (jsonParsed !== null) {
+ isJson = true;
+ response = JSON.stringify(jsonParsed, null, 4);
+ }
+ } catch (e) {}
+ responseContentEl.textContent =
+ response === '' ? '
' : response;
+ isJson && window.hljs.highlightBlock(responseContentEl);
+ const statusEl = document.querySelector(
+ `#execution-response-status-${endpointId}`,
+ );
+ statusEl.textContent = ` (${status})`;
+ document.querySelector(`#execution-results-${endpointId}`).hidden = false;
+ statusEl.scrollIntoView({ behavior: 'smooth', block: 'center' });
+}
+
+function handleError(endpointId, err) {
+ hideCodeSamples(endpointId);
+ // Hide response views
+ document.querySelector(`#execution-results-${endpointId}`).hidden = true;
+
+ // Show error views
+ let errorMessage = err.message || err;
+ errorMessage +=
+ "\n\nTip: Check that you're properly connected to the network.";
+ errorMessage +=
+ "\nIf you're a maintainer of ths API, verify that your API is running and you've enabled CORS.";
+ errorMessage +=
+ '\nYou can check the Dev Tools console for debugging information.';
+ document.querySelector(`#execution-error-message-${endpointId}`).textContent =
+ errorMessage;
+ const errorEl = document.querySelector(`#execution-error-${endpointId}`);
+ errorEl.hidden = false;
+ errorEl.scrollIntoView({ behavior: 'smooth', block: 'center' });
+}
+
+async function executeTryOut(endpointId, form) {
+ const executeBtn = document.querySelector(`#btn-executetryout-${endpointId}`);
+ executeBtn.textContent = '⏱ Sending...';
+ executeBtn.scrollIntoView({ behavior: 'smooth', block: 'center' });
+
+ let body;
+ let setter;
+ if (form.dataset.hasfiles === '1') {
+ body = new FormData();
+ setter = (name, value) => body.append(name, value);
+ } else if (form.dataset.isarraybody === '1') {
+ body = [];
+ setter = (name, value) => _.set(body, name, value);
+ } else {
+ body = {};
+ setter = (name, value) => _.set(body, name, value);
+ }
+ const bodyParameters = form.querySelectorAll('input[data-component=body]');
+ bodyParameters.forEach((el) => {
+ let { value } = el;
+ if (el.type === 'file' && el.files[0]) {
+ setter(el.name, el.files[0]);
+ return;
+ }
+
+ if (el.type !== 'radio') {
+ if (value === '' && el.required === false) {
+ // Don't include empty optional values in the request
+ return;
+ }
+ setter(el.name, value);
+ return;
+ }
+
+ if (el.checked) {
+ value = value !== 'false';
+ setter(el.name, value);
+ }
+ });
+
+ const query = {};
+ const queryParameters = form.querySelectorAll('input[data-component=query]');
+ queryParameters.forEach((el) => {
+ if (el.type !== 'radio' || (el.type === 'radio' && el.checked)) {
+ _.set(query, el.name, el.value);
+ }
+ });
+
+ let { path } = form.dataset;
+ const urlParameters = form.querySelectorAll('input[data-component=url]');
+ urlParameters.forEach(
+ (el) => (path = path.replace(new RegExp(`\\:${el.name}\\??`), el.value)),
+ );
+
+ const headers = JSON.parse(form.dataset.headers);
+ // Check for auth param that might go in header
+ if (form.dataset.authed === '1') {
+ const authHeaderEl = form.querySelector('input[data-component=header]');
+ if (authHeaderEl)
+ headers[authHeaderEl.name] =
+ authHeaderEl.dataset.prefix + authHeaderEl.value;
+ }
+ // When using FormData, the browser sets the correct content-type + boundary
+ if (body instanceof FormData) {
+ delete headers['Content-Type'];
+ }
+
+ makeAPICall(form.dataset.method, path, body, query, headers, endpointId)
+ .then(([responseStatus, responseContent, responseHeaders]) => {
+ handleResponse(
+ endpointId,
+ responseContent,
+ responseStatus,
+ responseHeaders,
+ );
+ })
+ .catch((err) => {
+ if (err.name === 'AbortError') {
+ console.log('Request cancelled');
+ return;
+ }
+ console.log('Error while making request: ', err);
+ handleError(endpointId, err);
+ })
+ .finally(() => {
+ executeBtn.textContent = 'Send Request 💥';
+ });
+}
+