{"version":3,"file":"mainLegacy.bd8bb04370fa8fbf3901.js","mappings":"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CAChD,IACA,OACA,QACA,SACA,QACA,MACA,SACA,OACA,KACA,QACA,KACA,MACA,MACA,MACA,KACA,KACA,KACA,UACA,OACA,MACA,KACA,MACA,SACA,QACA,OACA,MACA,KACA,OACA,SACA,OACA,OACA,QACA,MACA,OACA,MACA,MACA,MACA,MACA,OACA,KACA,MACA,OACA,MACA,MACA,MACA,UACA,IACA,KACA,KACA,OACA,KACA,KACA,MACA,OACA,QACA,MACA,OACA,SACA,MACA,KACA,QACA,OACA,OACA,KACA,UACA,KACA,MACA,MACA,KACA,MACA,QACA,KACA,OACA,KACA,QACA,MACA,MACA,SACA,OACA,MACA,OACA,MACA,SACA,QACA,KACA,OACA,OACA,OACA,MACA,QACA,OACA,OACA,QACA,QACA,OACA,OACA,MACA,KACA,MACA,OACA,KACA,QACA,MACA,KACA,OACA,OACA,OACA,QACA,QACA,QACA,MACA,OACA,MACA,OACA,OACA,QACA,MACA,MACA,SAGFvH,EAAK0D,SAASG,iBAAiB7D,EAAKO,eAAgB,kBAqBpDP,EAAKM,QAAU,SAAUwE,GACvB,OAAOA,EAAM/B,QAAO,SAAUtU,GAC5B,OAAOA,EAAEC,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,GAC/C,GACF,EAEAsR,EAAK0D,SAASG,iBAAiB7D,EAAKM,QAAS,YA2B7CN,EAAK4H,SAAW,WACdtgB,KAAKugB,OAAQ,EACbvgB,KAAKwgB,MAAQ,CAAC,EACdxgB,KAAKygB,GAAK/H,EAAK4H,SAASI,QACxBhI,EAAK4H,SAASI,SAAW,CAC3B,GAUcA,QAAU,EASxBhI,EAAK4H,SAASK,UAAY,SAAUrZ,GAGlC,IAFA,IAAIsR,EAAU,IAAIF,EAAK4H,SAASzH,QAEvBjT,EAAI,EAAG+V,EAAMrU,EAAIhE,OAAQsC,EAAI+V,EAAK/V,IACzCgT,EAAQuF,OAAO7W,EAAI1B,IAIrB,OADAgT,EAAQgI,SACDhI,EAAQxK,IACjB,EAWAsK,EAAK4H,SAASO,WAAa,SAAUC,GACnC,MAAI,iBAAkBA,EACbpI,EAAK4H,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","sources":["webpack://deveth0.de/./node_modules/@webcomponents/template/template.js","webpack://deveth0.de/./node_modules/intersection-observer/intersection-observer.js","webpack://deveth0.de/./node_modules/lodash.throttle/index.js","webpack://deveth0.de/./node_modules/lunr/lunr.js","webpack://deveth0.de/./node_modules/picturefill/dist/picturefill.js","webpack://deveth0.de/./themes/deveth0-theme/src/external/polyfills/mozilla_array-find.js","webpack://deveth0.de/./themes/deveth0-theme/src/external/polyfills/mozilla_array-from.js","webpack://deveth0.de/./themes/deveth0-theme/src/external/polyfills/mozilla_object-keys.js","webpack://deveth0.de/./themes/deveth0-theme/src/components/backToTop.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/commento/count.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/commentsLazyLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/cookieConsent.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/cookieHelper.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/gallery.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/lazyLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/lightbox.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/postList.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/postNav.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/readingPositionIndicator.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/search.ts","webpack://deveth0.de/./themes/deveth0-theme/src/components/svgLoader.ts","webpack://deveth0.de/./themes/deveth0-theme/src/main.ts","webpack://deveth0.de/./themes/deveth0-theme/src/mainLegacy.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/mqHelper.ts","webpack://deveth0.de/./themes/deveth0-theme/src/util/navObserver.ts","webpack://deveth0.de/webpack/bootstrap","webpack://deveth0.de/webpack/runtime/compat get default export","webpack://deveth0.de/webpack/runtime/define property getters","webpack://deveth0.de/webpack/runtime/global","webpack://deveth0.de/webpack/runtime/hasOwnProperty shorthand","webpack://deveth0.de/webpack/runtime/make namespace object","webpack://deveth0.de/webpack/runtime/node module decorator","webpack://deveth0.de/./src/mainLegacy.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n// minimal template polyfill\n(function () {\n  'use strict';\n\n  var needsTemplate = typeof HTMLTemplateElement === 'undefined';\n  var brokenDocFragment = !(\n    document.createDocumentFragment().cloneNode() instanceof DocumentFragment\n  );\n  var needsDocFrag = false;\n\n  // NOTE: Replace DocumentFragment to work around IE11 bug that\n  // causes children of a document fragment modified while\n  // there is a mutation observer to not have a parentNode, or\n  // have a broken parentNode (!?!)\n  if (/Trident/.test(navigator.userAgent)) {\n    (function () {\n      needsDocFrag = true;\n\n      var origCloneNode = Node.prototype.cloneNode;\n      Node.prototype.cloneNode = function cloneNode(deep) {\n        var newDom = origCloneNode.call(this, deep);\n        if (this instanceof DocumentFragment) {\n          newDom.__proto__ = DocumentFragment.prototype;\n        }\n        return newDom;\n      };\n\n      // IE's DocumentFragment querySelector code doesn't work when\n      // called on an element instance\n      DocumentFragment.prototype.querySelectorAll =\n        HTMLElement.prototype.querySelectorAll;\n      DocumentFragment.prototype.querySelector =\n        HTMLElement.prototype.querySelector;\n\n      Object.defineProperties(DocumentFragment.prototype, {\n        'nodeType': {\n          get: function () {\n            return Node.DOCUMENT_FRAGMENT_NODE;\n          },\n          configurable: true,\n        },\n\n        'localName': {\n          get: function () {\n            return undefined;\n          },\n          configurable: true,\n        },\n\n        'nodeName': {\n          get: function () {\n            return '#document-fragment';\n          },\n          configurable: true,\n        },\n      });\n\n      var origInsertBefore = Node.prototype.insertBefore;\n      function insertBefore(newNode, refNode) {\n        if (newNode instanceof DocumentFragment) {\n          var child;\n          while ((child = newNode.firstChild)) {\n            origInsertBefore.call(this, child, refNode);\n          }\n        } else {\n          origInsertBefore.call(this, newNode, refNode);\n        }\n        return newNode;\n      }\n      Node.prototype.insertBefore = insertBefore;\n\n      var origAppendChild = Node.prototype.appendChild;\n      Node.prototype.appendChild = function appendChild(child) {\n        if (child instanceof DocumentFragment) {\n          insertBefore.call(this, child, null);\n        } else {\n          origAppendChild.call(this, child);\n        }\n        return child;\n      };\n\n      var origRemoveChild = Node.prototype.removeChild;\n      var origReplaceChild = Node.prototype.replaceChild;\n      Node.prototype.replaceChild = function replaceChild(newChild, oldChild) {\n        if (newChild instanceof DocumentFragment) {\n          insertBefore.call(this, newChild, oldChild);\n          origRemoveChild.call(this, oldChild);\n        } else {\n          origReplaceChild.call(this, newChild, oldChild);\n        }\n        return oldChild;\n      };\n\n      Document.prototype.createDocumentFragment = function createDocumentFragment() {\n        var frag = this.createElement('df');\n        frag.__proto__ = DocumentFragment.prototype;\n        return frag;\n      };\n\n      var origImportNode = Document.prototype.importNode;\n      Document.prototype.importNode = function importNode(impNode, deep) {\n        deep = deep || false;\n        var newNode = origImportNode.call(this, impNode, deep);\n        if (impNode instanceof DocumentFragment) {\n          newNode.__proto__ = DocumentFragment.prototype;\n        }\n        return newNode;\n      };\n    })();\n  }\n\n  // NOTE: we rely on this cloneNode not causing element upgrade.\n  // This means this polyfill must load before the CE polyfill and\n  // this would need to be re-worked if a browser supports native CE\n  // but not <template>.\n  var capturedCloneNode = Node.prototype.cloneNode;\n  var capturedCreateElement = Document.prototype.createElement;\n  var capturedImportNode = Document.prototype.importNode;\n  var capturedRemoveChild = Node.prototype.removeChild;\n  var capturedAppendChild = Node.prototype.appendChild;\n  var capturedReplaceChild = Node.prototype.replaceChild;\n  var capturedParseFromString = DOMParser.prototype.parseFromString;\n  var capturedHTMLElementInnerHTML = Object.getOwnPropertyDescriptor(\n    window.HTMLElement.prototype,\n    'innerHTML'\n  ) || {\n    /**\n     * @this {!HTMLElement}\n     * @return {string}\n     */\n    get: function () {\n      return this.innerHTML;\n    },\n    /**\n     * @this {!HTMLElement}\n     * @param {string}\n     */\n    set: function (text) {\n      this.innerHTML = text;\n    },\n  };\n  var capturedChildNodes = Object.getOwnPropertyDescriptor(\n    window.Node.prototype,\n    'childNodes'\n  ) || {\n    /**\n     * @this {!Node}\n     * @return {!NodeList}\n     */\n    get: function () {\n      return this.childNodes;\n    },\n  };\n\n  var elementQuerySelectorAll = Element.prototype.querySelectorAll;\n  var docQuerySelectorAll = Document.prototype.querySelectorAll;\n  var fragQuerySelectorAll = DocumentFragment.prototype.querySelectorAll;\n\n  var scriptSelector =\n    'script:not([type]),script[type=\"application/javascript\"],script[type=\"text/javascript\"]';\n\n  function QSA(node, selector) {\n    // IE 11 throws a SyntaxError with `scriptSelector` if the node has no children due to the `:not([type])` syntax\n    if (!node.childNodes.length) {\n      return [];\n    }\n    switch (node.nodeType) {\n      case Node.DOCUMENT_NODE:\n        return docQuerySelectorAll.call(node, selector);\n      case Node.DOCUMENT_FRAGMENT_NODE:\n        return fragQuerySelectorAll.call(node, selector);\n      default:\n        return elementQuerySelectorAll.call(node, selector);\n    }\n  }\n\n  // returns true if nested templates cannot be cloned (they cannot be on\n  // some impl's like Safari 8 and Edge)\n  // OR if cloning a document fragment does not result in a document fragment\n  var needsCloning = (function () {\n    if (!needsTemplate) {\n      var t = document.createElement('template');\n      var t2 = document.createElement('template');\n      t2.content.appendChild(document.createElement('div'));\n      t.content.appendChild(t2);\n      var clone = t.cloneNode(true);\n      return (\n        clone.content.childNodes.length === 0 ||\n        clone.content.firstChild.content.childNodes.length === 0 ||\n        brokenDocFragment\n      );\n    }\n  })();\n\n  var TEMPLATE_TAG = 'template';\n  var PolyfilledHTMLTemplateElement = function () {};\n\n  if (needsTemplate) {\n    var contentDoc = document.implementation.createHTMLDocument('template');\n    var canDecorate = true;\n\n    var templateStyle = document.createElement('style');\n    templateStyle.textContent = TEMPLATE_TAG + '{display:none;}';\n\n    var head = document.head;\n    head.insertBefore(templateStyle, head.firstElementChild);\n\n    /**\n      Provides a minimal shim for the <template> element.\n    */\n    PolyfilledHTMLTemplateElement.prototype = Object.create(\n      HTMLElement.prototype\n    );\n\n    // if elements do not have `innerHTML` on instances, then\n    // templates can be patched by swizzling their prototypes.\n    var canProtoPatch = !document\n      .createElement('div')\n      .hasOwnProperty('innerHTML');\n\n    /**\n      The `decorate` method moves element children to the template's `content`.\n      NOTE: there is no support for dynamically adding elements to templates.\n    */\n    PolyfilledHTMLTemplateElement.decorate = function (template) {\n      // if the template is decorated or not in HTML namespace, return fast\n      if (\n        template.content ||\n        template.namespaceURI !== document.documentElement.namespaceURI\n      ) {\n        return;\n      }\n      template.content = contentDoc.createDocumentFragment();\n      var child;\n      while ((child = template.firstChild)) {\n        capturedAppendChild.call(template.content, child);\n      }\n      // NOTE: prefer prototype patching for performance and\n      // because on some browsers (IE11), re-defining `innerHTML`\n      // can result in intermittent errors.\n      if (canProtoPatch) {\n        template.__proto__ = PolyfilledHTMLTemplateElement.prototype;\n      } else {\n        template.cloneNode = function (deep) {\n          return PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n        };\n        // add innerHTML to template, if possible\n        // Note: this throws on Safari 7\n        if (canDecorate) {\n          try {\n            defineInnerHTML(template);\n            defineOuterHTML(template);\n          } catch (err) {\n            canDecorate = false;\n          }\n        }\n      }\n      // bootstrap recursively\n      PolyfilledHTMLTemplateElement.bootstrap(template.content);\n    };\n\n    // Taken from https://github.com/jquery/jquery/blob/73d7e6259c63ac45f42c6593da8c2796c6ce9281/src/manipulation/wrapMap.js\n    var topLevelWrappingMap = {\n      'option': ['select'],\n      'thead': ['table'],\n      'col': ['colgroup', 'table'],\n      'tr': ['tbody', 'table'],\n      'th': ['tr', 'tbody', 'table'],\n      'td': ['tr', 'tbody', 'table'],\n    };\n\n    var getTagName = function (text) {\n      // Taken from https://github.com/jquery/jquery/blob/73d7e6259c63ac45f42c6593da8c2796c6ce9281/src/manipulation/var/rtagName.js\n      return (/<([a-z][^/\\0>\\x20\\t\\r\\n\\f]+)/i.exec(text) || [\n        '',\n        '',\n      ])[1].toLowerCase();\n    };\n\n    var defineInnerHTML = function defineInnerHTML(obj) {\n      Object.defineProperty(obj, 'innerHTML', {\n        get: function () {\n          return getInnerHTML(this);\n        },\n        set: function (text) {\n          // For IE11, wrap the text in the correct (table) context\n          var wrap = topLevelWrappingMap[getTagName(text)];\n          if (wrap) {\n            for (var i = 0; i < wrap.length; i++) {\n              text = '<' + wrap[i] + '>' + text + '</' + wrap[i] + '>';\n            }\n          }\n          contentDoc.body.innerHTML = text;\n          PolyfilledHTMLTemplateElement.bootstrap(contentDoc);\n          while (this.content.firstChild) {\n            capturedRemoveChild.call(this.content, this.content.firstChild);\n          }\n          var body = contentDoc.body;\n          // If we had wrapped, get back to the original node\n          if (wrap) {\n            for (var j = 0; j < wrap.length; j++) {\n              body = body.lastChild;\n            }\n          }\n          while (body.firstChild) {\n            capturedAppendChild.call(this.content, body.firstChild);\n          }\n        },\n        configurable: true,\n      });\n    };\n\n    var defineOuterHTML = function defineOuterHTML(obj) {\n      Object.defineProperty(obj, 'outerHTML', {\n        get: function () {\n          return `<${TEMPLATE_TAG}>${this.innerHTML}</${TEMPLATE_TAG}>`;\n        },\n        set: function (innerHTML) {\n          if (this.parentNode) {\n            contentDoc.body.innerHTML = innerHTML;\n            var docFrag = this.ownerDocument.createDocumentFragment();\n            while (contentDoc.body.firstChild) {\n              capturedAppendChild.call(docFrag, contentDoc.body.firstChild);\n            }\n            capturedReplaceChild.call(this.parentNode, docFrag, this);\n          } else {\n            throw new Error(\n              \"Failed to set the 'outerHTML' property on 'Element': This element has no parent node.\"\n            );\n          }\n        },\n        configurable: true,\n      });\n    };\n\n    defineInnerHTML(PolyfilledHTMLTemplateElement.prototype);\n    defineOuterHTML(PolyfilledHTMLTemplateElement.prototype);\n\n    /**\n      The `bootstrap` method is called automatically and \"fixes\" all\n      <template> elements in the document referenced by the `doc` argument.\n    */\n    PolyfilledHTMLTemplateElement.bootstrap = function bootstrap(doc) {\n      var templates = QSA(doc, TEMPLATE_TAG);\n      for (\n        var i = 0, l = templates.length, t;\n        i < l && (t = templates[i]);\n        i++\n      ) {\n        PolyfilledHTMLTemplateElement.decorate(t);\n      }\n    };\n\n    // auto-bootstrapping for main document\n    document.addEventListener('DOMContentLoaded', function () {\n      PolyfilledHTMLTemplateElement.bootstrap(document);\n    });\n\n    // Patch document.createElement to ensure newly created templates have content\n    Document.prototype.createElement = function createElement() {\n      var el = capturedCreateElement.apply(this, arguments);\n      if (el.localName === 'template') {\n        PolyfilledHTMLTemplateElement.decorate(el);\n      }\n      return el;\n    };\n\n    DOMParser.prototype.parseFromString = function () {\n      var el = capturedParseFromString.apply(this, arguments);\n      PolyfilledHTMLTemplateElement.bootstrap(el);\n      return el;\n    };\n\n    Object.defineProperty(HTMLElement.prototype, 'innerHTML', {\n      get: function () {\n        return getInnerHTML(this);\n      },\n      set: function (text) {\n        capturedHTMLElementInnerHTML.set.call(this, text);\n        PolyfilledHTMLTemplateElement.bootstrap(this);\n      },\n      configurable: true,\n      enumerable: true,\n    });\n\n    // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString\n    var escapeAttrRegExp = /[&\\u00A0\"]/g;\n    var escapeDataRegExp = /[&\\u00A0<>]/g;\n\n    var escapeReplace = function (c) {\n      switch (c) {\n        case '&':\n          return '&amp;';\n        case '<':\n          return '&lt;';\n        case '>':\n          return '&gt;';\n        case '\"':\n          return '&quot;';\n        case '\\u00A0':\n          return '&nbsp;';\n      }\n    };\n\n    var escapeAttr = function (s) {\n      return s.replace(escapeAttrRegExp, escapeReplace);\n    };\n\n    var escapeData = function (s) {\n      return s.replace(escapeDataRegExp, escapeReplace);\n    };\n\n    var makeSet = function (arr) {\n      var set = {};\n      for (var i = 0; i < arr.length; i++) {\n        set[arr[i]] = true;\n      }\n      return set;\n    };\n\n    // http://www.whatwg.org/specs/web-apps/current-work/#void-elements\n    var voidElements = makeSet([\n      'area',\n      'base',\n      'br',\n      'col',\n      'command',\n      'embed',\n      'hr',\n      'img',\n      'input',\n      'keygen',\n      'link',\n      'meta',\n      'param',\n      'source',\n      'track',\n      'wbr',\n    ]);\n\n    var plaintextParents = makeSet([\n      'style',\n      'script',\n      'xmp',\n      'iframe',\n      'noembed',\n      'noframes',\n      'plaintext',\n      'noscript',\n    ]);\n\n    /**\n     * @param {Node} node\n     * @param {Node} parentNode\n     * @param {Function=} callback\n     */\n    var getOuterHTML = function (node, parentNode, callback) {\n      switch (node.nodeType) {\n        case Node.ELEMENT_NODE: {\n          var tagName = node.localName;\n          var s = '<' + tagName;\n          var attrs = node.attributes;\n          for (var i = 0, attr; (attr = attrs[i]); i++) {\n            s += ' ' + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n          }\n          s += '>';\n          if (voidElements[tagName]) {\n            return s;\n          }\n          return s + getInnerHTML(node, callback) + '</' + tagName + '>';\n        }\n        case Node.TEXT_NODE: {\n          var data = /** @type {Text} */ (node).data;\n          if (parentNode && plaintextParents[parentNode.localName]) {\n            return data;\n          }\n          return escapeData(data);\n        }\n        case Node.COMMENT_NODE: {\n          return '<!--' + /** @type {Comment} */ (node).data + '-->';\n        }\n        default: {\n          window.console.error(node);\n          throw new Error('not implemented');\n        }\n      }\n    };\n\n    /**\n     * @param {Node} node\n     * @param {Function=} callback\n     */\n    var getInnerHTML = function (node, callback) {\n      if (node.localName === 'template') {\n        node = /** @type {HTMLTemplateElement} */ (node).content;\n      }\n      var s = '';\n      var c$ = callback ? callback(node) : capturedChildNodes.get.call(node);\n      for (var i = 0, l = c$.length, child; i < l && (child = c$[i]); i++) {\n        s += getOuterHTML(child, node, callback);\n      }\n      return s;\n    };\n  }\n\n  // make cloning/importing work!\n  if (needsTemplate || needsCloning) {\n    PolyfilledHTMLTemplateElement._cloneNode = function _cloneNode(\n      template,\n      deep\n    ) {\n      var clone = capturedCloneNode.call(template, false);\n      // NOTE: decorate doesn't auto-fix children because they are already\n      // decorated so they need special clone fixup.\n      if (this.decorate) {\n        this.decorate(clone);\n      }\n      if (deep) {\n        // NOTE: use native clone node to make sure CE's wrapped\n        // cloneNode does not cause elements to upgrade.\n        capturedAppendChild.call(\n          clone.content,\n          capturedCloneNode.call(template.content, true)\n        );\n        // now ensure nested templates are cloned correctly.\n        fixClonedDom(clone.content, template.content);\n      }\n      return clone;\n    };\n\n    // Given a source and cloned subtree, find <template>'s in the cloned\n    // subtree and replace them with cloned <template>'s from source.\n    // We must do this because only the source templates have proper .content.\n    var fixClonedDom = function fixClonedDom(clone, source) {\n      // do nothing if cloned node is not an element\n      if (!source.querySelectorAll) {\n        return;\n      }\n      // these two lists should be coincident\n      var s$ = QSA(source, TEMPLATE_TAG);\n      if (s$.length === 0) {\n        return;\n      }\n      var t$ = QSA(clone, TEMPLATE_TAG);\n      for (var i = 0, l = t$.length, t, s; i < l; i++) {\n        s = s$[i];\n        t = t$[i];\n        if (\n          PolyfilledHTMLTemplateElement &&\n          PolyfilledHTMLTemplateElement.decorate\n        ) {\n          PolyfilledHTMLTemplateElement.decorate(s);\n        }\n        capturedReplaceChild.call(t.parentNode, cloneNode.call(s, true), t);\n      }\n    };\n\n    // make sure scripts inside of a cloned template are executable\n    var fixClonedScripts = function fixClonedScripts(fragment) {\n      var scripts = QSA(fragment, scriptSelector);\n      for (var ns, s, i = 0; i < scripts.length; i++) {\n        s = scripts[i];\n        ns = capturedCreateElement.call(document, 'script');\n        ns.textContent = s.textContent;\n        var attrs = s.attributes;\n        for (var ai = 0, a; ai < attrs.length; ai++) {\n          a = attrs[ai];\n          ns.setAttribute(a.name, a.value);\n        }\n        capturedReplaceChild.call(s.parentNode, ns, s);\n      }\n    };\n\n    // override all cloning to fix the cloned subtree to contain properly\n    // cloned templates.\n    var cloneNode = (Node.prototype.cloneNode = function cloneNode(deep) {\n      var dom;\n      // workaround for Edge bug cloning documentFragments\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8619646/\n      if (\n        !needsDocFrag &&\n        brokenDocFragment &&\n        this instanceof DocumentFragment\n      ) {\n        if (!deep) {\n          return this.ownerDocument.createDocumentFragment();\n        } else {\n          dom = importNode.call(this.ownerDocument, this, true);\n        }\n      } else if (\n        this.nodeType === Node.ELEMENT_NODE &&\n        this.localName === TEMPLATE_TAG &&\n        this.namespaceURI == document.documentElement.namespaceURI\n      ) {\n        dom = PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n      } else {\n        dom = capturedCloneNode.call(this, deep);\n      }\n      // template.content is cloned iff `deep`.\n      if (deep) {\n        fixClonedDom(dom, this);\n      }\n      return dom;\n    });\n\n    // NOTE: we are cloning instead of importing <template>'s.\n    // However, the ownerDocument of the cloned template will be correct!\n    // This is because the native import node creates the right document owned\n    // subtree and `fixClonedDom` inserts cloned templates into this subtree,\n    // thus updating the owner doc.\n    var importNode = (Document.prototype.importNode = function importNode(\n      element,\n      deep\n    ) {\n      deep = deep || false;\n      if (element.localName === TEMPLATE_TAG) {\n        return PolyfilledHTMLTemplateElement._cloneNode(element, deep);\n      } else {\n        var dom = capturedImportNode.call(this, element, deep);\n        if (deep) {\n          fixClonedDom(dom, element);\n          fixClonedScripts(dom);\n        }\n        return dom;\n      }\n    });\n  }\n\n  if (needsTemplate) {\n    window.HTMLTemplateElement = PolyfilledHTMLTemplateElement;\n  }\n})();\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n/**\n * Returns the embedding frame element, if any.\n * @param {!Document} doc\n * @return {!Element}\n */\nfunction getFrameElement(doc) {\n  try {\n    return doc.defaultView && doc.defaultView.frameElement || null;\n  } catch (e) {\n    // Ignore the error.\n    return null;\n  }\n}\n\n/**\n * A local reference to the root document.\n */\nvar document = (function(startDoc) {\n  var doc = startDoc;\n  var frame = getFrameElement(doc);\n  while (frame) {\n    doc = frame.ownerDocument;\n    frame = getFrameElement(doc);\n  }\n  return doc;\n})(window.document);\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n/**\n * The signal updater for cross-origin intersection. When not null, it means\n * that the polyfill is configured to work in a cross-origin mode.\n * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nvar crossOriginUpdater = null;\n\n/**\n * The current cross-origin intersection. Only used in the cross-origin mode.\n * @type {DOMRect|ClientRect}\n */\nvar crossOriginRect = null;\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = ensureDOMRect(entry.rootBounds);\n  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (\n    options.root &&\n    options.root.nodeType != 1 &&\n    options.root.nodeType != 9\n  ) {\n    throw new Error('root must be a Document or Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n\n  /** @private @const {!Array<!Document>} */\n  this._monitoringDocuments = [];\n  /** @private @const {!Array<function()>} */\n  this._monitoringUnsubscribes = [];\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Sets up the polyfill in the cross-origin mode. The result is the\n * updater function that accepts two arguments: `boundingClientRect` and\n * `intersectionRect` - just as these fields would be available to the\n * parent via `IntersectionObserverEntry`. This function should be called\n * each time the iframe receives intersection information from the parent\n * window, e.g. via messaging.\n * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nIntersectionObserver._setupCrossOriginUpdater = function() {\n  if (!crossOriginUpdater) {\n    /**\n     * @param {DOMRect|ClientRect} boundingClientRect\n     * @param {DOMRect|ClientRect} intersectionRect\n     */\n    crossOriginUpdater = function(boundingClientRect, intersectionRect) {\n      if (!boundingClientRect || !intersectionRect) {\n        crossOriginRect = getEmptyRect();\n      } else {\n        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n      }\n      registry.forEach(function(observer) {\n        observer._checkForIntersections();\n      });\n    };\n  }\n  return crossOriginUpdater;\n};\n\n\n/**\n * Resets the cross-origin mode.\n */\nIntersectionObserver._resetCrossOriginUpdater = function() {\n  crossOriginUpdater = null;\n  crossOriginRect = null;\n};\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections(target.ownerDocument);\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n        return item.element != target;\n      });\n  this._unmonitorIntersections(target.ownerDocument);\n  if (this._observationTargets.length == 0) {\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorAllIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function(doc) {\n  var win = doc.defaultView;\n  if (!win) {\n    // Already destroyed.\n    return;\n  }\n  if (this._monitoringDocuments.indexOf(doc) != -1) {\n    // Already monitoring.\n    return;\n  }\n\n  // Private state for monitoring.\n  var callback = this._checkForIntersections;\n  var monitoringInterval = null;\n  var domObserver = null;\n\n  // If a poll interval is set, use polling instead of listening to\n  // resize and scroll events or DOM mutations.\n  if (this.POLL_INTERVAL) {\n    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n  } else {\n    addEvent(win, 'resize', callback, true);\n    addEvent(doc, 'scroll', callback, true);\n    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n      domObserver = new win.MutationObserver(callback);\n      domObserver.observe(doc, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    }\n  }\n\n  this._monitoringDocuments.push(doc);\n  this._monitoringUnsubscribes.push(function() {\n    // Get the window object again. When a friendly iframe is destroyed, it\n    // will be null.\n    var win = doc.defaultView;\n\n    if (win) {\n      if (monitoringInterval) {\n        win.clearInterval(monitoringInterval);\n      }\n      removeEvent(win, 'resize', callback, true);\n    }\n\n    removeEvent(doc, 'scroll', callback, true);\n    if (domObserver) {\n      domObserver.disconnect();\n    }\n  });\n\n  // Also monitor the parent.\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._monitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function(doc) {\n  var index = this._monitoringDocuments.indexOf(doc);\n  if (index == -1) {\n    return;\n  }\n\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n\n  // Check if any dependent targets are still remaining.\n  var hasDependentTargets =\n      this._observationTargets.some(function(item) {\n        var itemDoc = item.element.ownerDocument;\n        // Target is in this context.\n        if (itemDoc == doc) {\n          return true;\n        }\n        // Target is nested in this context.\n        while (itemDoc && itemDoc != rootDoc) {\n          var frame = getFrameElement(itemDoc);\n          itemDoc = frame && frame.ownerDocument;\n          if (itemDoc == doc) {\n            return true;\n          }\n        }\n        return false;\n      });\n  if (hasDependentTargets) {\n    return;\n  }\n\n  // Unsubscribe.\n  var unsubscribe = this._monitoringUnsubscribes[index];\n  this._monitoringDocuments.splice(index, 1);\n  this._monitoringUnsubscribes.splice(index, 1);\n  unsubscribe();\n\n  // Also unmonitor the parent.\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._unmonitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorAllIntersections = function() {\n  var unsubscribes = this._monitoringUnsubscribes.slice(0);\n  this._monitoringDocuments.length = 0;\n  this._monitoringUnsubscribes.length = 0;\n  for (var i = 0; i < unsubscribes.length; i++) {\n    unsubscribes[i]();\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  if (!this.root && crossOriginUpdater && !crossOriginRect) {\n    // Cross origin monitoring, but no initial data available yet.\n    return;\n  }\n\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n    var rootBounds = null;\n    if (!this._rootContainsTarget(target)) {\n      rootBounds = getEmptyRect();\n    } else if (!crossOriginUpdater || this.root) {\n      rootBounds = rootRect;\n    }\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootBounds,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} targetRect The bounding rect of the target.\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, targetRect, rootRect) {\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot && parent) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return null;\n\n    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\n      atRoot = true;\n      if (parent == this.root || parent == document) {\n        if (crossOriginUpdater && !this.root) {\n          if (!crossOriginRect ||\n              crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n            // A 0-size cross-origin intersection means no-intersection.\n            parent = null;\n            parentRect = null;\n            intersectionRect = null;\n          } else {\n            parentRect = crossOriginRect;\n          }\n        } else {\n          parentRect = rootRect;\n        }\n      } else {\n        // Check if there's a frame that can be navigated to.\n        var frame = getParentNode(parent);\n        var frameRect = frame && getBoundingClientRect(frame);\n        var frameIntersect =\n            frame &&\n            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n        if (frameRect && frameIntersect) {\n          parent = frame;\n          parentRect = convertFromParentRect(frameRect, frameIntersect);\n        } else {\n          parent = null;\n          intersectionRect = null;\n        }\n      }\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      var doc = parent.ownerDocument;\n      if (parent != doc.body &&\n          parent != doc.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n    }\n    if (!intersectionRect) break;\n    parent = parent && getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {ClientRect} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root && !isDoc(this.root)) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var doc = isDoc(this.root) ? this.root : document;\n    var html = doc.documentElement;\n    var body = doc.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {DOMRect|ClientRect} rect The rect object to expand.\n * @return {ClientRect} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  return (\n    containsDeep(rootDoc, target) &&\n    (!this.root || rootDoc == target.ownerDocument)\n  );\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detachEvent == 'function') {\n    node.detachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object|?ClientRect} The intersection rect or undefined if no\n *     intersection is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  } || null;\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {ClientRect} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n\n/**\n * Ensure that the result has all of the necessary fields of the DOMRect.\n * Specifically this ensures that `x` and `y` fields are set.\n *\n * @param {?DOMRect|?ClientRect} rect\n * @return {?DOMRect}\n */\nfunction ensureDOMRect(rect) {\n  // A `DOMRect` object has `x` and `y` fields.\n  if (!rect || 'x' in rect) {\n    return rect;\n  }\n  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n  // for internally calculated Rect objects. For the purposes of\n  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n  // for these fields.\n  return {\n    top: rect.top,\n    y: rect.top,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    right: rect.right,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\n\n/**\n * Inverts the intersection and bounding rect from the parent (frame) BCR to\n * the local BCR space.\n * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n * @return {ClientRect} The local root bounding rect for the parent's children.\n */\nfunction convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n  var top = parentIntersectionRect.top - parentBoundingRect.top;\n  var left = parentIntersectionRect.left - parentBoundingRect.left;\n  return {\n    top: top,\n    left: left,\n    height: parentIntersectionRect.height,\n    width: parentIntersectionRect.width,\n    bottom: top + parentIntersectionRect.height,\n    right: left + parentIntersectionRect.width\n  };\n}\n\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\n    // If this node is a document node, look for the embedding frame.\n    return getFrameElement(node);\n  }\n\n  // If the parent has element that is assigned through shadow root slot\n  if (parent && parent.assignedSlot) {\n    parent = parent.assignedSlot.parentNode\n  }\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  return parent;\n}\n\n/**\n * Returns true if `node` is a Document.\n * @param {!Node} node\n * @returns {boolean}\n */\nfunction isDoc(node) {\n  return node && node.nodeType === 9;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = throttle;\n","/**\n * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9\n * Copyright (C) 2020 Oliver Nightingale\n * @license MIT\n */\n\n;(function(){\n\n/**\n * A convenience function for configuring and constructing\n * a new lunr Index.\n *\n * A lunr.Builder instance is created and the pipeline setup\n * with a trimmer, stop word filter and stemmer.\n *\n * This builder object is yielded to the configuration function\n * that is passed as a parameter, allowing the list of fields\n * and other builder parameters to be customised.\n *\n * All documents _must_ be added within the passed config function.\n *\n * @example\n * var idx = lunr(function () {\n *   this.field('title')\n *   this.field('body')\n *   this.ref('id')\n *\n *   documents.forEach(function (doc) {\n *     this.add(doc)\n *   }, this)\n * })\n *\n * @see {@link lunr.Builder}\n * @see {@link lunr.Pipeline}\n * @see {@link lunr.trimmer}\n * @see {@link lunr.stopWordFilter}\n * @see {@link lunr.stemmer}\n * @namespace {function} lunr\n */\nvar lunr = function (config) {\n  var builder = new lunr.Builder\n\n  builder.pipeline.add(\n    lunr.trimmer,\n    lunr.stopWordFilter,\n    lunr.stemmer\n  )\n\n  builder.searchPipeline.add(\n    lunr.stemmer\n  )\n\n  config.call(builder, builder)\n  return builder.build()\n}\n\nlunr.version = \"2.3.9\"\n/*!\n * lunr.utils\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * A namespace containing utils for the rest of the lunr library\n * @namespace lunr.utils\n */\nlunr.utils = {}\n\n/**\n * Print a warning message to the console.\n *\n * @param {String} message The message to be printed.\n * @memberOf lunr.utils\n * @function\n */\nlunr.utils.warn = (function (global) {\n  /* eslint-disable no-console */\n  return function (message) {\n    if (global.console && console.warn) {\n      console.warn(message)\n    }\n  }\n  /* eslint-enable no-console */\n})(this)\n\n/**\n * Convert an object to a string.\n *\n * In the case of `null` and `undefined` the function returns\n * the empty string, in all other cases the result of calling\n * `toString` on the passed object is returned.\n *\n * @param {Any} obj The object to convert to a string.\n * @return {String} string representation of the passed object.\n * @memberOf lunr.utils\n */\nlunr.utils.asString = function (obj) {\n  if (obj === void 0 || obj === null) {\n    return \"\"\n  } else {\n    return obj.toString()\n  }\n}\n\n/**\n * Clones an object.\n *\n * Will create a copy of an existing object such that any mutations\n * on the copy cannot affect the original.\n *\n * Only shallow objects are supported, passing a nested object to this\n * function will cause a TypeError.\n *\n * Objects with primitives, and arrays of primitives are supported.\n *\n * @param {Object} obj The object to clone.\n * @return {Object} a clone of the passed object.\n * @throws {TypeError} when a nested object is passed.\n * @memberOf Utils\n */\nlunr.utils.clone = function (obj) {\n  if (obj === null || obj === undefined) {\n    return obj\n  }\n\n  var clone = Object.create(null),\n      keys = Object.keys(obj)\n\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i],\n        val = obj[key]\n\n    if (Array.isArray(val)) {\n      clone[key] = val.slice()\n      continue\n    }\n\n    if (typeof val === 'string' ||\n        typeof val === 'number' ||\n        typeof val === 'boolean') {\n      clone[key] = val\n      continue\n    }\n\n    throw new TypeError(\"clone is not deep and does not support nested objects\")\n  }\n\n  return clone\n}\nlunr.FieldRef = function (docRef, fieldName, stringValue) {\n  this.docRef = docRef\n  this.fieldName = fieldName\n  this._stringValue = stringValue\n}\n\nlunr.FieldRef.joiner = \"/\"\n\nlunr.FieldRef.fromString = function (s) {\n  var n = s.indexOf(lunr.FieldRef.joiner)\n\n  if (n === -1) {\n    throw \"malformed field ref string\"\n  }\n\n  var fieldRef = s.slice(0, n),\n      docRef = s.slice(n + 1)\n\n  return new lunr.FieldRef (docRef, fieldRef, s)\n}\n\nlunr.FieldRef.prototype.toString = function () {\n  if (this._stringValue == undefined) {\n    this._stringValue = this.fieldName + lunr.FieldRef.joiner + this.docRef\n  }\n\n  return this._stringValue\n}\n/*!\n * lunr.Set\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * A lunr set.\n *\n * @constructor\n */\nlunr.Set = function (elements) {\n  this.elements = Object.create(null)\n\n  if (elements) {\n    this.length = elements.length\n\n    for (var i = 0; i < this.length; i++) {\n      this.elements[elements[i]] = true\n    }\n  } else {\n    this.length = 0\n  }\n}\n\n/**\n * A complete set that contains all elements.\n *\n * @static\n * @readonly\n * @type {lunr.Set}\n */\nlunr.Set.complete = {\n  intersect: function (other) {\n    return other\n  },\n\n  union: function () {\n    return this\n  },\n\n  contains: function () {\n    return true\n  }\n}\n\n/**\n * An empty set that contains no elements.\n *\n * @static\n * @readonly\n * @type {lunr.Set}\n */\nlunr.Set.empty = {\n  intersect: function () {\n    return this\n  },\n\n  union: function (other) {\n    return other\n  },\n\n  contains: function () {\n    return false\n  }\n}\n\n/**\n * Returns true if this set contains the specified object.\n *\n * @param {object} object - Object whose presence in this set is to be tested.\n * @returns {boolean} - True if this set contains the specified object.\n */\nlunr.Set.prototype.contains = function (object) {\n  return !!this.elements[object]\n}\n\n/**\n * Returns a new set containing only the elements that are present in both\n * this set and the specified set.\n *\n * @param {lunr.Set} other - set to intersect with this set.\n * @returns {lunr.Set} a new set that is the intersection of this and the specified set.\n */\n\nlunr.Set.prototype.intersect = function (other) {\n  var a, b, elements, intersection = []\n\n  if (other === lunr.Set.complete) {\n    return this\n  }\n\n  if (other === lunr.Set.empty) {\n    return other\n  }\n\n  if (this.length < other.length) {\n    a = this\n    b = other\n  } else {\n    a = other\n    b = this\n  }\n\n  elements = Object.keys(a.elements)\n\n  for (var i = 0; i < elements.length; i++) {\n    var element = elements[i]\n    if (element in b.elements) {\n      intersection.push(element)\n    }\n  }\n\n  return new lunr.Set (intersection)\n}\n\n/**\n * Returns a new set combining the elements of this and the specified set.\n *\n * @param {lunr.Set} other - set to union with this set.\n * @return {lunr.Set} a new set that is the union of this and the specified set.\n */\n\nlunr.Set.prototype.union = function (other) {\n  if (other === lunr.Set.complete) {\n    return lunr.Set.complete\n  }\n\n  if (other === lunr.Set.empty) {\n    return this\n  }\n\n  return new lunr.Set(Object.keys(this.elements).concat(Object.keys(other.elements)))\n}\n/**\n * A function to calculate the inverse document frequency for\n * a posting. This is shared between the builder and the index\n *\n * @private\n * @param {object} posting - The posting for a given term\n * @param {number} documentCount - The total number of documents.\n */\nlunr.idf = function (posting, documentCount) {\n  var documentsWithTerm = 0\n\n  for (var fieldName in posting) {\n    if (fieldName == '_index') continue // Ignore the term index, its not a field\n    documentsWithTerm += Object.keys(posting[fieldName]).length\n  }\n\n  var x = (documentCount - documentsWithTerm + 0.5) / (documentsWithTerm + 0.5)\n\n  return Math.log(1 + Math.abs(x))\n}\n\n/**\n * A token wraps a string representation of a token\n * as it is passed through the text processing pipeline.\n *\n * @constructor\n * @param {string} [str=''] - The string token being wrapped.\n * @param {object} [metadata={}] - Metadata associated with this token.\n */\nlunr.Token = function (str, metadata) {\n  this.str = str || \"\"\n  this.metadata = metadata || {}\n}\n\n/**\n * Returns the token string that is being wrapped by this object.\n *\n * @returns {string}\n */\nlunr.Token.prototype.toString = function () {\n  return this.str\n}\n\n/**\n * A token update function is used when updating or optionally\n * when cloning a token.\n *\n * @callback lunr.Token~updateFunction\n * @param {string} str - The string representation of the token.\n * @param {Object} metadata - All metadata associated with this token.\n */\n\n/**\n * Applies the given function to the wrapped string token.\n *\n * @example\n * token.update(function (str, metadata) {\n *   return str.toUpperCase()\n * })\n *\n * @param {lunr.Token~updateFunction} fn - A function to apply to the token string.\n * @returns {lunr.Token}\n */\nlunr.Token.prototype.update = function (fn) {\n  this.str = fn(this.str, this.metadata)\n  return this\n}\n\n/**\n * Creates a clone of this token. Optionally a function can be\n * applied to the cloned token.\n *\n * @param {lunr.Token~updateFunction} [fn] - An optional function to apply to the cloned token.\n * @returns {lunr.Token}\n */\nlunr.Token.prototype.clone = function (fn) {\n  fn = fn || function (s) { return s }\n  return new lunr.Token (fn(this.str, this.metadata), this.metadata)\n}\n/*!\n * lunr.tokenizer\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * A function for splitting a string into tokens ready to be inserted into\n * the search index. Uses `lunr.tokenizer.separator` to split strings, change\n * the value of this property to change how strings are split into tokens.\n *\n * This tokenizer will convert its parameter to a string by calling `toString` and\n * then will split this string on the character in `lunr.tokenizer.separator`.\n * Arrays will have their elements converted to strings and wrapped in a lunr.Token.\n *\n * Optional metadata can be passed to the tokenizer, this metadata will be cloned and\n * added as metadata to every token that is created from the object to be tokenized.\n *\n * @static\n * @param {?(string|object|object[])} obj - The object to convert into tokens\n * @param {?object} metadata - Optional metadata to associate with every token\n * @returns {lunr.Token[]}\n * @see {@link lunr.Pipeline}\n */\nlunr.tokenizer = function (obj, metadata) {\n  if (obj == null || obj == undefined) {\n    return []\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(function (t) {\n      return new lunr.Token(\n        lunr.utils.asString(t).toLowerCase(),\n        lunr.utils.clone(metadata)\n      )\n    })\n  }\n\n  var str = obj.toString().toLowerCase(),\n      len = str.length,\n      tokens = []\n\n  for (var sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {\n    var char = str.charAt(sliceEnd),\n        sliceLength = sliceEnd - sliceStart\n\n    if ((char.match(lunr.tokenizer.separator) || sliceEnd == len)) {\n\n      if (sliceLength > 0) {\n        var tokenMetadata = lunr.utils.clone(metadata) || {}\n        tokenMetadata[\"position\"] = [sliceStart, sliceLength]\n        tokenMetadata[\"index\"] = tokens.length\n\n        tokens.push(\n          new lunr.Token (\n            str.slice(sliceStart, sliceEnd),\n            tokenMetadata\n          )\n        )\n      }\n\n      sliceStart = sliceEnd + 1\n    }\n\n  }\n\n  return tokens\n}\n\n/**\n * The separator used to split a string into tokens. Override this property to change the behaviour of\n * `lunr.tokenizer` behaviour when tokenizing strings. By default this splits on whitespace and hyphens.\n *\n * @static\n * @see lunr.tokenizer\n */\nlunr.tokenizer.separator = /[\\s\\-]+/\n/*!\n * lunr.Pipeline\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * lunr.Pipelines maintain an ordered list of functions to be applied to all\n * tokens in documents entering the search index and queries being ran against\n * the index.\n *\n * An instance of lunr.Index created with the lunr shortcut will contain a\n * pipeline with a stop word filter and an English language stemmer. Extra\n * functions can be added before or after either of these functions or these\n * default functions can be removed.\n *\n * When run the pipeline will call each function in turn, passing a token, the\n * index of that token in the original list of all tokens and finally a list of\n * all the original tokens.\n *\n * The output of functions in the pipeline will be passed to the next function\n * in the pipeline. To exclude a token from entering the index the function\n * should return undefined, the rest of the pipeline will not be called with\n * this token.\n *\n * For serialisation of pipelines to work, all functions used in an instance of\n * a pipeline should be registered with lunr.Pipeline. Registered functions can\n * then be loaded. If trying to load a serialised pipeline that uses functions\n * that are not registered an error will be thrown.\n *\n * If not planning on serialising the pipeline then registering pipeline functions\n * is not necessary.\n *\n * @constructor\n */\nlunr.Pipeline = function () {\n  this._stack = []\n}\n\nlunr.Pipeline.registeredFunctions = Object.create(null)\n\n/**\n * A pipeline function maps lunr.Token to lunr.Token. A lunr.Token contains the token\n * string as well as all known metadata. A pipeline function can mutate the token string\n * or mutate (or add) metadata for a given token.\n *\n * A pipeline function can indicate that the passed token should be discarded by returning\n * null, undefined or an empty string. This token will not be passed to any downstream pipeline\n * functions and will not be added to the index.\n *\n * Multiple tokens can be returned by returning an array of tokens. Each token will be passed\n * to any downstream pipeline functions and all will returned tokens will be added to the index.\n *\n * Any number of pipeline functions may be chained together using a lunr.Pipeline.\n *\n * @interface lunr.PipelineFunction\n * @param {lunr.Token} token - A token from the document being processed.\n * @param {number} i - The index of this token in the complete list of tokens for this document/field.\n * @param {lunr.Token[]} tokens - All tokens for this document/field.\n * @returns {(?lunr.Token|lunr.Token[])}\n */\n\n/**\n * Register a function with the pipeline.\n *\n * Functions that are used in the pipeline should be registered if the pipeline\n * needs to be serialised, or a serialised pipeline needs to be loaded.\n *\n * Registering a function does not add it to a pipeline, functions must still be\n * added to instances of the pipeline for them to be used when running a pipeline.\n *\n * @param {lunr.PipelineFunction} fn - The function to check for.\n * @param {String} label - The label to register this function with\n */\nlunr.Pipeline.registerFunction = function (fn, label) {\n  if (label in this.registeredFunctions) {\n    lunr.utils.warn('Overwriting existing registered function: ' + label)\n  }\n\n  fn.label = label\n  lunr.Pipeline.registeredFunctions[fn.label] = fn\n}\n\n/**\n * Warns if the function is not registered as a Pipeline function.\n *\n * @param {lunr.PipelineFunction} fn - The function to check for.\n * @private\n */\nlunr.Pipeline.warnIfFunctionNotRegistered = function (fn) {\n  var isRegistered = fn.label && (fn.label in this.registeredFunctions)\n\n  if (!isRegistered) {\n    lunr.utils.warn('Function is not registered with pipeline. This may cause problems when serialising the index.\\n', fn)\n  }\n}\n\n/**\n * Loads a previously serialised pipeline.\n *\n * All functions to be loaded must already be registered with lunr.Pipeline.\n * If any function from the serialised data has not been registered then an\n * error will be thrown.\n *\n * @param {Object} serialised - The serialised pipeline to load.\n * @returns {lunr.Pipeline}\n */\nlunr.Pipeline.load = function (serialised) {\n  var pipeline = new lunr.Pipeline\n\n  serialised.forEach(function (fnName) {\n    var fn = lunr.Pipeline.registeredFunctions[fnName]\n\n    if (fn) {\n      pipeline.add(fn)\n    } else {\n      throw new Error('Cannot load unregistered function: ' + fnName)\n    }\n  })\n\n  return pipeline\n}\n\n/**\n * Adds new functions to the end of the pipeline.\n *\n * Logs a warning if the function has not been registered.\n *\n * @param {lunr.PipelineFunction[]} functions - Any number of functions to add to the pipeline.\n */\nlunr.Pipeline.prototype.add = function () {\n  var fns = Array.prototype.slice.call(arguments)\n\n  fns.forEach(function (fn) {\n    lunr.Pipeline.warnIfFunctionNotRegistered(fn)\n    this._stack.push(fn)\n  }, this)\n}\n\n/**\n * Adds a single function after a function that already exists in the\n * pipeline.\n *\n * Logs a warning if the function has not been registered.\n *\n * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.\n * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.\n */\nlunr.Pipeline.prototype.after = function (existingFn, newFn) {\n  lunr.Pipeline.warnIfFunctionNotRegistered(newFn)\n\n  var pos = this._stack.indexOf(existingFn)\n  if (pos == -1) {\n    throw new Error('Cannot find existingFn')\n  }\n\n  pos = pos + 1\n  this._stack.splice(pos, 0, newFn)\n}\n\n/**\n * Adds a single function before a function that already exists in the\n * pipeline.\n *\n * Logs a warning if the function has not been registered.\n *\n * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.\n * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.\n */\nlunr.Pipeline.prototype.before = function (existingFn, newFn) {\n  lunr.Pipeline.warnIfFunctionNotRegistered(newFn)\n\n  var pos = this._stack.indexOf(existingFn)\n  if (pos == -1) {\n    throw new Error('Cannot find existingFn')\n  }\n\n  this._stack.splice(pos, 0, newFn)\n}\n\n/**\n * Removes a function from the pipeline.\n *\n * @param {lunr.PipelineFunction} fn The function to remove from the pipeline.\n */\nlunr.Pipeline.prototype.remove = function (fn) {\n  var pos = this._stack.indexOf(fn)\n  if (pos == -1) {\n    return\n  }\n\n  this._stack.splice(pos, 1)\n}\n\n/**\n * Runs the current list of functions that make up the pipeline against the\n * passed tokens.\n *\n * @param {Array} tokens The tokens to run through the pipeline.\n * @returns {Array}\n */\nlunr.Pipeline.prototype.run = function (tokens) {\n  var stackLength = this._stack.length\n\n  for (var i = 0; i < stackLength; i++) {\n    var fn = this._stack[i]\n    var memo = []\n\n    for (var j = 0; j < tokens.length; j++) {\n      var result = fn(tokens[j], j, tokens)\n\n      if (result === null || result === void 0 || result === '') continue\n\n      if (Array.isArray(result)) {\n        for (var k = 0; k < result.length; k++) {\n          memo.push(result[k])\n        }\n      } else {\n        memo.push(result)\n      }\n    }\n\n    tokens = memo\n  }\n\n  return tokens\n}\n\n/**\n * Convenience method for passing a string through a pipeline and getting\n * strings out. This method takes care of wrapping the passed string in a\n * token and mapping the resulting tokens back to strings.\n *\n * @param {string} str - The string to pass through the pipeline.\n * @param {?object} metadata - Optional metadata to associate with the token\n * passed to the pipeline.\n * @returns {string[]}\n */\nlunr.Pipeline.prototype.runString = function (str, metadata) {\n  var token = new lunr.Token (str, metadata)\n\n  return this.run([token]).map(function (t) {\n    return t.toString()\n  })\n}\n\n/**\n * Resets the pipeline by removing any existing processors.\n *\n */\nlunr.Pipeline.prototype.reset = function () {\n  this._stack = []\n}\n\n/**\n * Returns a representation of the pipeline ready for serialisation.\n *\n * Logs a warning if the function has not been registered.\n *\n * @returns {Array}\n */\nlunr.Pipeline.prototype.toJSON = function () {\n  return this._stack.map(function (fn) {\n    lunr.Pipeline.warnIfFunctionNotRegistered(fn)\n\n    return fn.label\n  })\n}\n/*!\n * lunr.Vector\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * A vector is used to construct the vector space of documents and queries. These\n * vectors support operations to determine the similarity between two documents or\n * a document and a query.\n *\n * Normally no parameters are required for initializing a vector, but in the case of\n * loading a previously dumped vector the raw elements can be provided to the constructor.\n *\n * For performance reasons vectors are implemented with a flat array, where an elements\n * index is immediately followed by its value. E.g. [index, value, index, value]. This\n * allows the underlying array to be as sparse as possible and still offer decent\n * performance when being used for vector calculations.\n *\n * @constructor\n * @param {Number[]} [elements] - The flat list of element index and element value pairs.\n */\nlunr.Vector = function (elements) {\n  this._magnitude = 0\n  this.elements = elements || []\n}\n\n\n/**\n * Calculates the position within the vector to insert a given index.\n *\n * This is used internally by insert and upsert. If there are duplicate indexes then\n * the position is returned as if the value for that index were to be updated, but it\n * is the callers responsibility to check whether there is a duplicate at that index\n *\n * @param {Number} insertIdx - The index at which the element should be inserted.\n * @returns {Number}\n */\nlunr.Vector.prototype.positionForIndex = function (index) {\n  // For an empty vector the tuple can be inserted at the beginning\n  if (this.elements.length == 0) {\n    return 0\n  }\n\n  var start = 0,\n      end = this.elements.length / 2,\n      sliceLength = end - start,\n      pivotPoint = Math.floor(sliceLength / 2),\n      pivotIndex = this.elements[pivotPoint * 2]\n\n  while (sliceLength > 1) {\n    if (pivotIndex < index) {\n      start = pivotPoint\n    }\n\n    if (pivotIndex > index) {\n      end = pivotPoint\n    }\n\n    if (pivotIndex == index) {\n      break\n    }\n\n    sliceLength = end - start\n    pivotPoint = start + Math.floor(sliceLength / 2)\n    pivotIndex = this.elements[pivotPoint * 2]\n  }\n\n  if (pivotIndex == index) {\n    return pivotPoint * 2\n  }\n\n  if (pivotIndex > index) {\n    return pivotPoint * 2\n  }\n\n  if (pivotIndex < index) {\n    return (pivotPoint + 1) * 2\n  }\n}\n\n/**\n * Inserts an element at an index within the vector.\n *\n * Does not allow duplicates, will throw an error if there is already an entry\n * for this index.\n *\n * @param {Number} insertIdx - The index at which the element should be inserted.\n * @param {Number} val - The value to be inserted into the vector.\n */\nlunr.Vector.prototype.insert = function (insertIdx, val) {\n  this.upsert(insertIdx, val, function () {\n    throw \"duplicate index\"\n  })\n}\n\n/**\n * Inserts or updates an existing index within the vector.\n *\n * @param {Number} insertIdx - The index at which the element should be inserted.\n * @param {Number} val - The value to be inserted into the vector.\n * @param {function} fn - A function that is called for updates, the existing value and the\n * requested value are passed as arguments\n */\nlunr.Vector.prototype.upsert = function (insertIdx, val, fn) {\n  this._magnitude = 0\n  var position = this.positionForIndex(insertIdx)\n\n  if (this.elements[position] == insertIdx) {\n    this.elements[position + 1] = fn(this.elements[position + 1], val)\n  } else {\n    this.elements.splice(position, 0, insertIdx, val)\n  }\n}\n\n/**\n * Calculates the magnitude of this vector.\n *\n * @returns {Number}\n */\nlunr.Vector.prototype.magnitude = function () {\n  if (this._magnitude) return this._magnitude\n\n  var sumOfSquares = 0,\n      elementsLength = this.elements.length\n\n  for (var i = 1; i < elementsLength; i += 2) {\n    var val = this.elements[i]\n    sumOfSquares += val * val\n  }\n\n  return this._magnitude = Math.sqrt(sumOfSquares)\n}\n\n/**\n * Calculates the dot product of this vector and another vector.\n *\n * @param {lunr.Vector} otherVector - The vector to compute the dot product with.\n * @returns {Number}\n */\nlunr.Vector.prototype.dot = function (otherVector) {\n  var dotProduct = 0,\n      a = this.elements, b = otherVector.elements,\n      aLen = a.length, bLen = b.length,\n      aVal = 0, bVal = 0,\n      i = 0, j = 0\n\n  while (i < aLen && j < bLen) {\n    aVal = a[i], bVal = b[j]\n    if (aVal < bVal) {\n      i += 2\n    } else if (aVal > bVal) {\n      j += 2\n    } else if (aVal == bVal) {\n      dotProduct += a[i + 1] * b[j + 1]\n      i += 2\n      j += 2\n    }\n  }\n\n  return dotProduct\n}\n\n/**\n * Calculates the similarity between this vector and another vector.\n *\n * @param {lunr.Vector} otherVector - The other vector to calculate the\n * similarity with.\n * @returns {Number}\n */\nlunr.Vector.prototype.similarity = function (otherVector) {\n  return this.dot(otherVector) / this.magnitude() || 0\n}\n\n/**\n * Converts the vector to an array of the elements within the vector.\n *\n * @returns {Number[]}\n */\nlunr.Vector.prototype.toArray = function () {\n  var output = new Array (this.elements.length / 2)\n\n  for (var i = 1, j = 0; i < this.elements.length; i += 2, j++) {\n    output[j] = this.elements[i]\n  }\n\n  return output\n}\n\n/**\n * A JSON serializable representation of the vector.\n *\n * @returns {Number[]}\n */\nlunr.Vector.prototype.toJSON = function () {\n  return this.elements\n}\n/* eslint-disable */\n/*!\n * lunr.stemmer\n * Copyright (C) 2020 Oliver Nightingale\n * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt\n */\n\n/**\n * lunr.stemmer is an english language stemmer, this is a JavaScript\n * implementation of the PorterStemmer taken from http://tartarus.org/~martin\n *\n * @static\n * @implements {lunr.PipelineFunction}\n * @param {lunr.Token} token - The string to stem\n * @returns {lunr.Token}\n * @see {@link lunr.Pipeline}\n * @function\n */\nlunr.stemmer = (function(){\n  var step2list = {\n      \"ational\" : \"ate\",\n      \"tional\" : \"tion\",\n      \"enci\" : \"ence\",\n      \"anci\" : \"ance\",\n      \"izer\" : \"ize\",\n      \"bli\" : \"ble\",\n      \"alli\" : \"al\",\n      \"entli\" : \"ent\",\n      \"eli\" : \"e\",\n      \"ousli\" : \"ous\",\n      \"ization\" : \"ize\",\n      \"ation\" : \"ate\",\n      \"ator\" : \"ate\",\n      \"alism\" : \"al\",\n      \"iveness\" : \"ive\",\n      \"fulness\" : \"ful\",\n      \"ousness\" : \"ous\",\n      \"aliti\" : \"al\",\n      \"iviti\" : \"ive\",\n      \"biliti\" : \"ble\",\n      \"logi\" : \"log\"\n    },\n\n    step3list = {\n      \"icate\" : \"ic\",\n      \"ative\" : \"\",\n      \"alize\" : \"al\",\n      \"iciti\" : \"ic\",\n      \"ical\" : \"ic\",\n      \"ful\" : \"\",\n      \"ness\" : \"\"\n    },\n\n    c = \"[^aeiou]\",          // consonant\n    v = \"[aeiouy]\",          // vowel\n    C = c + \"[^aeiouy]*\",    // consonant sequence\n    V = v + \"[aeiou]*\",      // vowel sequence\n\n    mgr0 = \"^(\" + C + \")?\" + V + C,               // [C]VC... is m>0\n    meq1 = \"^(\" + C + \")?\" + V + C + \"(\" + V + \")?$\",  // [C]VC[V] is m=1\n    mgr1 = \"^(\" + C + \")?\" + V + C + V + C,       // [C]VCVC... is m>1\n    s_v = \"^(\" + C + \")?\" + v;                   // vowel in stem\n\n  var re_mgr0 = new RegExp(mgr0);\n  var re_mgr1 = new RegExp(mgr1);\n  var re_meq1 = new RegExp(meq1);\n  var re_s_v = new RegExp(s_v);\n\n  var re_1a = /^(.+?)(ss|i)es$/;\n  var re2_1a = /^(.+?)([^s])s$/;\n  var re_1b = /^(.+?)eed$/;\n  var re2_1b = /^(.+?)(ed|ing)$/;\n  var re_1b_2 = /.$/;\n  var re2_1b_2 = /(at|bl|iz)$/;\n  var re3_1b_2 = new RegExp(\"([^aeiouylsz])\\\\1$\");\n  var re4_1b_2 = new RegExp(\"^\" + C + v + \"[^aeiouwxy]$\");\n\n  var re_1c = /^(.+?[^aeiou])y$/;\n  var re_2 = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;\n\n  var re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;\n\n  var re_4 = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;\n  var re2_4 = /^(.+?)(s|t)(ion)$/;\n\n  var re_5 = /^(.+?)e$/;\n  var re_5_1 = /ll$/;\n  var re3_5 = new RegExp(\"^\" + C + v + \"[^aeiouwxy]$\");\n\n  var porterStemmer = function porterStemmer(w) {\n    var stem,\n      suffix,\n      firstch,\n      re,\n      re2,\n      re3,\n      re4;\n\n    if (w.length < 3) { return w; }\n\n    firstch = w.substr(0,1);\n    if (firstch == \"y\") {\n      w = firstch.toUpperCase() + w.substr(1);\n    }\n\n    // Step 1a\n    re = re_1a\n    re2 = re2_1a;\n\n    if (re.test(w)) { w = w.replace(re,\"$1$2\"); }\n    else if (re2.test(w)) { w = w.replace(re2,\"$1$2\"); }\n\n    // Step 1b\n    re = re_1b;\n    re2 = re2_1b;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      re = re_mgr0;\n      if (re.test(fp[1])) {\n        re = re_1b_2;\n        w = w.replace(re,\"\");\n      }\n    } else if (re2.test(w)) {\n      var fp = re2.exec(w);\n      stem = fp[1];\n      re2 = re_s_v;\n      if (re2.test(stem)) {\n        w = stem;\n        re2 = re2_1b_2;\n        re3 = re3_1b_2;\n        re4 = re4_1b_2;\n        if (re2.test(w)) { w = w + \"e\"; }\n        else if (re3.test(w)) { re = re_1b_2; w = w.replace(re,\"\"); }\n        else if (re4.test(w)) { w = w + \"e\"; }\n      }\n    }\n\n    // Step 1c - replace suffix y or Y by i if preceded by a non-vowel which is not the first letter of the word (so cry -> cri, by -> by, say -> say)\n    re = re_1c;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      stem = fp[1];\n      w = stem + \"i\";\n    }\n\n    // Step 2\n    re = re_2;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      stem = fp[1];\n      suffix = fp[2];\n      re = re_mgr0;\n      if (re.test(stem)) {\n        w = stem + step2list[suffix];\n      }\n    }\n\n    // Step 3\n    re = re_3;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      stem = fp[1];\n      suffix = fp[2];\n      re = re_mgr0;\n      if (re.test(stem)) {\n        w = stem + step3list[suffix];\n      }\n    }\n\n    // Step 4\n    re = re_4;\n    re2 = re2_4;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      stem = fp[1];\n      re = re_mgr1;\n      if (re.test(stem)) {\n        w = stem;\n      }\n    } else if (re2.test(w)) {\n      var fp = re2.exec(w);\n      stem = fp[1] + fp[2];\n      re2 = re_mgr1;\n      if (re2.test(stem)) {\n        w = stem;\n      }\n    }\n\n    // Step 5\n    re = re_5;\n    if (re.test(w)) {\n      var fp = re.exec(w);\n      stem = fp[1];\n      re = re_mgr1;\n      re2 = re_meq1;\n      re3 = re3_5;\n      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) {\n        w = stem;\n      }\n    }\n\n    re = re_5_1;\n    re2 = re_mgr1;\n    if (re.test(w) && re2.test(w)) {\n      re = re_1b_2;\n      w = w.replace(re,\"\");\n    }\n\n    // and turn initial Y back to y\n\n    if (firstch == \"y\") {\n      w = firstch.toLowerCase() + w.substr(1);\n    }\n\n    return w;\n  };\n\n  return function (token) {\n    return token.update(porterStemmer);\n  }\n})();\n\nlunr.Pipeline.registerFunction(lunr.stemmer, 'stemmer')\n/*!\n * lunr.stopWordFilter\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * lunr.generateStopWordFilter builds a stopWordFilter function from the provided\n * list of stop words.\n *\n * The built in lunr.stopWordFilter is built using this generator and can be used\n * to generate custom stopWordFilters for applications or non English languages.\n *\n * @function\n * @param {Array} token The token to pass through the filter\n * @returns {lunr.PipelineFunction}\n * @see lunr.Pipeline\n * @see lunr.stopWordFilter\n */\nlunr.generateStopWordFilter = function (stopWords) {\n  var words = stopWords.reduce(function (memo, stopWord) {\n    memo[stopWord] = stopWord\n    return memo\n  }, {})\n\n  return function (token) {\n    if (token && words[token.toString()] !== token.toString()) return token\n  }\n}\n\n/**\n * lunr.stopWordFilter is an English language stop word list filter, any words\n * contained in the list will not be passed through the filter.\n *\n * This is intended to be used in the Pipeline. If the token does not pass the\n * filter then undefined will be returned.\n *\n * @function\n * @implements {lunr.PipelineFunction}\n * @params {lunr.Token} token - A token to check for being a stop word.\n * @returns {lunr.Token}\n * @see {@link lunr.Pipeline}\n */\nlunr.stopWordFilter = lunr.generateStopWordFilter([\n  'a',\n  'able',\n  'about',\n  'across',\n  'after',\n  'all',\n  'almost',\n  'also',\n  'am',\n  'among',\n  'an',\n  'and',\n  'any',\n  'are',\n  'as',\n  'at',\n  'be',\n  'because',\n  'been',\n  'but',\n  'by',\n  'can',\n  'cannot',\n  'could',\n  'dear',\n  'did',\n  'do',\n  'does',\n  'either',\n  'else',\n  'ever',\n  'every',\n  'for',\n  'from',\n  'get',\n  'got',\n  'had',\n  'has',\n  'have',\n  'he',\n  'her',\n  'hers',\n  'him',\n  'his',\n  'how',\n  'however',\n  'i',\n  'if',\n  'in',\n  'into',\n  'is',\n  'it',\n  'its',\n  'just',\n  'least',\n  'let',\n  'like',\n  'likely',\n  'may',\n  'me',\n  'might',\n  'most',\n  'must',\n  'my',\n  'neither',\n  'no',\n  'nor',\n  'not',\n  'of',\n  'off',\n  'often',\n  'on',\n  'only',\n  'or',\n  'other',\n  'our',\n  'own',\n  'rather',\n  'said',\n  'say',\n  'says',\n  'she',\n  'should',\n  'since',\n  'so',\n  'some',\n  'than',\n  'that',\n  'the',\n  'their',\n  'them',\n  'then',\n  'there',\n  'these',\n  'they',\n  'this',\n  'tis',\n  'to',\n  'too',\n  'twas',\n  'us',\n  'wants',\n  'was',\n  'we',\n  'were',\n  'what',\n  'when',\n  'where',\n  'which',\n  'while',\n  'who',\n  'whom',\n  'why',\n  'will',\n  'with',\n  'would',\n  'yet',\n  'you',\n  'your'\n])\n\nlunr.Pipeline.registerFunction(lunr.stopWordFilter, 'stopWordFilter')\n/*!\n * lunr.trimmer\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * lunr.trimmer is a pipeline function for trimming non word\n * characters from the beginning and end of tokens before they\n * enter the index.\n *\n * This implementation may not work correctly for non latin\n * characters and should either be removed or adapted for use\n * with languages with non-latin characters.\n *\n * @static\n * @implements {lunr.PipelineFunction}\n * @param {lunr.Token} token The token to pass through the filter\n * @returns {lunr.Token}\n * @see lunr.Pipeline\n */\nlunr.trimmer = function (token) {\n  return token.update(function (s) {\n    return s.replace(/^\\W+/, '').replace(/\\W+$/, '')\n  })\n}\n\nlunr.Pipeline.registerFunction(lunr.trimmer, 'trimmer')\n/*!\n * lunr.TokenSet\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * A token set is used to store the unique list of all tokens\n * within an index. Token sets are also used to represent an\n * incoming query to the index, this query token set and index\n * token set are then intersected to find which tokens to look\n * up in the inverted index.\n *\n * A token set can hold multiple tokens, as in the case of the\n * index token set, or it can hold a single token as in the\n * case of a simple query token set.\n *\n * Additionally token sets are used to perform wildcard matching.\n * Leading, contained and trailing wildcards are supported, and\n * from this edit distance matching can also be provided.\n *\n * Token sets are implemented as a minimal finite state automata,\n * where both common prefixes and suffixes are shared between tokens.\n * This helps to reduce the space used for storing the token set.\n *\n * @constructor\n */\nlunr.TokenSet = function () {\n  this.final = false\n  this.edges = {}\n  this.id = lunr.TokenSet._nextId\n  lunr.TokenSet._nextId += 1\n}\n\n/**\n * Keeps track of the next, auto increment, identifier to assign\n * to a new tokenSet.\n *\n * TokenSets require a unique identifier to be correctly minimised.\n *\n * @private\n */\nlunr.TokenSet._nextId = 1\n\n/**\n * Creates a TokenSet instance from the given sorted array of words.\n *\n * @param {String[]} arr - A sorted array of strings to create the set from.\n * @returns {lunr.TokenSet}\n * @throws Will throw an error if the input array is not sorted.\n */\nlunr.TokenSet.fromArray = function (arr) {\n  var builder = new lunr.TokenSet.Builder\n\n  for (var i = 0, len = arr.length; i < len; i++) {\n    builder.insert(arr[i])\n  }\n\n  builder.finish()\n  return builder.root\n}\n\n/**\n * Creates a token set from a query clause.\n *\n * @private\n * @param {Object} clause - A single clause from lunr.Query.\n * @param {string} clause.term - The query clause term.\n * @param {number} [clause.editDistance] - The optional edit distance for the term.\n * @returns {lunr.TokenSet}\n */\nlunr.TokenSet.fromClause = function (clause) {\n  if ('editDistance' in clause) {\n    return lunr.TokenSet.fromFuzzyString(clause.term, clause.editDistance)\n  } else {\n    return lunr.TokenSet.fromString(clause.term)\n  }\n}\n\n/**\n * Creates a token set representing a single string with a specified\n * edit distance.\n *\n * Insertions, deletions, substitutions and transpositions are each\n * treated as an edit distance of 1.\n *\n * Increasing the allowed edit distance will have a dramatic impact\n * on the performance of both creating and intersecting these TokenSets.\n * It is advised to keep the edit distance less than 3.\n *\n * @param {string} str - The string to create the token set from.\n * @param {number} editDistance - The allowed edit distance to match.\n * @returns {lunr.Vector}\n */\nlunr.TokenSet.fromFuzzyString = function (str, editDistance) {\n  var root = new lunr.TokenSet\n\n  var stack = [{\n    node: root,\n    editsRemaining: editDistance,\n    str: str\n  }]\n\n  while (stack.length) {\n    var frame = stack.pop()\n\n    // no edit\n    if (frame.str.length > 0) {\n      var char = frame.str.charAt(0),\n          noEditNode\n\n      if (char in frame.node.edges) {\n        noEditNode = frame.node.edges[char]\n      } else {\n        noEditNode = new lunr.TokenSet\n        frame.node.edges[char] = noEditNode\n      }\n\n      if (frame.str.length == 1) {\n        noEditNode.final = true\n      }\n\n      stack.push({\n        node: noEditNode,\n        editsRemaining: frame.editsRemaining,\n        str: frame.str.slice(1)\n      })\n    }\n\n    if (frame.editsRemaining == 0) {\n      continue\n    }\n\n    // insertion\n    if (\"*\" in frame.node.edges) {\n      var insertionNode = frame.node.edges[\"*\"]\n    } else {\n      var insertionNode = new lunr.TokenSet\n      frame.node.edges[\"*\"] = insertionNode\n    }\n\n    if (frame.str.length == 0) {\n      insertionNode.final = true\n    }\n\n    stack.push({\n      node: insertionNode,\n      editsRemaining: frame.editsRemaining - 1,\n      str: frame.str\n    })\n\n    // deletion\n    // can only do a deletion if we have enough edits remaining\n    // and if there are characters left to delete in the string\n    if (frame.str.length > 1) {\n      stack.push({\n        node: frame.node,\n        editsRemaining: frame.editsRemaining - 1,\n        str: frame.str.slice(1)\n      })\n    }\n\n    // deletion\n    // just removing the last character from the str\n    if (frame.str.length == 1) {\n      frame.node.final = true\n    }\n\n    // substitution\n    // can only do a substitution if we have enough edits remaining\n    // and if there are characters left to substitute\n    if (frame.str.length >= 1) {\n      if (\"*\" in frame.node.edges) {\n        var substitutionNode = frame.node.edges[\"*\"]\n      } else {\n        var substitutionNode = new lunr.TokenSet\n        frame.node.edges[\"*\"] = substitutionNode\n      }\n\n      if (frame.str.length == 1) {\n        substitutionNode.final = true\n      }\n\n      stack.push({\n        node: substitutionNode,\n        editsRemaining: frame.editsRemaining - 1,\n        str: frame.str.slice(1)\n      })\n    }\n\n    // transposition\n    // can only do a transposition if there are edits remaining\n    // and there are enough characters to transpose\n    if (frame.str.length > 1) {\n      var charA = frame.str.charAt(0),\n          charB = frame.str.charAt(1),\n          transposeNode\n\n      if (charB in frame.node.edges) {\n        transposeNode = frame.node.edges[charB]\n      } else {\n        transposeNode = new lunr.TokenSet\n        frame.node.edges[charB] = transposeNode\n      }\n\n      if (frame.str.length == 1) {\n        transposeNode.final = true\n      }\n\n      stack.push({\n        node: transposeNode,\n        editsRemaining: frame.editsRemaining - 1,\n        str: charA + frame.str.slice(2)\n      })\n    }\n  }\n\n  return root\n}\n\n/**\n * Creates a TokenSet from a string.\n *\n * The string may contain one or more wildcard characters (*)\n * that will allow wildcard matching when intersecting with\n * another TokenSet.\n *\n * @param {string} str - The string to create a TokenSet from.\n * @returns {lunr.TokenSet}\n */\nlunr.TokenSet.fromString = function (str) {\n  var node = new lunr.TokenSet,\n      root = node\n\n  /*\n   * Iterates through all characters within the passed string\n   * appending a node for each character.\n   *\n   * When a wildcard character is found then a self\n   * referencing edge is introduced to continually match\n   * any number of any characters.\n   */\n  for (var i = 0, len = str.length; i < len; i++) {\n    var char = str[i],\n        final = (i == len - 1)\n\n    if (char == \"*\") {\n      node.edges[char] = node\n      node.final = final\n\n    } else {\n      var next = new lunr.TokenSet\n      next.final = final\n\n      node.edges[char] = next\n      node = next\n    }\n  }\n\n  return root\n}\n\n/**\n * Converts this TokenSet into an array of strings\n * contained within the TokenSet.\n *\n * This is not intended to be used on a TokenSet that\n * contains wildcards, in these cases the results are\n * undefined and are likely to cause an infinite loop.\n *\n * @returns {string[]}\n */\nlunr.TokenSet.prototype.toArray = function () {\n  var words = []\n\n  var stack = [{\n    prefix: \"\",\n    node: this\n  }]\n\n  while (stack.length) {\n    var frame = stack.pop(),\n        edges = Object.keys(frame.node.edges),\n        len = edges.length\n\n    if (frame.node.final) {\n      /* In Safari, at this point the prefix is sometimes corrupted, see:\n       * https://github.com/olivernn/lunr.js/issues/279 Calling any\n       * String.prototype method forces Safari to \"cast\" this string to what\n       * it's supposed to be, fixing the bug. */\n      frame.prefix.charAt(0)\n      words.push(frame.prefix)\n    }\n\n    for (var i = 0; i < len; i++) {\n      var edge = edges[i]\n\n      stack.push({\n        prefix: frame.prefix.concat(edge),\n        node: frame.node.edges[edge]\n      })\n    }\n  }\n\n  return words\n}\n\n/**\n * Generates a string representation of a TokenSet.\n *\n * This is intended to allow TokenSets to be used as keys\n * in objects, largely to aid the construction and minimisation\n * of a TokenSet. As such it is not designed to be a human\n * friendly representation of the TokenSet.\n *\n * @returns {string}\n */\nlunr.TokenSet.prototype.toString = function () {\n  // NOTE: Using Object.keys here as this.edges is very likely\n  // to enter 'hash-mode' with many keys being added\n  //\n  // avoiding a for-in loop here as it leads to the function\n  // being de-optimised (at least in V8). From some simple\n  // benchmarks the performance is comparable, but allowing\n  // V8 to optimize may mean easy performance wins in the future.\n\n  if (this._str) {\n    return this._str\n  }\n\n  var str = this.final ? '1' : '0',\n      labels = Object.keys(this.edges).sort(),\n      len = labels.length\n\n  for (var i = 0; i < len; i++) {\n    var label = labels[i],\n        node = this.edges[label]\n\n    str = str + label + node.id\n  }\n\n  return str\n}\n\n/**\n * Returns a new TokenSet that is the intersection of\n * this TokenSet and the passed TokenSet.\n *\n * This intersection will take into account any wildcards\n * contained within the TokenSet.\n *\n * @param {lunr.TokenSet} b - An other TokenSet to intersect with.\n * @returns {lunr.TokenSet}\n */\nlunr.TokenSet.prototype.intersect = function (b) {\n  var output = new lunr.TokenSet,\n      frame = undefined\n\n  var stack = [{\n    qNode: b,\n    output: output,\n    node: this\n  }]\n\n  while (stack.length) {\n    frame = stack.pop()\n\n    // NOTE: As with the #toString method, we are using\n    // Object.keys and a for loop instead of a for-in loop\n    // as both of these objects enter 'hash' mode, causing\n    // the function to be de-optimised in V8\n    var qEdges = Object.keys(frame.qNode.edges),\n        qLen = qEdges.length,\n        nEdges = Object.keys(frame.node.edges),\n        nLen = nEdges.length\n\n    for (var q = 0; q < qLen; q++) {\n      var qEdge = qEdges[q]\n\n      for (var n = 0; n < nLen; n++) {\n        var nEdge = nEdges[n]\n\n        if (nEdge == qEdge || qEdge == '*') {\n          var node = frame.node.edges[nEdge],\n              qNode = frame.qNode.edges[qEdge],\n              final = node.final && qNode.final,\n              next = undefined\n\n          if (nEdge in frame.output.edges) {\n            // an edge already exists for this character\n            // no need to create a new node, just set the finality\n            // bit unless this node is already final\n            next = frame.output.edges[nEdge]\n            next.final = next.final || final\n\n          } else {\n            // no edge exists yet, must create one\n            // set the finality bit and insert it\n            // into the output\n            next = new lunr.TokenSet\n            next.final = final\n            frame.output.edges[nEdge] = next\n          }\n\n          stack.push({\n            qNode: qNode,\n            output: next,\n            node: node\n          })\n        }\n      }\n    }\n  }\n\n  return output\n}\nlunr.TokenSet.Builder = function () {\n  this.previousWord = \"\"\n  this.root = new lunr.TokenSet\n  this.uncheckedNodes = []\n  this.minimizedNodes = {}\n}\n\nlunr.TokenSet.Builder.prototype.insert = function (word) {\n  var node,\n      commonPrefix = 0\n\n  if (word < this.previousWord) {\n    throw new Error (\"Out of order word insertion\")\n  }\n\n  for (var i = 0; i < word.length && i < this.previousWord.length; i++) {\n    if (word[i] != this.previousWord[i]) break\n    commonPrefix++\n  }\n\n  this.minimize(commonPrefix)\n\n  if (this.uncheckedNodes.length == 0) {\n    node = this.root\n  } else {\n    node = this.uncheckedNodes[this.uncheckedNodes.length - 1].child\n  }\n\n  for (var i = commonPrefix; i < word.length; i++) {\n    var nextNode = new lunr.TokenSet,\n        char = word[i]\n\n    node.edges[char] = nextNode\n\n    this.uncheckedNodes.push({\n      parent: node,\n      char: char,\n      child: nextNode\n    })\n\n    node = nextNode\n  }\n\n  node.final = true\n  this.previousWord = word\n}\n\nlunr.TokenSet.Builder.prototype.finish = function () {\n  this.minimize(0)\n}\n\nlunr.TokenSet.Builder.prototype.minimize = function (downTo) {\n  for (var i = this.uncheckedNodes.length - 1; i >= downTo; i--) {\n    var node = this.uncheckedNodes[i],\n        childKey = node.child.toString()\n\n    if (childKey in this.minimizedNodes) {\n      node.parent.edges[node.char] = this.minimizedNodes[childKey]\n    } else {\n      // Cache the key for this node since\n      // we know it can't change anymore\n      node.child._str = childKey\n\n      this.minimizedNodes[childKey] = node.child\n    }\n\n    this.uncheckedNodes.pop()\n  }\n}\n/*!\n * lunr.Index\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * An index contains the built index of all documents and provides a query interface\n * to the index.\n *\n * Usually instances of lunr.Index will not be created using this constructor, instead\n * lunr.Builder should be used to construct new indexes, or lunr.Index.load should be\n * used to load previously built and serialized indexes.\n *\n * @constructor\n * @param {Object} attrs - The attributes of the built search index.\n * @param {Object} attrs.invertedIndex - An index of term/field to document reference.\n * @param {Object<string, lunr.Vector>} attrs.fieldVectors - Field vectors\n * @param {lunr.TokenSet} attrs.tokenSet - An set of all corpus tokens.\n * @param {string[]} attrs.fields - The names of indexed document fields.\n * @param {lunr.Pipeline} attrs.pipeline - The pipeline to use for search terms.\n */\nlunr.Index = function (attrs) {\n  this.invertedIndex = attrs.invertedIndex\n  this.fieldVectors = attrs.fieldVectors\n  this.tokenSet = attrs.tokenSet\n  this.fields = attrs.fields\n  this.pipeline = attrs.pipeline\n}\n\n/**\n * A result contains details of a document matching a search query.\n * @typedef {Object} lunr.Index~Result\n * @property {string} ref - The reference of the document this result represents.\n * @property {number} score - A number between 0 and 1 representing how similar this document is to the query.\n * @property {lunr.MatchData} matchData - Contains metadata about this match including which term(s) caused the match.\n */\n\n/**\n * Although lunr provides the ability to create queries using lunr.Query, it also provides a simple\n * query language which itself is parsed into an instance of lunr.Query.\n *\n * For programmatically building queries it is advised to directly use lunr.Query, the query language\n * is best used for human entered text rather than program generated text.\n *\n * At its simplest queries can just be a single term, e.g. `hello`, multiple terms are also supported\n * and will be combined with OR, e.g `hello world` will match documents that contain either 'hello'\n * or 'world', though those that contain both will rank higher in the results.\n *\n * Wildcards can be included in terms to match one or more unspecified characters, these wildcards can\n * be inserted anywhere within the term, and more than one wildcard can exist in a single term. Adding\n * wildcards will increase the number of documents that will be found but can also have a negative\n * impact on query performance, especially with wildcards at the beginning of a term.\n *\n * Terms can be restricted to specific fields, e.g. `title:hello`, only documents with the term\n * hello in the title field will match this query. Using a field not present in the index will lead\n * to an error being thrown.\n *\n * Modifiers can also be added to terms, lunr supports edit distance and boost modifiers on terms. A term\n * boost will make documents matching that term score higher, e.g. `foo^5`. Edit distance is also supported\n * to provide fuzzy matching, e.g. 'hello~2' will match documents with hello with an edit distance of 2.\n * Avoid large values for edit distance to improve query performance.\n *\n * Each term also supports a presence modifier. By default a term's presence in document is optional, however\n * this can be changed to either required or prohibited. For a term's presence to be required in a document the\n * term should be prefixed with a '+', e.g. `+foo bar` is a search for documents that must contain 'foo' and\n * optionally contain 'bar'. Conversely a leading '-' sets the terms presence to prohibited, i.e. it must not\n * appear in a document, e.g. `-foo bar` is a search for documents that do not contain 'foo' but may contain 'bar'.\n *\n * To escape special characters the backslash character '\\' can be used, this allows searches to include\n * characters that would normally be considered modifiers, e.g. `foo\\~2` will search for a term \"foo~2\" instead\n * of attempting to apply a boost of 2 to the search term \"foo\".\n *\n * @typedef {string} lunr.Index~QueryString\n * @example <caption>Simple single term query</caption>\n * hello\n * @example <caption>Multiple term query</caption>\n * hello world\n * @example <caption>term scoped to a field</caption>\n * title:hello\n * @example <caption>term with a boost of 10</caption>\n * hello^10\n * @example <caption>term with an edit distance of 2</caption>\n * hello~2\n * @example <caption>terms with presence modifiers</caption>\n * -foo +bar baz\n */\n\n/**\n * Performs a search against the index using lunr query syntax.\n *\n * Results will be returned sorted by their score, the most relevant results\n * will be returned first.  For details on how the score is calculated, please see\n * the {@link https://lunrjs.com/guides/searching.html#scoring|guide}.\n *\n * For more programmatic querying use lunr.Index#query.\n *\n * @param {lunr.Index~QueryString} queryString - A string containing a lunr query.\n * @throws {lunr.QueryParseError} If the passed query string cannot be parsed.\n * @returns {lunr.Index~Result[]}\n */\nlunr.Index.prototype.search = function (queryString) {\n  return this.query(function (query) {\n    var parser = new lunr.QueryParser(queryString, query)\n    parser.parse()\n  })\n}\n\n/**\n * A query builder callback provides a query object to be used to express\n * the query to perform on the index.\n *\n * @callback lunr.Index~queryBuilder\n * @param {lunr.Query} query - The query object to build up.\n * @this lunr.Query\n */\n\n/**\n * Performs a query against the index using the yielded lunr.Query object.\n *\n * If performing programmatic queries against the index, this method is preferred\n * over lunr.Index#search so as to avoid the additional query parsing overhead.\n *\n * A query object is yielded to the supplied function which should be used to\n * express the query to be run against the index.\n *\n * Note that although this function takes a callback parameter it is _not_ an\n * asynchronous operation, the callback is just yielded a query object to be\n * customized.\n *\n * @param {lunr.Index~queryBuilder} fn - A function that is used to build the query.\n * @returns {lunr.Index~Result[]}\n */\nlunr.Index.prototype.query = function (fn) {\n  // for each query clause\n  // * process terms\n  // * expand terms from token set\n  // * find matching documents and metadata\n  // * get document vectors\n  // * score documents\n\n  var query = new lunr.Query(this.fields),\n      matchingFields = Object.create(null),\n      queryVectors = Object.create(null),\n      termFieldCache = Object.create(null),\n      requiredMatches = Object.create(null),\n      prohibitedMatches = Object.create(null)\n\n  /*\n   * To support field level boosts a query vector is created per\n   * field. An empty vector is eagerly created to support negated\n   * queries.\n   */\n  for (var i = 0; i < this.fields.length; i++) {\n    queryVectors[this.fields[i]] = new lunr.Vector\n  }\n\n  fn.call(query, query)\n\n  for (var i = 0; i < query.clauses.length; i++) {\n    /*\n     * Unless the pipeline has been disabled for this term, which is\n     * the case for terms with wildcards, we need to pass the clause\n     * term through the search pipeline. A pipeline returns an array\n     * of processed terms. Pipeline functions may expand the passed\n     * term, which means we may end up performing multiple index lookups\n     * for a single query term.\n     */\n    var clause = query.clauses[i],\n        terms = null,\n        clauseMatches = lunr.Set.empty\n\n    if (clause.usePipeline) {\n      terms = this.pipeline.runString(clause.term, {\n        fields: clause.fields\n      })\n    } else {\n      terms = [clause.term]\n    }\n\n    for (var m = 0; m < terms.length; m++) {\n      var term = terms[m]\n\n      /*\n       * Each term returned from the pipeline needs to use the same query\n       * clause object, e.g. the same boost and or edit distance. The\n       * simplest way to do this is to re-use the clause object but mutate\n       * its term property.\n       */\n      clause.term = term\n\n      /*\n       * From the term in the clause we create a token set which will then\n       * be used to intersect the indexes token set to get a list of terms\n       * to lookup in the inverted index\n       */\n      var termTokenSet = lunr.TokenSet.fromClause(clause),\n          expandedTerms = this.tokenSet.intersect(termTokenSet).toArray()\n\n      /*\n       * If a term marked as required does not exist in the tokenSet it is\n       * impossible for the search to return any matches. We set all the field\n       * scoped required matches set to empty and stop examining any further\n       * clauses.\n       */\n      if (expandedTerms.length === 0 && clause.presence === lunr.Query.presence.REQUIRED) {\n        for (var k = 0; k < clause.fields.length; k++) {\n          var field = clause.fields[k]\n          requiredMatches[field] = lunr.Set.empty\n        }\n\n        break\n      }\n\n      for (var j = 0; j < expandedTerms.length; j++) {\n        /*\n         * For each term get the posting and termIndex, this is required for\n         * building the query vector.\n         */\n        var expandedTerm = expandedTerms[j],\n            posting = this.invertedIndex[expandedTerm],\n            termIndex = posting._index\n\n        for (var k = 0; k < clause.fields.length; k++) {\n          /*\n           * For each field that this query term is scoped by (by default\n           * all fields are in scope) we need to get all the document refs\n           * that have this term in that field.\n           *\n           * The posting is the entry in the invertedIndex for the matching\n           * term from above.\n           */\n          var field = clause.fields[k],\n              fieldPosting = posting[field],\n              matchingDocumentRefs = Object.keys(fieldPosting),\n              termField = expandedTerm + \"/\" + field,\n              matchingDocumentsSet = new lunr.Set(matchingDocumentRefs)\n\n          /*\n           * if the presence of this term is required ensure that the matching\n           * documents are added to the set of required matches for this clause.\n           *\n           */\n          if (clause.presence == lunr.Query.presence.REQUIRED) {\n            clauseMatches = clauseMatches.union(matchingDocumentsSet)\n\n            if (requiredMatches[field] === undefined) {\n              requiredMatches[field] = lunr.Set.complete\n            }\n          }\n\n          /*\n           * if the presence of this term is prohibited ensure that the matching\n           * documents are added to the set of prohibited matches for this field,\n           * creating that set if it does not yet exist.\n           */\n          if (clause.presence == lunr.Query.presence.PROHIBITED) {\n            if (prohibitedMatches[field] === undefined) {\n              prohibitedMatches[field] = lunr.Set.empty\n            }\n\n            prohibitedMatches[field] = prohibitedMatches[field].union(matchingDocumentsSet)\n\n            /*\n             * Prohibited matches should not be part of the query vector used for\n             * similarity scoring and no metadata should be extracted so we continue\n             * to the next field\n             */\n            continue\n          }\n\n          /*\n           * The query field vector is populated using the termIndex found for\n           * the term and a unit value with the appropriate boost applied.\n           * Using upsert because there could already be an entry in the vector\n           * for the term we are working with. In that case we just add the scores\n           * together.\n           */\n          queryVectors[field].upsert(termIndex, clause.boost, function (a, b) { return a + b })\n\n          /**\n           * If we've already seen this term, field combo then we've already collected\n           * the matching documents and metadata, no need to go through all that again\n           */\n          if (termFieldCache[termField]) {\n            continue\n          }\n\n          for (var l = 0; l < matchingDocumentRefs.length; l++) {\n            /*\n             * All metadata for this term/field/document triple\n             * are then extracted and collected into an instance\n             * of lunr.MatchData ready to be returned in the query\n             * results\n             */\n            var matchingDocumentRef = matchingDocumentRefs[l],\n                matchingFieldRef = new lunr.FieldRef (matchingDocumentRef, field),\n                metadata = fieldPosting[matchingDocumentRef],\n                fieldMatch\n\n            if ((fieldMatch = matchingFields[matchingFieldRef]) === undefined) {\n              matchingFields[matchingFieldRef] = new lunr.MatchData (expandedTerm, field, metadata)\n            } else {\n              fieldMatch.add(expandedTerm, field, metadata)\n            }\n\n          }\n\n          termFieldCache[termField] = true\n        }\n      }\n    }\n\n    /**\n     * If the presence was required we need to update the requiredMatches field sets.\n     * We do this after all fields for the term have collected their matches because\n     * the clause terms presence is required in _any_ of the fields not _all_ of the\n     * fields.\n     */\n    if (clause.presence === lunr.Query.presence.REQUIRED) {\n      for (var k = 0; k < clause.fields.length; k++) {\n        var field = clause.fields[k]\n        requiredMatches[field] = requiredMatches[field].intersect(clauseMatches)\n      }\n    }\n  }\n\n  /**\n   * Need to combine the field scoped required and prohibited\n   * matching documents into a global set of required and prohibited\n   * matches\n   */\n  var allRequiredMatches = lunr.Set.complete,\n      allProhibitedMatches = lunr.Set.empty\n\n  for (var i = 0; i < this.fields.length; i++) {\n    var field = this.fields[i]\n\n    if (requiredMatches[field]) {\n      allRequiredMatches = allRequiredMatches.intersect(requiredMatches[field])\n    }\n\n    if (prohibitedMatches[field]) {\n      allProhibitedMatches = allProhibitedMatches.union(prohibitedMatches[field])\n    }\n  }\n\n  var matchingFieldRefs = Object.keys(matchingFields),\n      results = [],\n      matches = Object.create(null)\n\n  /*\n   * If the query is negated (contains only prohibited terms)\n   * we need to get _all_ fieldRefs currently existing in the\n   * index. This is only done when we know that the query is\n   * entirely prohibited terms to avoid any cost of getting all\n   * fieldRefs unnecessarily.\n   *\n   * Additionally, blank MatchData must be created to correctly\n   * populate the results.\n   */\n  if (query.isNegated()) {\n    matchingFieldRefs = Object.keys(this.fieldVectors)\n\n    for (var i = 0; i < matchingFieldRefs.length; i++) {\n      var matchingFieldRef = matchingFieldRefs[i]\n      var fieldRef = lunr.FieldRef.fromString(matchingFieldRef)\n      matchingFields[matchingFieldRef] = new lunr.MatchData\n    }\n  }\n\n  for (var i = 0; i < matchingFieldRefs.length; i++) {\n    /*\n     * Currently we have document fields that match the query, but we\n     * need to return documents. The matchData and scores are combined\n     * from multiple fields belonging to the same document.\n     *\n     * Scores are calculated by field, using the query vectors created\n     * above, and combined into a final document score using addition.\n     */\n    var fieldRef = lunr.FieldRef.fromString(matchingFieldRefs[i]),\n        docRef = fieldRef.docRef\n\n    if (!allRequiredMatches.contains(docRef)) {\n      continue\n    }\n\n    if (allProhibitedMatches.contains(docRef)) {\n      continue\n    }\n\n    var fieldVector = this.fieldVectors[fieldRef],\n        score = queryVectors[fieldRef.fieldName].similarity(fieldVector),\n        docMatch\n\n    if ((docMatch = matches[docRef]) !== undefined) {\n      docMatch.score += score\n      docMatch.matchData.combine(matchingFields[fieldRef])\n    } else {\n      var match = {\n        ref: docRef,\n        score: score,\n        matchData: matchingFields[fieldRef]\n      }\n      matches[docRef] = match\n      results.push(match)\n    }\n  }\n\n  /*\n   * Sort the results objects by score, highest first.\n   */\n  return results.sort(function (a, b) {\n    return b.score - a.score\n  })\n}\n\n/**\n * Prepares the index for JSON serialization.\n *\n * The schema for this JSON blob will be described in a\n * separate JSON schema file.\n *\n * @returns {Object}\n */\nlunr.Index.prototype.toJSON = function () {\n  var invertedIndex = Object.keys(this.invertedIndex)\n    .sort()\n    .map(function (term) {\n      return [term, this.invertedIndex[term]]\n    }, this)\n\n  var fieldVectors = Object.keys(this.fieldVectors)\n    .map(function (ref) {\n      return [ref, this.fieldVectors[ref].toJSON()]\n    }, this)\n\n  return {\n    version: lunr.version,\n    fields: this.fields,\n    fieldVectors: fieldVectors,\n    invertedIndex: invertedIndex,\n    pipeline: this.pipeline.toJSON()\n  }\n}\n\n/**\n * Loads a previously serialized lunr.Index\n *\n * @param {Object} serializedIndex - A previously serialized lunr.Index\n * @returns {lunr.Index}\n */\nlunr.Index.load = function (serializedIndex) {\n  var attrs = {},\n      fieldVectors = {},\n      serializedVectors = serializedIndex.fieldVectors,\n      invertedIndex = Object.create(null),\n      serializedInvertedIndex = serializedIndex.invertedIndex,\n      tokenSetBuilder = new lunr.TokenSet.Builder,\n      pipeline = lunr.Pipeline.load(serializedIndex.pipeline)\n\n  if (serializedIndex.version != lunr.version) {\n    lunr.utils.warn(\"Version mismatch when loading serialised index. Current version of lunr '\" + lunr.version + \"' does not match serialized index '\" + serializedIndex.version + \"'\")\n  }\n\n  for (var i = 0; i < serializedVectors.length; i++) {\n    var tuple = serializedVectors[i],\n        ref = tuple[0],\n        elements = tuple[1]\n\n    fieldVectors[ref] = new lunr.Vector(elements)\n  }\n\n  for (var i = 0; i < serializedInvertedIndex.length; i++) {\n    var tuple = serializedInvertedIndex[i],\n        term = tuple[0],\n        posting = tuple[1]\n\n    tokenSetBuilder.insert(term)\n    invertedIndex[term] = posting\n  }\n\n  tokenSetBuilder.finish()\n\n  attrs.fields = serializedIndex.fields\n\n  attrs.fieldVectors = fieldVectors\n  attrs.invertedIndex = invertedIndex\n  attrs.tokenSet = tokenSetBuilder.root\n  attrs.pipeline = pipeline\n\n  return new lunr.Index(attrs)\n}\n/*!\n * lunr.Builder\n * Copyright (C) 2020 Oliver Nightingale\n */\n\n/**\n * lunr.Builder performs indexing on a set of documents and\n * returns instances of lunr.Index ready for querying.\n *\n * All configuration of the index is done via the builder, the\n * fields to index, the document reference, the text processing\n * pipeline and document scoring parameters are all set on the\n * builder before indexing.\n *\n * @constructor\n * @property {string} _ref - Internal reference to the document reference field.\n * @property {string[]} _fields - Internal reference to the document fields to index.\n * @property {object} invertedIndex - The inverted index maps terms to document fields.\n * @property {object} documentTermFrequencies - Keeps track of document term frequencies.\n * @property {object} documentLengths - Keeps track of the length of documents added to the index.\n * @property {lunr.tokenizer} tokenizer - Function for splitting strings into tokens for indexing.\n * @property {lunr.Pipeline} pipeline - The pipeline performs text processing on tokens before indexing.\n * @property {lunr.Pipeline} searchPipeline - A pipeline for processing search terms before querying the index.\n * @property {number} documentCount - Keeps track of the total number of documents indexed.\n * @property {number} _b - A parameter to control field length normalization, setting this to 0 disabled normalization, 1 fully normalizes field lengths, the default value is 0.75.\n * @property {number} _k1 - A parameter to control how quickly an increase in term frequency results in term frequency saturation, the default value is 1.2.\n * @property {number} termIndex - A counter incremented for each unique term, used to identify a terms position in the vector space.\n * @property {array} metadataWhitelist - A list of metadata keys that have been whitelisted for entry in the index.\n */\nlunr.Builder = function () {\n  this._ref = \"id\"\n  this._fields = Object.create(null)\n  this._documents = Object.create(null)\n  this.invertedIndex = Object.create(null)\n  this.fieldTermFrequencies = {}\n  this.fieldLengths = {}\n  this.tokenizer = lunr.tokenizer\n  this.pipeline = new lunr.Pipeline\n  this.searchPipeline = new lunr.Pipeline\n  this.documentCount = 0\n  this._b = 0.75\n  this._k1 = 1.2\n  this.termIndex = 0\n  this.metadataWhitelist = []\n}\n\n/**\n * Sets the document field used as the document reference. Every document must have this field.\n * The type of this field in the document should be a string, if it is not a string it will be\n * coerced into a string by calling toString.\n *\n * The default ref is 'id'.\n *\n * The ref should _not_ be changed during indexing, it should be set before any documents are\n * added to the index. Changing it during indexing can lead to inconsistent results.\n *\n * @param {string} ref - The name of the reference field in the document.\n */\nlunr.Builder.prototype.ref = function (ref) {\n  this._ref = ref\n}\n\n/**\n * A function that is used to extract a field from a document.\n *\n * Lunr expects a field to be at the top level of a document, if however the field\n * is deeply nested within a document an extractor function can be used to extract\n * the right field for indexing.\n *\n * @callback fieldExtractor\n * @param {object} doc - The document being added to the index.\n * @returns {?(string|object|object[])} obj - The object that will be indexed for this field.\n * @example <caption>Extracting a nested field</caption>\n * function (doc) { return doc.nested.field }\n */\n\n/**\n * Adds a field to the list of document fields that will be indexed. Every document being\n * indexed should have this field. Null values for this field in indexed documents will\n * not cause errors but will limit the chance of that document being retrieved by searches.\n *\n * All fields should be added before adding documents to the index. Adding fields after\n * a document has been indexed will have no effect on already indexed documents.\n *\n * Fields can be boosted at build time. This allows terms within that field to have more\n * importance when ranking search results. Use a field boost to specify that matches within\n * one field are more important than other fields.\n *\n * @param {string} fieldName - The name of a field to index in all documents.\n * @param {object} attributes - Optional attributes associated with this field.\n * @param {number} [attributes.boost=1] - Boost applied to all terms within this field.\n * @param {fieldExtractor} [attributes.extractor] - Function to extract a field from a document.\n * @throws {RangeError} fieldName cannot contain unsupported characters '/'\n */\nlunr.Builder.prototype.field = function (fieldName, attributes) {\n  if (/\\//.test(fieldName)) {\n    throw new RangeError (\"Field '\" + fieldName + \"' contains illegal character '/'\")\n  }\n\n  this._fields[fieldName] = attributes || {}\n}\n\n/**\n * A parameter to tune the amount of field length normalisation that is applied when\n * calculating relevance scores. A value of 0 will completely disable any normalisation\n * and a value of 1 will fully normalise field lengths. The default is 0.75. Values of b\n * will be clamped to the range 0 - 1.\n *\n * @param {number} number - The value to set for this tuning parameter.\n */\nlunr.Builder.prototype.b = function (number) {\n  if (number < 0) {\n    this._b = 0\n  } else if (number > 1) {\n    this._b = 1\n  } else {\n    this._b = number\n  }\n}\n\n/**\n * A parameter that controls the speed at which a rise in term frequency results in term\n * frequency saturation. The default value is 1.2. Setting this to a higher value will give\n * slower saturation levels, a lower value will result in quicker saturation.\n *\n * @param {number} number - The value to set for this tuning parameter.\n */\nlunr.Builder.prototype.k1 = function (number) {\n  this._k1 = number\n}\n\n/**\n * Adds a document to the index.\n *\n * Before adding fields to the index the index should have been fully setup, with the document\n * ref and all fields to index already having been specified.\n *\n * The document must have a field name as specified by the ref (by default this is 'id') and\n * it should have all fields defined for indexing, though null or undefined values will not\n * cause errors.\n *\n * Entire documents can be boosted at build time. Applying a boost to a document indicates that\n * this document should rank higher in search results than other documents.\n *\n * @param {object} doc - The document to add to the index.\n * @param {object} attributes - Optional attributes associated with this document.\n * @param {number} [attributes.boost=1] - Boost applied to all terms within this document.\n */\nlunr.Builder.prototype.add = function (doc, attributes) {\n  var docRef = doc[this._ref],\n      fields = Object.keys(this._fields)\n\n  this._documents[docRef] = attributes || {}\n  this.documentCount += 1\n\n  for (var i = 0; i < fields.length; i++) {\n    var fieldName = fields[i],\n        extractor = this._fields[fieldName].extractor,\n        field = extractor ? extractor(doc) : doc[fieldName],\n        tokens = this.tokenizer(field, {\n          fields: [fieldName]\n        }),\n        terms = this.pipeline.run(tokens),\n        fieldRef = new lunr.FieldRef (docRef, fieldName),\n        fieldTerms = Object.create(null)\n\n    this.fieldTermFrequencies[fieldRef] = fieldTerms\n    this.fieldLengths[fieldRef] = 0\n\n    // store the length of this field for this document\n    this.fieldLengths[fieldRef] += terms.length\n\n    // calculate term frequencies for this field\n    for (var j = 0; j < terms.length; j++) {\n      var term = terms[j]\n\n      if (fieldTerms[term] == undefined) {\n        fieldTerms[term] = 0\n      }\n\n      fieldTerms[term] += 1\n\n      // add to inverted index\n      // create an initial posting if one doesn't exist\n      if (this.invertedIndex[term] == undefined) {\n        var posting = Object.create(null)\n        posting[\"_index\"] = this.termIndex\n        this.termIndex += 1\n\n        for (var k = 0; k < fields.length; k++) {\n          posting[fields[k]] = Object.create(null)\n        }\n\n        this.invertedIndex[term] = posting\n      }\n\n      // add an entry for this term/fieldName/docRef to the invertedIndex\n      if (this.invertedIndex[term][fieldName][docRef] == undefined) {\n        this.invertedIndex[term][fieldName][docRef] = Object.create(null)\n      }\n\n      // store all whitelisted metadata about this token in the\n      // inverted index\n      for (var l = 0; l < this.metadataWhitelist.length; l++) {\n        var metadataKey = this.metadataWhitelist[l],\n            metadata = term.metadata[metadataKey]\n\n        if (this.invertedIndex[term][fieldName][docRef][metadataKey] == undefined) {\n          this.invertedIndex[term][fieldName][docRef][metadataKey] = []\n        }\n\n        this.invertedIndex[term][fieldName][docRef][metadataKey].push(metadata)\n      }\n    }\n\n  }\n}\n\n/**\n * Calculates the average document length for this index\n *\n * @private\n */\nlunr.Builder.prototype.calculateAverageFieldLengths = function () {\n\n  var fieldRefs = Object.keys(this.fieldLengths),\n      numberOfFields = fieldRefs.length,\n      accumulator = {},\n      documentsWithField = {}\n\n  for (var i = 0; i < numberOfFields; i++) {\n    var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        field = fieldRef.fieldName\n\n    documentsWithField[field] || (documentsWithField[field] = 0)\n    documentsWithField[field] += 1\n\n    accumulator[field] || (accumulator[field] = 0)\n    accumulator[field] += this.fieldLengths[fieldRef]\n  }\n\n  var fields = Object.keys(this._fields)\n\n  for (var i = 0; i < fields.length; i++) {\n    var fieldName = fields[i]\n    accumulator[fieldName] = accumulator[fieldName] / documentsWithField[fieldName]\n  }\n\n  this.averageFieldLength = accumulator\n}\n\n/**\n * Builds a vector space model of every document using lunr.Vector\n *\n * @private\n */\nlunr.Builder.prototype.createFieldVectors = function () {\n  var fieldVectors = {},\n      fieldRefs = Object.keys(this.fieldTermFrequencies),\n      fieldRefsLength = fieldRefs.length,\n      termIdfCache = Object.create(null)\n\n  for (var i = 0; i < fieldRefsLength; i++) {\n    var fieldRef = lunr.FieldRef.fromString(fieldRefs[i]),\n        fieldName = fieldRef.fieldName,\n        fieldLength = this.fieldLengths[fieldRef],\n        fieldVector = new lunr.Vector,\n        termFrequencies = this.fieldTermFrequencies[fieldRef],\n        terms = Object.keys(termFrequencies),\n        termsLength = terms.length\n\n\n    var fieldBoost = this._fields[fieldName].boost || 1,\n        docBoost = this._documents[fieldRef.docRef].boost || 1\n\n    for (var j = 0; j < termsLength; j++) {\n      var term = terms[j],\n          tf = termFrequencies[term],\n          termIndex = this.invertedIndex[term]._index,\n          idf, score, scoreWithPrecision\n\n      if (termIdfCache[term] === undefined) {\n        idf = lunr.idf(this.invertedIndex[term], this.documentCount)\n        termIdfCache[term] = idf\n      } else {\n        idf = termIdfCache[term]\n      }\n\n      score = idf * ((this._k1 + 1) * tf) / (this._k1 * (1 - this._b + this._b * (fieldLength / this.averageFieldLength[fieldName])) + tf)\n      score *= fieldBoost\n      score *= docBoost\n      scoreWithPrecision = Math.round(score * 1000) / 1000\n      // Converts 1.23456789 to 1.234.\n      // Reducing the precision so that the vectors take up less\n      // space when serialised. Doing it now so that they behave\n      // the same before and after serialisation. Also, this is\n      // the fastest approach to reducing a number's precision in\n      // JavaScript.\n\n      fieldVector.insert(termIndex, scoreWithPrecision)\n    }\n\n    fieldVectors[fieldRef] = fieldVector\n  }\n\n  this.fieldVectors = fieldVectors\n}\n\n/**\n * Creates a token set of all tokens in the index using lunr.TokenSet\n *\n * @private\n */\nlunr.Builder.prototype.createTokenSet = function () {\n  this.tokenSet = lunr.TokenSet.fromArray(\n    Object.keys(this.invertedIndex).sort()\n  )\n}\n\n/**\n * Builds the index, creating an instance of lunr.Index.\n *\n * This completes the indexing process and should only be called\n * once all documents have been added to the index.\n *\n * @returns {lunr.Index}\n */\nlunr.Builder.prototype.build = function () {\n  this.calculateAverageFieldLengths()\n  this.createFieldVectors()\n  this.createTokenSet()\n\n  return new lunr.Index({\n    invertedIndex: this.invertedIndex,\n    fieldVectors: this.fieldVectors,\n    tokenSet: this.tokenSet,\n    fields: Object.keys(this._fields),\n    pipeline: this.searchPipeline\n  })\n}\n\n/**\n * Applies a plugin to the index builder.\n *\n * A plugin is a function that is called with the index builder as its context.\n * Plugins can be used to customise or extend the behaviour of the index\n * in some way. A plugin is just a function, that encapsulated the custom\n * behaviour that should be applied when building the index.\n *\n * The plugin function will be called with the index builder as its argument, additional\n * arguments can also be passed when calling use. The function will be called\n * with the index builder as its context.\n *\n * @param {Function} plugin The plugin to apply.\n */\nlunr.Builder.prototype.use = function (fn) {\n  var args = Array.prototype.slice.call(arguments, 1)\n  args.unshift(this)\n  fn.apply(this, args)\n}\n/**\n * Contains and collects metadata about a matching document.\n * A single instance of lunr.MatchData is returned as part of every\n * lunr.Index~Result.\n *\n * @constructor\n * @param {string} term - The term this match data is associated with\n * @param {string} field - The field in which the term was found\n * @param {object} metadata - The metadata recorded about this term in this field\n * @property {object} metadata - A cloned collection of metadata associated with this document.\n * @see {@link lunr.Index~Result}\n */\nlunr.MatchData = function (term, field, metadata) {\n  var clonedMetadata = Object.create(null),\n      metadataKeys = Object.keys(metadata || {})\n\n  // Cloning the metadata to prevent the original\n  // being mutated during match data combination.\n  // Metadata is kept in an array within the inverted\n  // index so cloning the data can be done with\n  // Array#slice\n  for (var i = 0; i < metadataKeys.length; i++) {\n    var key = metadataKeys[i]\n    clonedMetadata[key] = metadata[key].slice()\n  }\n\n  this.metadata = Object.create(null)\n\n  if (term !== undefined) {\n    this.metadata[term] = Object.create(null)\n    this.metadata[term][field] = clonedMetadata\n  }\n}\n\n/**\n * An instance of lunr.MatchData will be created for every term that matches a\n * document. However only one instance is required in a lunr.Index~Result. This\n * method combines metadata from another instance of lunr.MatchData with this\n * objects metadata.\n *\n * @param {lunr.MatchData} otherMatchData - Another instance of match data to merge with this one.\n * @see {@link lunr.Index~Result}\n */\nlunr.MatchData.prototype.combine = function (otherMatchData) {\n  var terms = Object.keys(otherMatchData.metadata)\n\n  for (var i = 0; i < terms.length; i++) {\n    var term = terms[i],\n        fields = Object.keys(otherMatchData.metadata[term])\n\n    if (this.metadata[term] == undefined) {\n      this.metadata[term] = Object.create(null)\n    }\n\n    for (var j = 0; j < fields.length; j++) {\n      var field = fields[j],\n          keys = Object.keys(otherMatchData.metadata[term][field])\n\n      if (this.metadata[term][field] == undefined) {\n        this.metadata[term][field] = Object.create(null)\n      }\n\n      for (var k = 0; k < keys.length; k++) {\n        var key = keys[k]\n\n        if (this.metadata[term][field][key] == undefined) {\n          this.metadata[term][field][key] = otherMatchData.metadata[term][field][key]\n        } else {\n          this.metadata[term][field][key] = this.metadata[term][field][key].concat(otherMatchData.metadata[term][field][key])\n        }\n\n      }\n    }\n  }\n}\n\n/**\n * Add metadata for a term/field pair to this instance of match data.\n *\n * @param {string} term - The term this match data is associated with\n * @param {string} field - The field in which the term was found\n * @param {object} metadata - The metadata recorded about this term in this field\n */\nlunr.MatchData.prototype.add = function (term, field, metadata) {\n  if (!(term in this.metadata)) {\n    this.metadata[term] = Object.create(null)\n    this.metadata[term][field] = metadata\n    return\n  }\n\n  if (!(field in this.metadata[term])) {\n    this.metadata[term][field] = metadata\n    return\n  }\n\n  var metadataKeys = Object.keys(metadata)\n\n  for (var i = 0; i < metadataKeys.length; i++) {\n    var key = metadataKeys[i]\n\n    if (key in this.metadata[term][field]) {\n      this.metadata[term][field][key] = this.metadata[term][field][key].concat(metadata[key])\n    } else {\n      this.metadata[term][field][key] = metadata[key]\n    }\n  }\n}\n/**\n * A lunr.Query provides a programmatic way of defining queries to be performed\n * against a {@link lunr.Index}.\n *\n * Prefer constructing a lunr.Query using the {@link lunr.Index#query} method\n * so the query object is pre-initialized with the right index fields.\n *\n * @constructor\n * @property {lunr.Query~Clause[]} clauses - An array of query clauses.\n * @property {string[]} allFields - An array of all available fields in a lunr.Index.\n */\nlunr.Query = function (allFields) {\n  this.clauses = []\n  this.allFields = allFields\n}\n\n/**\n * Constants for indicating what kind of automatic wildcard insertion will be used when constructing a query clause.\n *\n * This allows wildcards to be added to the beginning and end of a term without having to manually do any string\n * concatenation.\n *\n * The wildcard constants can be bitwise combined to select both leading and trailing wildcards.\n *\n * @constant\n * @default\n * @property {number} wildcard.NONE - The term will have no wildcards inserted, this is the default behaviour\n * @property {number} wildcard.LEADING - Prepend the term with a wildcard, unless a leading wildcard already exists\n * @property {number} wildcard.TRAILING - Append a wildcard to the term, unless a trailing wildcard already exists\n * @see lunr.Query~Clause\n * @see lunr.Query#clause\n * @see lunr.Query#term\n * @example <caption>query term with trailing wildcard</caption>\n * query.term('foo', { wildcard: lunr.Query.wildcard.TRAILING })\n * @example <caption>query term with leading and trailing wildcard</caption>\n * query.term('foo', {\n *   wildcard: lunr.Query.wildcard.LEADING | lunr.Query.wildcard.TRAILING\n * })\n */\n\nlunr.Query.wildcard = new String (\"*\")\nlunr.Query.wildcard.NONE = 0\nlunr.Query.wildcard.LEADING = 1\nlunr.Query.wildcard.TRAILING = 2\n\n/**\n * Constants for indicating what kind of presence a term must have in matching documents.\n *\n * @constant\n * @enum {number}\n * @see lunr.Query~Clause\n * @see lunr.Query#clause\n * @see lunr.Query#term\n * @example <caption>query term with required presence</caption>\n * query.term('foo', { presence: lunr.Query.presence.REQUIRED })\n */\nlunr.Query.presence = {\n  /**\n   * Term's presence in a document is optional, this is the default value.\n   */\n  OPTIONAL: 1,\n\n  /**\n   * Term's presence in a document is required, documents that do not contain\n   * this term will not be returned.\n   */\n  REQUIRED: 2,\n\n  /**\n   * Term's presence in a document is prohibited, documents that do contain\n   * this term will not be returned.\n   */\n  PROHIBITED: 3\n}\n\n/**\n * A single clause in a {@link lunr.Query} contains a term and details on how to\n * match that term against a {@link lunr.Index}.\n *\n * @typedef {Object} lunr.Query~Clause\n * @property {string[]} fields - The fields in an index this clause should be matched against.\n * @property {number} [boost=1] - Any boost that should be applied when matching this clause.\n * @property {number} [editDistance] - Whether the term should have fuzzy matching applied, and how fuzzy the match should be.\n * @property {boolean} [usePipeline] - Whether the term should be passed through the search pipeline.\n * @property {number} [wildcard=lunr.Query.wildcard.NONE] - Whether the term should have wildcards appended or prepended.\n * @property {number} [presence=lunr.Query.presence.OPTIONAL] - The terms presence in any matching documents.\n */\n\n/**\n * Adds a {@link lunr.Query~Clause} to this query.\n *\n * Unless the clause contains the fields to be matched all fields will be matched. In addition\n * a default boost of 1 is applied to the clause.\n *\n * @param {lunr.Query~Clause} clause - The clause to add to this query.\n * @see lunr.Query~Clause\n * @returns {lunr.Query}\n */\nlunr.Query.prototype.clause = function (clause) {\n  if (!('fields' in clause)) {\n    clause.fields = this.allFields\n  }\n\n  if (!('boost' in clause)) {\n    clause.boost = 1\n  }\n\n  if (!('usePipeline' in clause)) {\n    clause.usePipeline = true\n  }\n\n  if (!('wildcard' in clause)) {\n    clause.wildcard = lunr.Query.wildcard.NONE\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.LEADING) && (clause.term.charAt(0) != lunr.Query.wildcard)) {\n    clause.term = \"*\" + clause.term\n  }\n\n  if ((clause.wildcard & lunr.Query.wildcard.TRAILING) && (clause.term.slice(-1) != lunr.Query.wildcard)) {\n    clause.term = \"\" + clause.term + \"*\"\n  }\n\n  if (!('presence' in clause)) {\n    clause.presence = lunr.Query.presence.OPTIONAL\n  }\n\n  this.clauses.push(clause)\n\n  return this\n}\n\n/**\n * A negated query is one in which every clause has a presence of\n * prohibited. These queries require some special processing to return\n * the expected results.\n *\n * @returns boolean\n */\nlunr.Query.prototype.isNegated = function () {\n  for (var i = 0; i < this.clauses.length; i++) {\n    if (this.clauses[i].presence != lunr.Query.presence.PROHIBITED) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * Adds a term to the current query, under the covers this will create a {@link lunr.Query~Clause}\n * to the list of clauses that make up this query.\n *\n * The term is used as is, i.e. no tokenization will be performed by this method. Instead conversion\n * to a token or token-like string should be done before calling this method.\n *\n * The term will be converted to a string by calling `toString`. Multiple terms can be passed as an\n * array, each term in the array will share the same options.\n *\n * @param {object|object[]} term - The term(s) to add to the query.\n * @param {object} [options] - Any additional properties to add to the query clause.\n * @returns {lunr.Query}\n * @see lunr.Query#clause\n * @see lunr.Query~Clause\n * @example <caption>adding a single term to a query</caption>\n * query.term(\"foo\")\n * @example <caption>adding a single term to a query and specifying search fields, term boost and automatic trailing wildcard</caption>\n * query.term(\"foo\", {\n *   fields: [\"title\"],\n *   boost: 10,\n *   wildcard: lunr.Query.wildcard.TRAILING\n * })\n * @example <caption>using lunr.tokenizer to convert a string to tokens before using them as terms</caption>\n * query.term(lunr.tokenizer(\"foo bar\"))\n */\nlunr.Query.prototype.term = function (term, options) {\n  if (Array.isArray(term)) {\n    term.forEach(function (t) { this.term(t, lunr.utils.clone(options)) }, this)\n    return this\n  }\n\n  var clause = options || {}\n  clause.term = term.toString()\n\n  this.clause(clause)\n\n  return this\n}\nlunr.QueryParseError = function (message, start, end) {\n  this.name = \"QueryParseError\"\n  this.message = message\n  this.start = start\n  this.end = end\n}\n\nlunr.QueryParseError.prototype = new Error\nlunr.QueryLexer = function (str) {\n  this.lexemes = []\n  this.str = str\n  this.length = str.length\n  this.pos = 0\n  this.start = 0\n  this.escapeCharPositions = []\n}\n\nlunr.QueryLexer.prototype.run = function () {\n  var state = lunr.QueryLexer.lexText\n\n  while (state) {\n    state = state(this)\n  }\n}\n\nlunr.QueryLexer.prototype.sliceString = function () {\n  var subSlices = [],\n      sliceStart = this.start,\n      sliceEnd = this.pos\n\n  for (var i = 0; i < this.escapeCharPositions.length; i++) {\n    sliceEnd = this.escapeCharPositions[i]\n    subSlices.push(this.str.slice(sliceStart, sliceEnd))\n    sliceStart = sliceEnd + 1\n  }\n\n  subSlices.push(this.str.slice(sliceStart, this.pos))\n  this.escapeCharPositions.length = 0\n\n  return subSlices.join('')\n}\n\nlunr.QueryLexer.prototype.emit = function (type) {\n  this.lexemes.push({\n    type: type,\n    str: this.sliceString(),\n    start: this.start,\n    end: this.pos\n  })\n\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.escapeCharacter = function () {\n  this.escapeCharPositions.push(this.pos - 1)\n  this.pos += 1\n}\n\nlunr.QueryLexer.prototype.next = function () {\n  if (this.pos >= this.length) {\n    return lunr.QueryLexer.EOS\n  }\n\n  var char = this.str.charAt(this.pos)\n  this.pos += 1\n  return char\n}\n\nlunr.QueryLexer.prototype.width = function () {\n  return this.pos - this.start\n}\n\nlunr.QueryLexer.prototype.ignore = function () {\n  if (this.start == this.pos) {\n    this.pos += 1\n  }\n\n  this.start = this.pos\n}\n\nlunr.QueryLexer.prototype.backup = function () {\n  this.pos -= 1\n}\n\nlunr.QueryLexer.prototype.acceptDigitRun = function () {\n  var char, charCode\n\n  do {\n    char = this.next()\n    charCode = char.charCodeAt(0)\n  } while (charCode > 47 && charCode < 58)\n\n  if (char != lunr.QueryLexer.EOS) {\n    this.backup()\n  }\n}\n\nlunr.QueryLexer.prototype.more = function () {\n  return this.pos < this.length\n}\n\nlunr.QueryLexer.EOS = 'EOS'\nlunr.QueryLexer.FIELD = 'FIELD'\nlunr.QueryLexer.TERM = 'TERM'\nlunr.QueryLexer.EDIT_DISTANCE = 'EDIT_DISTANCE'\nlunr.QueryLexer.BOOST = 'BOOST'\nlunr.QueryLexer.PRESENCE = 'PRESENCE'\n\nlunr.QueryLexer.lexField = function (lexer) {\n  lexer.backup()\n  lexer.emit(lunr.QueryLexer.FIELD)\n  lexer.ignore()\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexTerm = function (lexer) {\n  if (lexer.width() > 1) {\n    lexer.backup()\n    lexer.emit(lunr.QueryLexer.TERM)\n  }\n\n  lexer.ignore()\n\n  if (lexer.more()) {\n    return lunr.QueryLexer.lexText\n  }\n}\n\nlunr.QueryLexer.lexEditDistance = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.EDIT_DISTANCE)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexBoost = function (lexer) {\n  lexer.ignore()\n  lexer.acceptDigitRun()\n  lexer.emit(lunr.QueryLexer.BOOST)\n  return lunr.QueryLexer.lexText\n}\n\nlunr.QueryLexer.lexEOS = function (lexer) {\n  if (lexer.width() > 0) {\n    lexer.emit(lunr.QueryLexer.TERM)\n  }\n}\n\n// This matches the separator used when tokenising fields\n// within a document. These should match otherwise it is\n// not possible to search for some tokens within a document.\n//\n// It is possible for the user to change the separator on the\n// tokenizer so it _might_ clash with any other of the special\n// characters already used within the search string, e.g. :.\n//\n// This means that it is possible to change the separator in\n// such a way that makes some words unsearchable using a search\n// string.\nlunr.QueryLexer.termSeparator = lunr.tokenizer.separator\n\nlunr.QueryLexer.lexText = function (lexer) {\n  while (true) {\n    var char = lexer.next()\n\n    if (char == lunr.QueryLexer.EOS) {\n      return lunr.QueryLexer.lexEOS\n    }\n\n    // Escape character is '\\'\n    if (char.charCodeAt(0) == 92) {\n      lexer.escapeCharacter()\n      continue\n    }\n\n    if (char == \":\") {\n      return lunr.QueryLexer.lexField\n    }\n\n    if (char == \"~\") {\n      lexer.backup()\n      if (lexer.width() > 0) {\n        lexer.emit(lunr.QueryLexer.TERM)\n      }\n      return lunr.QueryLexer.lexEditDistance\n    }\n\n    if (char == \"^\") {\n      lexer.backup()\n      if (lexer.width() > 0) {\n        lexer.emit(lunr.QueryLexer.TERM)\n      }\n      return lunr.QueryLexer.lexBoost\n    }\n\n    // \"+\" indicates term presence is required\n    // checking for length to ensure that only\n    // leading \"+\" are considered\n    if (char == \"+\" && lexer.width() === 1) {\n      lexer.emit(lunr.QueryLexer.PRESENCE)\n      return lunr.QueryLexer.lexText\n    }\n\n    // \"-\" indicates term presence is prohibited\n    // checking for length to ensure that only\n    // leading \"-\" are considered\n    if (char == \"-\" && lexer.width() === 1) {\n      lexer.emit(lunr.QueryLexer.PRESENCE)\n      return lunr.QueryLexer.lexText\n    }\n\n    if (char.match(lunr.QueryLexer.termSeparator)) {\n      return lunr.QueryLexer.lexTerm\n    }\n  }\n}\n\nlunr.QueryParser = function (str, query) {\n  this.lexer = new lunr.QueryLexer (str)\n  this.query = query\n  this.currentClause = {}\n  this.lexemeIdx = 0\n}\n\nlunr.QueryParser.prototype.parse = function () {\n  this.lexer.run()\n  this.lexemes = this.lexer.lexemes\n\n  var state = lunr.QueryParser.parseClause\n\n  while (state) {\n    state = state(this)\n  }\n\n  return this.query\n}\n\nlunr.QueryParser.prototype.peekLexeme = function () {\n  return this.lexemes[this.lexemeIdx]\n}\n\nlunr.QueryParser.prototype.consumeLexeme = function () {\n  var lexeme = this.peekLexeme()\n  this.lexemeIdx += 1\n  return lexeme\n}\n\nlunr.QueryParser.prototype.nextClause = function () {\n  var completedClause = this.currentClause\n  this.query.clause(completedClause)\n  this.currentClause = {}\n}\n\nlunr.QueryParser.parseClause = function (parser) {\n  var lexeme = parser.peekLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  switch (lexeme.type) {\n    case lunr.QueryLexer.PRESENCE:\n      return lunr.QueryParser.parsePresence\n    case lunr.QueryLexer.FIELD:\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expected either a field or a term, found \" + lexeme.type\n\n      if (lexeme.str.length >= 1) {\n        errorMessage += \" with value '\" + lexeme.str + \"'\"\n      }\n\n      throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n}\n\nlunr.QueryParser.parsePresence = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  switch (lexeme.str) {\n    case \"-\":\n      parser.currentClause.presence = lunr.Query.presence.PROHIBITED\n      break\n    case \"+\":\n      parser.currentClause.presence = lunr.Query.presence.REQUIRED\n      break\n    default:\n      var errorMessage = \"unrecognised presence operator'\" + lexeme.str + \"'\"\n      throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    var errorMessage = \"expecting term or field, found nothing\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.FIELD:\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expecting term or field, found '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseField = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  if (parser.query.allFields.indexOf(lexeme.str) == -1) {\n    var possibleFields = parser.query.allFields.map(function (f) { return \"'\" + f + \"'\" }).join(', '),\n        errorMessage = \"unrecognised field '\" + lexeme.str + \"', possible fields: \" + possibleFields\n\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.fields = [lexeme.str]\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    var errorMessage = \"expecting term, found nothing\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      return lunr.QueryParser.parseTerm\n    default:\n      var errorMessage = \"expecting term, found '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseTerm = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  parser.currentClause.term = lexeme.str.toLowerCase()\n\n  if (lexeme.str.indexOf(\"*\") != -1) {\n    parser.currentClause.usePipeline = false\n  }\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseEditDistance = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var editDistance = parseInt(lexeme.str, 10)\n\n  if (isNaN(editDistance)) {\n    var errorMessage = \"edit distance must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.editDistance = editDistance\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\nlunr.QueryParser.parseBoost = function (parser) {\n  var lexeme = parser.consumeLexeme()\n\n  if (lexeme == undefined) {\n    return\n  }\n\n  var boost = parseInt(lexeme.str, 10)\n\n  if (isNaN(boost)) {\n    var errorMessage = \"boost must be numeric\"\n    throw new lunr.QueryParseError (errorMessage, lexeme.start, lexeme.end)\n  }\n\n  parser.currentClause.boost = boost\n\n  var nextLexeme = parser.peekLexeme()\n\n  if (nextLexeme == undefined) {\n    parser.nextClause()\n    return\n  }\n\n  switch (nextLexeme.type) {\n    case lunr.QueryLexer.TERM:\n      parser.nextClause()\n      return lunr.QueryParser.parseTerm\n    case lunr.QueryLexer.FIELD:\n      parser.nextClause()\n      return lunr.QueryParser.parseField\n    case lunr.QueryLexer.EDIT_DISTANCE:\n      return lunr.QueryParser.parseEditDistance\n    case lunr.QueryLexer.BOOST:\n      return lunr.QueryParser.parseBoost\n    case lunr.QueryLexer.PRESENCE:\n      parser.nextClause()\n      return lunr.QueryParser.parsePresence\n    default:\n      var errorMessage = \"Unexpected lexeme type '\" + nextLexeme.type + \"'\"\n      throw new lunr.QueryParseError (errorMessage, nextLexeme.start, nextLexeme.end)\n  }\n}\n\n  /**\n   * export the module via AMD, CommonJS or as a browser global\n   * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js\n   */\n  ;(function (root, factory) {\n    if (typeof define === 'function' && define.amd) {\n      // AMD. Register as an anonymous module.\n      define(factory)\n    } else if (typeof exports === 'object') {\n      /**\n       * Node. Does not work with strict CommonJS, but\n       * only CommonJS-like enviroments that support module.exports,\n       * like Node.\n       */\n      module.exports = factory()\n    } else {\n      // Browser globals (root is window)\n      root.lunr = factory()\n    }\n  }(this, function () {\n    /**\n     * Just return a value to define the module export.\n     * This example returns an object, but the module\n     * can return a function as the exported value.\n     */\n    return lunr\n  }))\n})();\n","/*! picturefill - v3.0.2 - 2016-02-12\n * https://scottjehl.github.io/picturefill/\n * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT\n */\n/*! Gecko-Picture - v1.0\n * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture\n * Firefox's early picture implementation (prior to FF41) is static and does\n * not react to viewport changes. This tiny module fixes this.\n */\n(function(window) {\n\t/*jshint eqnull:true */\n\tvar ua = navigator.userAgent;\n\n\tif ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 < 45) ) {\n\t\taddEventListener(\"resize\", (function() {\n\t\t\tvar timer;\n\n\t\t\tvar dummySrc = document.createElement(\"source\");\n\n\t\t\tvar fixRespimg = function(img) {\n\t\t\t\tvar source, sizes;\n\t\t\t\tvar picture = img.parentNode;\n\n\t\t\t\tif (picture.nodeName.toUpperCase() === \"PICTURE\") {\n\t\t\t\t\tsource = dummySrc.cloneNode();\n\n\t\t\t\t\tpicture.insertBefore(source, picture.firstElementChild);\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tpicture.removeChild(source);\n\t\t\t\t\t});\n\t\t\t\t} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {\n\t\t\t\t\timg._pfLastSize = img.offsetWidth;\n\t\t\t\t\tsizes = img.sizes;\n\t\t\t\t\timg.sizes += \",100vw\";\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\timg.sizes = sizes;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar findPictureImgs = function() {\n\t\t\t\tvar i;\n\t\t\t\tvar imgs = document.querySelectorAll(\"picture > img, img[srcset][sizes]\");\n\t\t\t\tfor (i = 0; i < imgs.length; i++) {\n\t\t\t\t\tfixRespimg(imgs[i]);\n\t\t\t\t}\n\t\t\t};\n\t\t\tvar onResize = function() {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = setTimeout(findPictureImgs, 99);\n\t\t\t};\n\t\t\tvar mq = window.matchMedia && matchMedia(\"(orientation: landscape)\");\n\t\t\tvar init = function() {\n\t\t\t\tonResize();\n\n\t\t\t\tif (mq && mq.addListener) {\n\t\t\t\t\tmq.addListener(onResize);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tdummySrc.srcset = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n\t\t\tif (/^[c|i]|d$/.test(document.readyState || \"\")) {\n\t\t\t\tinit();\n\t\t\t} else {\n\t\t\t\tdocument.addEventListener(\"DOMContentLoaded\", init);\n\t\t\t}\n\n\t\t\treturn onResize;\n\t\t})());\n\t}\n})(window);\n\n/*! Picturefill - v3.0.2\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;\n *  License: MIT\n */\n\n(function( window, document, undefined ) {\n\t// Enable strict mode\n\t\"use strict\";\n\n\t// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)\n\tdocument.createElement( \"picture\" );\n\n\tvar warn, eminpx, alwaysCheckWDescriptor, evalId;\n\t// local object for method references and testing exposure\n\tvar pf = {};\n\tvar isSupportTestReady = false;\n\tvar noop = function() {};\n\tvar image = document.createElement( \"img\" );\n\tvar getImgAttr = image.getAttribute;\n\tvar setImgAttr = image.setAttribute;\n\tvar removeImgAttr = image.removeAttribute;\n\tvar docElem = document.documentElement;\n\tvar types = {};\n\tvar cfg = {\n\t\t//resource selection:\n\t\talgorithm: \"\"\n\t};\n\tvar srcAttr = \"data-pfsrc\";\n\tvar srcsetAttr = srcAttr + \"set\";\n\t// ua sniffing is done for undetectable img loading features,\n\t// to do some non crucial perf optimizations\n\tvar ua = navigator.userAgent;\n\tvar supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 > 35 );\n\tvar curSrcProp = \"currentSrc\";\n\tvar regWDesc = /\\s+\\+?\\d+(e\\d+)?w/;\n\tvar regSize = /(\\([^)]+\\))?\\s*(.+)/;\n\tvar setOptions = window.picturefillCFG;\n\t/**\n\t * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )\n\t */\n\t// baseStyle also used by getEmValue (i.e.: width: 1em is important)\n\tvar baseStyle = \"position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)\";\n\tvar fsCss = \"font-size:100%!important;\";\n\tvar isVwDirty = true;\n\n\tvar cssCache = {};\n\tvar sizeLengthCache = {};\n\tvar DPR = window.devicePixelRatio;\n\tvar units = {\n\t\tpx: 1,\n\t\t\"in\": 96\n\t};\n\tvar anchor = document.createElement( \"a\" );\n\t/**\n\t * alreadyRun flag used for setOptions. is it true setOptions will reevaluate\n\t * @type {boolean}\n\t */\n\tvar alreadyRun = false;\n\n\t// Reusable, non-\"g\" Regexes\n\n\t// (Don't use \\s, to avoid matching non-breaking space.)\n\tvar regexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t    regexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t    regexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t    regexTrailingCommas = /[,]+$/,\n\t    regexNonNegativeInteger = /^\\d+$/,\n\n\t    // ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t    // Must include at least one digit.\n\t    // According to spec tests any decimal point must be followed by a digit.\n\t    // No leading plus sign is allowed.)\n\t    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;\n\n\tvar on = function(obj, evt, fn, capture) {\n\t\tif ( obj.addEventListener ) {\n\t\t\tobj.addEventListener(evt, fn, capture || false);\n\t\t} else if ( obj.attachEvent ) {\n\t\t\tobj.attachEvent( \"on\" + evt, fn);\n\t\t}\n\t};\n\n\t/**\n\t * simple memoize function:\n\t */\n\n\tvar memoize = function(fn) {\n\t\tvar cache = {};\n\t\treturn function(input) {\n\t\t\tif ( !(input in cache) ) {\n\t\t\t\tcache[ input ] = fn(input);\n\t\t\t}\n\t\t\treturn cache[ input ];\n\t\t};\n\t};\n\n\t// UTILITY FUNCTIONS\n\n\t// Manual is faster than RegEx\n\t// http://jsperf.com/whitespace-character/5\n\tfunction isSpace(c) {\n\t\treturn (c === \"\\u0020\" || // space\n\t\t        c === \"\\u0009\" || // horizontal tab\n\t\t        c === \"\\u000A\" || // new line\n\t\t        c === \"\\u000C\" || // form feed\n\t\t        c === \"\\u000D\");  // carriage return\n\t}\n\n\t/**\n\t * gets a mediaquery and returns a boolean or gets a css length and returns a number\n\t * @param css mediaqueries or css length\n\t * @returns {boolean|number}\n\t *\n\t * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738\n\t */\n\tvar evalCSS = (function() {\n\n\t\tvar regLength = /^([\\d\\.]+)(em|vw|px)$/;\n\t\tvar replace = function() {\n\t\t\tvar args = arguments, index = 0, string = args[0];\n\t\t\twhile (++index in args) {\n\t\t\t\tstring = string.replace(args[index], args[++index]);\n\t\t\t}\n\t\t\treturn string;\n\t\t};\n\n\t\tvar buildStr = memoize(function(css) {\n\n\t\t\treturn \"return \" + replace((css || \"\").toLowerCase(),\n\t\t\t\t// interpret `and`\n\t\t\t\t/\\band\\b/g, \"&&\",\n\n\t\t\t\t// interpret `,`\n\t\t\t\t/,/g, \"||\",\n\n\t\t\t\t// interpret `min-` as >=\n\t\t\t\t/min-([a-z-\\s]+):/g, \"e.$1>=\",\n\n\t\t\t\t// interpret `max-` as <=\n\t\t\t\t/max-([a-z-\\s]+):/g, \"e.$1<=\",\n\n\t\t\t\t//calc value\n\t\t\t\t/calc([^)]+)/g, \"($1)\",\n\n\t\t\t\t// interpret css values\n\t\t\t\t/(\\d+[\\.]*[\\d]*)([a-z]+)/g, \"($1 * e.$2)\",\n\t\t\t\t//make eval less evil\n\t\t\t\t/^(?!(e.[a-z]|[0-9\\.&=|><\\+\\-\\*\\(\\)\\/])).*/ig, \"\"\n\t\t\t) + \";\";\n\t\t});\n\n\t\treturn function(css, length) {\n\t\t\tvar parsedLength;\n\t\t\tif (!(css in cssCache)) {\n\t\t\t\tcssCache[css] = false;\n\t\t\t\tif (length && (parsedLength = css.match( regLength ))) {\n\t\t\t\t\tcssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];\n\t\t\t\t} else {\n\t\t\t\t\t/*jshint evil:true */\n\t\t\t\t\ttry{\n\t\t\t\t\t\tcssCache[css] = new Function(\"e\", buildStr(css))(units);\n\t\t\t\t\t} catch(e) {}\n\t\t\t\t\t/*jshint evil:false */\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn cssCache[css];\n\t\t};\n\t})();\n\n\tvar setResolution = function( candidate, sizesattr ) {\n\t\tif ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...\n\t\t\tcandidate.cWidth = pf.calcListLength( sizesattr || \"100vw\" );\n\t\t\tcandidate.res = candidate.w / candidate.cWidth ;\n\t\t} else {\n\t\t\tcandidate.res = candidate.d;\n\t\t}\n\t\treturn candidate;\n\t};\n\n\t/**\n\t *\n\t * @param opt\n\t */\n\tvar picturefill = function( opt ) {\n\n\t\tif (!isSupportTestReady) {return;}\n\n\t\tvar elements, i, plen;\n\n\t\tvar options = opt || {};\n\n\t\tif ( options.elements && options.elements.nodeType === 1 ) {\n\t\t\tif ( options.elements.nodeName.toUpperCase() === \"IMG\" ) {\n\t\t\t\toptions.elements =  [ options.elements ];\n\t\t\t} else {\n\t\t\t\toptions.context = options.elements;\n\t\t\t\toptions.elements =  null;\n\t\t\t}\n\t\t}\n\n\t\telements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );\n\n\t\tif ( (plen = elements.length) ) {\n\n\t\t\tpf.setupRun( options );\n\t\t\talreadyRun = true;\n\n\t\t\t// Loop through all elements\n\t\t\tfor ( i = 0; i < plen; i++ ) {\n\t\t\t\tpf.fillImg(elements[ i ], options);\n\t\t\t}\n\n\t\t\tpf.teardownRun( options );\n\t\t}\n\t};\n\n\t/**\n\t * outputs a warning for the developer\n\t * @param {message}\n\t * @type {Function}\n\t */\n\twarn = ( window.console && console.warn ) ?\n\t\tfunction( message ) {\n\t\t\tconsole.warn( message );\n\t\t} :\n\t\tnoop\n\t;\n\n\tif ( !(curSrcProp in image) ) {\n\t\tcurSrcProp = \"src\";\n\t}\n\n\t// Add support for standard mime types.\n\ttypes[ \"image/jpeg\" ] = true;\n\ttypes[ \"image/gif\" ] = true;\n\ttypes[ \"image/png\" ] = true;\n\n\tfunction detectTypeSupport( type, typeUri ) {\n\t\t// based on Modernizr's lossless img-webp test\n\t\t// note: asynchronous\n\t\tvar image = new window.Image();\n\t\timage.onerror = function() {\n\t\t\ttypes[ type ] = false;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.onload = function() {\n\t\t\ttypes[ type ] = image.width === 1;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.src = typeUri;\n\t\treturn \"pending\";\n\t}\n\n\t// test svg support\n\ttypes[ \"image/svg+xml\" ] = document.implementation.hasFeature( \"http://www.w3.org/TR/SVG11/feature#Image\", \"1.1\" );\n\n\t/**\n\t * updates the internal vW property with the current viewport width in px\n\t */\n\tfunction updateMetrics() {\n\n\t\tisVwDirty = false;\n\t\tDPR = window.devicePixelRatio;\n\t\tcssCache = {};\n\t\tsizeLengthCache = {};\n\n\t\tpf.DPR = DPR || 1;\n\n\t\tunits.width = Math.max(window.innerWidth || 0, docElem.clientWidth);\n\t\tunits.height = Math.max(window.innerHeight || 0, docElem.clientHeight);\n\n\t\tunits.vw = units.width / 100;\n\t\tunits.vh = units.height / 100;\n\n\t\tevalId = [ units.height, units.width, DPR ].join(\"-\");\n\n\t\tunits.em = pf.getEmValue();\n\t\tunits.rem = units.em;\n\t}\n\n\tfunction chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {\n\t\tvar bonusFactor, tooMuch, bonus, meanDensity;\n\n\t\t//experimental\n\t\tif (cfg.algorithm === \"saveData\" ){\n\t\t\tif ( lowerValue > 2.7 ) {\n\t\t\t\tmeanDensity = dprValue + 1;\n\t\t\t} else {\n\t\t\t\ttooMuch = higherValue - dprValue;\n\t\t\t\tbonusFactor = Math.pow(lowerValue - 0.6, 1.5);\n\n\t\t\t\tbonus = tooMuch * bonusFactor;\n\n\t\t\t\tif (isCached) {\n\t\t\t\t\tbonus += 0.1 * bonusFactor;\n\t\t\t\t}\n\n\t\t\t\tmeanDensity = lowerValue + bonus;\n\t\t\t}\n\t\t} else {\n\t\t\tmeanDensity = (dprValue > 1) ?\n\t\t\t\tMath.sqrt(lowerValue * higherValue) :\n\t\t\t\tlowerValue;\n\t\t}\n\n\t\treturn meanDensity > dprValue;\n\t}\n\n\tfunction applyBestCandidate( img ) {\n\t\tvar srcSetCandidates;\n\t\tvar matchingSet = pf.getSet( img );\n\t\tvar evaluated = false;\n\t\tif ( matchingSet !== \"pending\" ) {\n\t\t\tevaluated = evalId;\n\t\t\tif ( matchingSet ) {\n\t\t\t\tsrcSetCandidates = pf.setRes( matchingSet );\n\t\t\t\tpf.applySetCandidate( srcSetCandidates, img );\n\t\t\t}\n\t\t}\n\t\timg[ pf.ns ].evaled = evaluated;\n\t}\n\n\tfunction ascendingSort( a, b ) {\n\t\treturn a.res - b.res;\n\t}\n\n\tfunction setSrcToCur( img, src, set ) {\n\t\tvar candidate;\n\t\tif ( !set && src ) {\n\t\t\tset = img[ pf.ns ].sets;\n\t\t\tset = set && set[set.length - 1];\n\t\t}\n\n\t\tcandidate = getCandidateForSrc(src, set);\n\n\t\tif ( candidate ) {\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\timg[ pf.ns ].curSrc = src;\n\t\t\timg[ pf.ns ].curCan = candidate;\n\n\t\t\tif ( !candidate.res ) {\n\t\t\t\tsetResolution( candidate, candidate.set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getCandidateForSrc( src, set ) {\n\t\tvar i, candidate, candidates;\n\t\tif ( src && set ) {\n\t\t\tcandidates = pf.parseSet( set );\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\tfor ( i = 0; i < candidates.length; i++ ) {\n\t\t\t\tif ( src === pf.makeUrl(candidates[ i ].url) ) {\n\t\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getAllSourceElements( picture, candidates ) {\n\t\tvar i, len, source, srcset;\n\n\t\t// SPEC mismatch intended for size and perf:\n\t\t// actually only source elements preceding the img should be used\n\t\t// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector\n\t\tvar sources = picture.getElementsByTagName( \"source\" );\n\n\t\tfor ( i = 0, len = sources.length; i < len; i++ ) {\n\t\t\tsource = sources[ i ];\n\t\t\tsource[ pf.ns ] = true;\n\t\t\tsrcset = source.getAttribute( \"srcset\" );\n\n\t\t\t// if source does not have a srcset attribute, skip\n\t\t\tif ( srcset ) {\n\t\t\t\tcandidates.push( {\n\t\t\t\t\tsrcset: srcset,\n\t\t\t\t\tmedia: source.getAttribute( \"media\" ),\n\t\t\t\t\ttype: source.getAttribute( \"type\" ),\n\t\t\t\t\tsizes: source.getAttribute( \"sizes\" )\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Srcset Parser\n\t * By Alex Bell |  MIT License\n\t *\n\t * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]\n\t *\n\t * Based super duper closely on the reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n\t */\n\n\t// 1. Let input be the value passed to this algorithm.\n\t// (TO-DO : Explain what \"set\" argument is here. Maybe choose a more\n\t// descriptive & more searchable name.  Since passing the \"set\" in really has\n\t// nothing to do with parsing proper, I would prefer this assignment eventually\n\t// go in an external fn.)\n\tfunction parseSrcset(input, set) {\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t    match = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\t\t    url,\n\t\t    descriptors,\n\t\t    currentDescriptor,\n\t\t    state,\n\t\t    c,\n\n\t\t    // 2. Let position be a pointer into input, initially pointing at the start\n\t\t    //    of the string.\n\t\t    pos = 0,\n\n\t\t    // 3. Let candidates be an initially empty source set.\n\t\t    candidates = [];\n\n\t\t/**\n\t\t* Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t* @return undefined\n\t\t*/\n\t\t// (Declared outside of the while loop so that it's only created once.\n\t\t// (This fn is defined before it is used, in order to pass JSHINT.\n\t\t// Unfortunately this breaks the sequencing of the spec comments. :/ )\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t// 10. Let width be absent.\n\t\t\t// 11. Let density be absent.\n\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t    w, d, h, i,\n\t\t\t    candidate = {},\n\t\t\t    desc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tif (!h && !d && !w) {candidate.d = 1;}\n\t\t\t\tif (candidate.d === 1) {set.has1x = true;}\n\t\t\t\tcandidate.set = set;\n\n\t\t\t\tcandidates.push(candidate);\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t\t/**\n\t\t* Tokenizes descriptor properties prior to parsing\n\t\t* Returns undefined.\n\t\t* (Again, this fn is defined before it is used, in order to pass JSHINT.\n\t\t* Unfortunately this breaks the logical sequencing of the spec comments. :/ )\n\t\t*/\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t  // Space character\n\t\t\t\t  // If current descriptor is not empty, append current descriptor to\n\t\t\t\t  // descriptors and let current descriptor be the empty string.\n\t\t\t\t  // Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\t}\n\n\t/*\n\t * Sizes Parser\n\t *\n\t * By Alex Bell |  MIT License\n\t *\n\t * Non-strict but accurate and lightweight JS Parser for the string value <img sizes=\"here\">\n\t *\n\t * Reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute\n\t *\n\t * Most comments are copied in directly from the spec\n\t * (except for comments in parens).\n\t *\n\t * Grammar is:\n\t * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>\n\t * <source-size> = <media-condition> <source-size-value>\n\t * <source-size-value> = <length>\n\t * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes\n\t *\n\t * E.g. \"(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw\"\n\t * or \"(min-width: 30em), calc(30vw - 15px)\" or just \"30vw\"\n\t *\n\t * Returns the first valid <css-length> with a media condition that evaluates to true,\n\t * or \"100vw\" if all valid media conditions evaluate to false.\n\t *\n\t */\n\n\tfunction parseSizes(strValue) {\n\n\t\t// (Percentage CSS lengths are not allowed in this case, to avoid confusion:\n\t\t// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list\n\t\t// CSS allows a single optional plus or minus sign:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#numbers\n\t\t// CSS is ASCII case-insensitive:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#characters )\n\t\t// Spec allows exponential notation for <number> type:\n\t\t// http://dev.w3.org/csswg/css-values/#numbers\n\t\tvar regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;\n\n\t\t// (This is a quick and lenient test. Because of optional unlimited-depth internal\n\t\t// grouping parens and strict spacing rules, this could get very complicated.)\n\t\tvar regexCssCalc = /^calc\\((?:[0-9a-z \\.\\+\\-\\*\\/\\(\\)]+)\\)$/i;\n\n\t\tvar i;\n\t\tvar unparsedSizesList;\n\t\tvar unparsedSizesListLength;\n\t\tvar unparsedSize;\n\t\tvar lastComponentValue;\n\t\tvar size;\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t//  (Toy CSS parser. The goals here are:\n\t\t//  1) expansive test coverage without the weight of a full CSS parser.\n\t\t//  2) Avoiding regex wherever convenient.\n\t\t//  Quick tests: http://jsfiddle.net/gtntL4gr/3/\n\t\t//  Returns an array of arrays.)\n\t\tfunction parseComponentValues(str) {\n\t\t\tvar chrctr;\n\t\t\tvar component = \"\";\n\t\t\tvar componentArray = [];\n\t\t\tvar listArray = [];\n\t\t\tvar parenDepth = 0;\n\t\t\tvar pos = 0;\n\t\t\tvar inComment = false;\n\n\t\t\tfunction pushComponent() {\n\t\t\t\tif (component) {\n\t\t\t\t\tcomponentArray.push(component);\n\t\t\t\t\tcomponent = \"\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction pushComponentArray() {\n\t\t\t\tif (componentArray[0]) {\n\t\t\t\t\tlistArray.push(componentArray);\n\t\t\t\t\tcomponentArray = [];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// (Loop forwards from the beginning of the string.)\n\t\t\twhile (true) {\n\t\t\t\tchrctr = str.charAt(pos);\n\n\t\t\t\tif (chrctr === \"\") { // ( End of string reached.)\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\treturn listArray;\n\t\t\t\t} else if (inComment) {\n\t\t\t\t\tif ((chrctr === \"*\") && (str[pos + 1] === \"/\")) { // (At end of a comment.)\n\t\t\t\t\t\tinComment = false;\n\t\t\t\t\t\tpos += 2;\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += 1; // (Skip all characters inside comments.)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else if (isSpace(chrctr)) {\n\t\t\t\t\t// (If previous character in loop was also a space, or if\n\t\t\t\t\t// at the beginning of the string, do not add space char to\n\t\t\t\t\t// component.)\n\t\t\t\t\tif ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (parenDepth === 0) {\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tpos +=1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// (Replace any space character with a plain space for legibility.)\n\t\t\t\t\t\tchrctr = \" \";\n\t\t\t\t\t}\n\t\t\t\t} else if (chrctr === \"(\") {\n\t\t\t\t\tparenDepth += 1;\n\t\t\t\t} else if (chrctr === \")\") {\n\t\t\t\t\tparenDepth -= 1;\n\t\t\t\t} else if (chrctr === \",\") {\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\tpos += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if ( (chrctr === \"/\") && (str.charAt(pos + 1) === \"*\") ) {\n\t\t\t\t\tinComment = true;\n\t\t\t\t\tpos += 2;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tcomponent = component + chrctr;\n\t\t\t\tpos += 1;\n\t\t\t}\n\t\t}\n\n\t\tfunction isValidNonNegativeSourceSizeValue(s) {\n\t\t\tif (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}\n\t\t\tif (regexCssCalc.test(s)) {return true;}\n\t\t\t// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:\n\t\t\t// \"-0 is equivalent to 0 and is not a negative number.\" which means that\n\t\t\t// unitless zero and unitless negative zero must be accepted as special cases.)\n\t\t\tif ((s === \"0\") || (s === \"-0\") || (s === \"+0\")) {return true;}\n\t\t\treturn false;\n\t\t}\n\n\t\t// When asked to parse a sizes attribute from an element, parse a\n\t\t// comma-separated list of component values from the value of the element's\n\t\t// sizes attribute (or the empty string, if the attribute is absent), and let\n\t\t// unparsed sizes list be the result.\n\t\t// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values\n\n\t\tunparsedSizesList = parseComponentValues(strValue);\n\t\tunparsedSizesListLength = unparsedSizesList.length;\n\n\t\t// For each unparsed size in unparsed sizes list:\n\t\tfor (i = 0; i < unparsedSizesListLength; i++) {\n\t\t\tunparsedSize = unparsedSizesList[i];\n\n\t\t\t// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.\n\t\t\t// ( parseComponentValues() already omits spaces outside of parens. )\n\n\t\t\t// If unparsed size is now empty, that is a parse error; continue to the next\n\t\t\t// iteration of this algorithm.\n\t\t\t// ( parseComponentValues() won't push an empty array. )\n\n\t\t\t// 2. If the last component value in unparsed size is a valid non-negative\n\t\t\t// <source-size-value>, let size be its value and remove the component value\n\t\t\t// from unparsed size. Any CSS function other than the calc() function is\n\t\t\t// invalid. Otherwise, there is a parse error; continue to the next iteration\n\t\t\t// of this algorithm.\n\t\t\t// http://dev.w3.org/csswg/css-syntax/#parse-component-value\n\t\t\tlastComponentValue = unparsedSize[unparsedSize.length - 1];\n\n\t\t\tif (isValidNonNegativeSourceSizeValue(lastComponentValue)) {\n\t\t\t\tsize = lastComponentValue;\n\t\t\t\tunparsedSize.pop();\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 3. Remove all consecutive <whitespace-token>s from the end of unparsed\n\t\t\t// size. If unparsed size is now empty, return size and exit this algorithm.\n\t\t\t// If this was not the last item in unparsed sizes list, that is a parse error.\n\t\t\tif (unparsedSize.length === 0) {\n\t\t\t\treturn size;\n\t\t\t}\n\n\t\t\t// 4. Parse the remaining component values in unparsed size as a\n\t\t\t// <media-condition>. If it does not parse correctly, or it does parse\n\t\t\t// correctly but the <media-condition> evaluates to false, continue to the\n\t\t\t// next iteration of this algorithm.\n\t\t\t// (Parsing all possible compound media conditions in JS is heavy, complicated,\n\t\t\t// and the payoff is unclear. Is there ever an situation where the\n\t\t\t// media condition parses incorrectly but still somehow evaluates to true?\n\t\t\t// Can we just rely on the browser/polyfill to do it?)\n\t\t\tunparsedSize = unparsedSize.join(\" \");\n\t\t\tif (!(pf.matchesMedia( unparsedSize ) ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 5. Return size and exit this algorithm.\n\t\t\treturn size;\n\t\t}\n\n\t\t// If the above algorithm exhausts unparsed sizes list without returning a\n\t\t// size value, return 100vw.\n\t\treturn \"100vw\";\n\t}\n\n\t// namespace\n\tpf.ns = (\"pf\" + new Date().getTime()).substr(0, 9);\n\n\t// srcset support test\n\tpf.supSrcset = \"srcset\" in image;\n\tpf.supSizes = \"sizes\" in image;\n\tpf.supPicture = !!window.HTMLPictureElement;\n\n\t// UC browser does claim to support srcset and picture, but not sizes,\n\t// this extended test reveals the browser does support nothing\n\tif (pf.supSrcset && pf.supPicture && !pf.supSizes) {\n\t\t(function(image2) {\n\t\t\timage.srcset = \"data:,a\";\n\t\t\timage2.src = \"data:,a\";\n\t\t\tpf.supSrcset = image.complete === image2.complete;\n\t\t\tpf.supPicture = pf.supSrcset && pf.supPicture;\n\t\t})(document.createElement(\"img\"));\n\t}\n\n\t// Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute\n\tif (pf.supSrcset && !pf.supSizes) {\n\n\t\t(function() {\n\t\t\tvar width2 = \"data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==\";\n\t\t\tvar width1 = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\t\t\tvar img = document.createElement(\"img\");\n\t\t\tvar test = function() {\n\t\t\t\tvar width = img.width;\n\n\t\t\t\tif (width === 2) {\n\t\t\t\t\tpf.supSizes = true;\n\t\t\t\t}\n\n\t\t\t\talwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;\n\n\t\t\t\tisSupportTestReady = true;\n\t\t\t\t// force async\n\t\t\t\tsetTimeout(picturefill);\n\t\t\t};\n\n\t\t\timg.onload = test;\n\t\t\timg.onerror = test;\n\t\t\timg.setAttribute(\"sizes\", \"9px\");\n\n\t\t\timg.srcset = width1 + \" 1w,\" + width2 + \" 9w\";\n\t\t\timg.src = width1;\n\t\t})();\n\n\t} else {\n\t\tisSupportTestReady = true;\n\t}\n\n\t// using pf.qsa instead of dom traversing does scale much better,\n\t// especially on sites mixing responsive and non-responsive images\n\tpf.selShort = \"picture>img,img[srcset]\";\n\tpf.sel = pf.selShort;\n\tpf.cfg = cfg;\n\n\t/**\n\t * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )\n\t */\n\tpf.DPR = (DPR  || 1 );\n\tpf.u = units;\n\n\t// container of supported mime types that one might need to qualify before using\n\tpf.types =  types;\n\n\tpf.setSize = noop;\n\n\t/**\n\t * Gets a string and returns the absolute URL\n\t * @param src\n\t * @returns {String} absolute URL\n\t */\n\n\tpf.makeUrl = memoize(function(src) {\n\t\tanchor.href = src;\n\t\treturn anchor.href;\n\t});\n\n\t/**\n\t * Gets a DOM element or document and a selctor and returns the found matches\n\t * Can be extended with jQuery/Sizzle for IE7 support\n\t * @param context\n\t * @param sel\n\t * @returns {NodeList|Array}\n\t */\n\tpf.qsa = function(context, sel) {\n\t\treturn ( \"querySelector\" in context ) ? context.querySelectorAll(sel) : [];\n\t};\n\n\t/**\n\t * Shortcut method for matchMedia ( for easy overriding in tests )\n\t * wether native or pf.mMQ is used will be decided lazy on first call\n\t * @returns {boolean}\n\t */\n\tpf.matchesMedia = function() {\n\t\tif ( window.matchMedia && (matchMedia( \"(min-width: 0.1em)\" ) || {}).matches ) {\n\t\t\tpf.matchesMedia = function( media ) {\n\t\t\t\treturn !media || ( matchMedia( media ).matches );\n\t\t\t};\n\t\t} else {\n\t\t\tpf.matchesMedia = pf.mMQ;\n\t\t}\n\n\t\treturn pf.matchesMedia.apply( this, arguments );\n\t};\n\n\t/**\n\t * A simplified matchMedia implementation for IE8 and IE9\n\t * handles only min-width/max-width with px or em values\n\t * @param media\n\t * @returns {boolean}\n\t */\n\tpf.mMQ = function( media ) {\n\t\treturn media ? evalCSS(media) : true;\n\t};\n\n\t/**\n\t * Returns the calculated length in css pixel from the given sourceSizeValue\n\t * http://dev.w3.org/csswg/css-values-3/#length-value\n\t * intended Spec mismatches:\n\t * * Does not check for invalid use of CSS functions\n\t * * Does handle a computed length of 0 the same as a negative and therefore invalid value\n\t * @param sourceSizeValue\n\t * @returns {Number}\n\t */\n\tpf.calcLength = function( sourceSizeValue ) {\n\n\t\tvar value = evalCSS(sourceSizeValue, true) || false;\n\t\tif (value < 0) {\n\t\t\tvalue = false;\n\t\t}\n\n\t\treturn value;\n\t};\n\n\t/**\n\t * Takes a type string and checks if its supported\n\t */\n\n\tpf.supportsType = function( type ) {\n\t\treturn ( type ) ? types[ type ] : true;\n\t};\n\n\t/**\n\t * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)\n\t * @param sourceSizeStr\n\t * @returns {*}\n\t */\n\tpf.parseSize = memoize(function( sourceSizeStr ) {\n\t\tvar match = ( sourceSizeStr || \"\" ).match(regSize);\n\t\treturn {\n\t\t\tmedia: match && match[1],\n\t\t\tlength: match && match[2]\n\t\t};\n\t});\n\n\tpf.parseSet = function( set ) {\n\t\tif ( !set.cands ) {\n\t\t\tset.cands = parseSrcset(set.srcset, set);\n\t\t}\n\t\treturn set.cands;\n\t};\n\n\t/**\n\t * returns 1em in css px for html/body default size\n\t * function taken from respondjs\n\t * @returns {*|number}\n\t */\n\tpf.getEmValue = function() {\n\t\tvar body;\n\t\tif ( !eminpx && (body = document.body) ) {\n\t\t\tvar div = document.createElement( \"div\" ),\n\t\t\t\toriginalHTMLCSS = docElem.style.cssText,\n\t\t\t\toriginalBodyCSS = body.style.cssText;\n\n\t\t\tdiv.style.cssText = baseStyle;\n\n\t\t\t// 1em in a media query is the value of the default font size of the browser\n\t\t\t// reset docElem and body to ensure the correct value is returned\n\t\t\tdocElem.style.cssText = fsCss;\n\t\t\tbody.style.cssText = fsCss;\n\n\t\t\tbody.appendChild( div );\n\t\t\teminpx = div.offsetWidth;\n\t\t\tbody.removeChild( div );\n\n\t\t\t//also update eminpx before returning\n\t\t\teminpx = parseFloat( eminpx, 10 );\n\n\t\t\t// restore the original values\n\t\t\tdocElem.style.cssText = originalHTMLCSS;\n\t\t\tbody.style.cssText = originalBodyCSS;\n\n\t\t}\n\t\treturn eminpx || 16;\n\t};\n\n\t/**\n\t * Takes a string of sizes and returns the width in pixels as a number\n\t */\n\tpf.calcListLength = function( sourceSizeListStr ) {\n\t\t// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%\n\t\t//\n\t\t//                           or (min-width:30em) calc(30% - 15px)\n\t\tif ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {\n\t\t\tvar winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );\n\n\t\t\tsizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;\n\t\t}\n\n\t\treturn sizeLengthCache[ sourceSizeListStr ];\n\t};\n\n\t/**\n\t * Takes a candidate object with a srcset property in the form of url/\n\t * ex. \"images/pic-medium.png 1x, images/pic-medium-2x.png 2x\" or\n\t *     \"images/pic-medium.png 400w, images/pic-medium-2x.png 800w\" or\n\t *     \"images/pic-small.png\"\n\t * Get an array of image candidates in the form of\n\t *      {url: \"/foo/bar.png\", resolution: 1}\n\t * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value\n\t * If sizes is specified, res is calculated\n\t */\n\tpf.setRes = function( set ) {\n\t\tvar candidates;\n\t\tif ( set ) {\n\n\t\t\tcandidates = pf.parseSet( set );\n\n\t\t\tfor ( var i = 0, len = candidates.length; i < len; i++ ) {\n\t\t\t\tsetResolution( candidates[ i ], set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidates;\n\t};\n\n\tpf.setRes.res = setResolution;\n\n\tpf.applySetCandidate = function( candidates, img ) {\n\t\tif ( !candidates.length ) {return;}\n\t\tvar candidate,\n\t\t\ti,\n\t\t\tj,\n\t\t\tlength,\n\t\t\tbestCandidate,\n\t\t\tcurSrc,\n\t\t\tcurCan,\n\t\t\tcandidateSrc,\n\t\t\tabortCurSrc;\n\n\t\tvar imageData = img[ pf.ns ];\n\t\tvar dpr = pf.DPR;\n\n\t\tcurSrc = imageData.curSrc || img[curSrcProp];\n\n\t\tcurCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);\n\n\t\t// if we have a current source, we might either become lazy or give this source some advantage\n\t\tif ( curCan && curCan.set === candidates[ 0 ].set ) {\n\n\t\t\t// if browser can abort image request and the image has a higher pixel density than needed\n\t\t\t// and this image isn't downloaded yet, we skip next part and try to save bandwidth\n\t\t\tabortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);\n\n\t\t\tif ( !abortCurSrc ) {\n\t\t\t\tcurCan.cached = true;\n\n\t\t\t\t// if current candidate is \"best\", \"better\" or \"okay\",\n\t\t\t\t// set it to bestCandidate\n\t\t\t\tif ( curCan.res >= dpr ) {\n\t\t\t\t\tbestCandidate = curCan;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( !bestCandidate ) {\n\n\t\t\tcandidates.sort( ascendingSort );\n\n\t\t\tlength = candidates.length;\n\t\t\tbestCandidate = candidates[ length - 1 ];\n\n\t\t\tfor ( i = 0; i < length; i++ ) {\n\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\tif ( candidate.res >= dpr ) {\n\t\t\t\t\tj = i - 1;\n\n\t\t\t\t\t// we have found the perfect candidate,\n\t\t\t\t\t// but let's improve this a little bit with some assumptions ;-)\n\t\t\t\t\tif (candidates[ j ] &&\n\t\t\t\t\t\t(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&\n\t\t\t\t\t\tchooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {\n\n\t\t\t\t\t\tbestCandidate = candidates[ j ];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbestCandidate = candidate;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( bestCandidate ) {\n\n\t\t\tcandidateSrc = pf.makeUrl( bestCandidate.url );\n\n\t\t\timageData.curSrc = candidateSrc;\n\t\t\timageData.curCan = bestCandidate;\n\n\t\t\tif ( candidateSrc !== curSrc ) {\n\t\t\t\tpf.setSrc( img, bestCandidate );\n\t\t\t}\n\t\t\tpf.setSize( img );\n\t\t}\n\t};\n\n\tpf.setSrc = function( img, bestCandidate ) {\n\t\tvar origWidth;\n\t\timg.src = bestCandidate.url;\n\n\t\t// although this is a specific Safari issue, we don't want to take too much different code paths\n\t\tif ( bestCandidate.set.type === \"image/svg+xml\" ) {\n\t\t\torigWidth = img.style.width;\n\t\t\timg.style.width = (img.offsetWidth + 1) + \"px\";\n\n\t\t\t// next line only should trigger a repaint\n\t\t\t// if... is only done to trick dead code removal\n\t\t\tif ( img.offsetWidth + 1 ) {\n\t\t\t\timg.style.width = origWidth;\n\t\t\t}\n\t\t}\n\t};\n\n\tpf.getSet = function( img ) {\n\t\tvar i, set, supportsType;\n\t\tvar match = false;\n\t\tvar sets = img [ pf.ns ].sets;\n\n\t\tfor ( i = 0; i < sets.length && !match; i++ ) {\n\t\t\tset = sets[i];\n\n\t\t\tif ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( supportsType === \"pending\" ) {\n\t\t\t\tset = supportsType;\n\t\t\t}\n\n\t\t\tmatch = set;\n\t\t\tbreak;\n\t\t}\n\n\t\treturn match;\n\t};\n\n\tpf.parseSets = function( element, parent, options ) {\n\t\tvar srcsetAttribute, imageSet, isWDescripor, srcsetParsed;\n\n\t\tvar hasPicture = parent && parent.nodeName.toUpperCase() === \"PICTURE\";\n\t\tvar imageData = element[ pf.ns ];\n\n\t\tif ( imageData.src === undefined || options.src ) {\n\t\t\timageData.src = getImgAttr.call( element, \"src\" );\n\t\t\tif ( imageData.src ) {\n\t\t\t\tsetImgAttr.call( element, srcAttr, imageData.src );\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcAttr );\n\t\t\t}\n\t\t}\n\n\t\tif ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {\n\t\t\tsrcsetAttribute = getImgAttr.call( element, \"srcset\" );\n\t\t\timageData.srcset = srcsetAttribute;\n\t\t\tsrcsetParsed = true;\n\t\t}\n\n\t\timageData.sets = [];\n\n\t\tif ( hasPicture ) {\n\t\t\timageData.pic = true;\n\t\t\tgetAllSourceElements( parent, imageData.sets );\n\t\t}\n\n\t\tif ( imageData.srcset ) {\n\t\t\timageSet = {\n\t\t\t\tsrcset: imageData.srcset,\n\t\t\t\tsizes: getImgAttr.call( element, \"sizes\" )\n\t\t\t};\n\n\t\t\timageData.sets.push( imageSet );\n\n\t\t\tisWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || \"\");\n\n\t\t\t// add normal src as candidate, if source has no w descriptor\n\t\t\tif ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {\n\t\t\t\timageSet.srcset += \", \" + imageData.src;\n\t\t\t\timageSet.cands.push({\n\t\t\t\t\turl: imageData.src,\n\t\t\t\t\td: 1,\n\t\t\t\t\tset: imageSet\n\t\t\t\t});\n\t\t\t}\n\n\t\t} else if ( imageData.src ) {\n\t\t\timageData.sets.push( {\n\t\t\t\tsrcset: imageData.src,\n\t\t\t\tsizes: null\n\t\t\t} );\n\t\t}\n\n\t\timageData.curCan = null;\n\t\timageData.curSrc = undefined;\n\n\t\t// if img has picture or the srcset was removed or has a srcset and does not support srcset at all\n\t\t// or has a w descriptor (and does not support sizes) set support to false to evaluate\n\t\timageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || (isWDescripor && !pf.supSizes) );\n\n\t\tif ( srcsetParsed && pf.supSrcset && !imageData.supported ) {\n\t\t\tif ( srcsetAttribute ) {\n\t\t\t\tsetImgAttr.call( element, srcsetAttr, srcsetAttribute );\n\t\t\t\telement.srcset = \"\";\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcsetAttr );\n\t\t\t}\n\t\t}\n\n\t\tif (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {\n\t\t\tif (imageData.src === null) {\n\t\t\t\telement.removeAttribute(\"src\");\n\t\t\t} else {\n\t\t\t\telement.src = imageData.src;\n\t\t\t}\n\t\t}\n\n\t\timageData.parsed = true;\n\t};\n\n\tpf.fillImg = function(element, options) {\n\t\tvar imageData;\n\t\tvar extreme = options.reselect || options.reevaluate;\n\n\t\t// expando for caching data on the img\n\t\tif ( !element[ pf.ns ] ) {\n\t\t\telement[ pf.ns ] = {};\n\t\t}\n\n\t\timageData = element[ pf.ns ];\n\n\t\t// if the element has already been evaluated, skip it\n\t\t// unless `options.reevaluate` is set to true ( this, for example,\n\t\t// is set to true when running `picturefill` on `resize` ).\n\t\tif ( !extreme && imageData.evaled === evalId ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( !imageData.parsed || options.reevaluate ) {\n\t\t\tpf.parseSets( element, element.parentNode, options );\n\t\t}\n\n\t\tif ( !imageData.supported ) {\n\t\t\tapplyBestCandidate( element );\n\t\t} else {\n\t\t\timageData.evaled = evalId;\n\t\t}\n\t};\n\n\tpf.setupRun = function() {\n\t\tif ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {\n\t\t\tupdateMetrics();\n\t\t}\n\t};\n\n\t// If picture is supported, well, that's awesome.\n\tif ( pf.supPicture ) {\n\t\tpicturefill = noop;\n\t\tpf.fillImg = noop;\n\t} else {\n\n\t\t // Set up picture polyfill by polling the document\n\t\t(function() {\n\t\t\tvar isDomReady;\n\t\t\tvar regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;\n\n\t\t\tvar run = function() {\n\t\t\t\tvar readyState = document.readyState || \"\";\n\n\t\t\t\ttimerId = setTimeout(run, readyState === \"loading\" ? 200 :  999);\n\t\t\t\tif ( document.body ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t\tisDomReady = isDomReady || regReady.test(readyState);\n\t\t\t\t\tif ( isDomReady ) {\n\t\t\t\t\t\tclearTimeout( timerId );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar timerId = setTimeout(run, document.body ? 9 : 99);\n\n\t\t\t// Also attach picturefill on resize and readystatechange\n\t\t\t// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html\n\t\t\tvar debounce = function(func, wait) {\n\t\t\t\tvar timeout, timestamp;\n\t\t\t\tvar later = function() {\n\t\t\t\t\tvar last = (new Date()) - timestamp;\n\n\t\t\t\t\tif (last < wait) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait - last);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttimeout = null;\n\t\t\t\t\t\tfunc();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\treturn function() {\n\t\t\t\t\ttimestamp = new Date();\n\n\t\t\t\t\tif (!timeout) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t\tvar lastClientWidth = docElem.clientHeight;\n\t\t\tvar onResize = function() {\n\t\t\t\tisVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;\n\t\t\t\tlastClientWidth = docElem.clientHeight;\n\t\t\t\tif ( isVwDirty ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ton( window, \"resize\", debounce(onResize, 99 ) );\n\t\t\ton( document, \"readystatechange\", run );\n\t\t})();\n\t}\n\n\tpf.picturefill = picturefill;\n\t//use this internally for easy monkey patching/performance testing\n\tpf.fillImgs = picturefill;\n\tpf.teardownRun = noop;\n\n\t/* expose methods for testing */\n\tpicturefill._ = pf;\n\n\twindow.picturefillCFG = {\n\t\tpf: pf,\n\t\tpush: function(args) {\n\t\t\tvar name = args.shift();\n\t\t\tif (typeof pf[name] === \"function\") {\n\t\t\t\tpf[name].apply(pf, args);\n\t\t\t} else {\n\t\t\t\tcfg[name] = args[0];\n\t\t\t\tif (alreadyRun) {\n\t\t\t\t\tpf.fillImgs( { reselect: true } );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\twhile (setOptions && setOptions.length) {\n\t\twindow.picturefillCFG.push(setOptions.shift());\n\t}\n\n\t/* expose picturefill */\n\twindow.picturefill = picturefill;\n\n\t/* expose picturefill */\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// CommonJS, just export\n\t\tmodule.exports = picturefill;\n\t} else if ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD support\n\t\tdefine( \"picturefill\", function() { return picturefill; } );\n\t}\n\n\t// IE8 evals this sync, so it must be the last thing we do\n\tif ( !pf.supPicture ) {\n\t\ttypes[ \"image/webp\" ] = detectTypeSupport(\"image/webp\", \"data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==\" );\n\t}\n\n} )( window, document );\n","/* eslint-disable */\n// https://tc39.github.io/ecma262/#sec-array.prototype.find\nif (!Array.prototype.find) {\n  Object.defineProperty(Array.prototype, 'find', {\n    value: function(predicate) {\n      // 1. Let O be ? ToObject(this value).\n      if (this == null) {\n        throw new TypeError('\"this\" is null or not defined');\n      }\n\n      var o = Object(this);\n\n      // 2. Let len be ? ToLength(? Get(O, \"length\")).\n      var len = o.length >>> 0;\n\n      // 3. If IsCallable(predicate) is false, throw a TypeError exception.\n      if (typeof predicate !== 'function') {\n        throw new TypeError('predicate must be a function');\n      }\n\n      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.\n      var thisArg = arguments[1];\n\n      // 5. Let k be 0.\n      var k = 0;\n\n      // 6. Repeat, while k < len\n      while (k < len) {\n        // a. Let Pk be ! ToString(k).\n        // b. Let kValue be ? Get(O, Pk).\n        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).\n        // d. If testResult is true, return kValue.\n        var kValue = o[k];\n        if (predicate.call(thisArg, kValue, k, o)) {\n          return kValue;\n        }\n        // e. Increase k by 1.\n        k++;\n      }\n\n      // 7. Return undefined.\n      return undefined;\n    },\n    configurable: true,\n    writable: true\n  });\n}\n/* eslint-enable */","/* eslint-disable */\n// Production steps of ECMA-262, Edition 6, 22.1.2.1\nif (!Array.from) {\n  Array.from = (function () {\n    var toStr = Object.prototype.toString;\n    var isCallable = function (fn) {\n      return typeof fn === 'function' || toStr.call(fn) === '[object Function]';\n    };\n    var toInteger = function (value) {\n      var number = Number(value);\n      if (isNaN(number)) { return 0; }\n      if (number === 0 || !isFinite(number)) { return number; }\n      return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));\n    };\n    var maxSafeInteger = Math.pow(2, 53) - 1;\n    var toLength = function (value) {\n      var len = toInteger(value);\n      return Math.min(Math.max(len, 0), maxSafeInteger);\n    };\n\n    // The length property of the from method is 1.\n    return function from(arrayLike/*, mapFn, thisArg */) {\n      // 1. Let C be the this value.\n      var C = this;\n\n      // 2. Let items be ToObject(arrayLike).\n      var items = Object(arrayLike);\n\n      // 3. ReturnIfAbrupt(items).\n      if (arrayLike == null) {\n        throw new TypeError('Array.from requires an array-like object - not null or undefined');\n      }\n\n      // 4. If mapfn is undefined, then let mapping be false.\n      var mapFn = arguments.length > 1 ? arguments[1] : void undefined;\n      var T;\n      if (typeof mapFn !== 'undefined') {\n        // 5. else\n        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.\n        if (!isCallable(mapFn)) {\n          throw new TypeError('Array.from: when provided, the second argument must be a function');\n        }\n\n        // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.\n        if (arguments.length > 2) {\n          T = arguments[2];\n        }\n      }\n\n      // 10. Let lenValue be Get(items, \"length\").\n      // 11. Let len be ToLength(lenValue).\n      var len = toLength(items.length);\n\n      // 13. If IsConstructor(C) is true, then\n      // 13. a. Let A be the result of calling the [[Construct]] internal method\n      // of C with an argument list containing the single item len.\n      // 14. a. Else, Let A be ArrayCreate(len).\n      var A = isCallable(C) ? Object(new C(len)) : new Array(len);\n\n      // 16. Let k be 0.\n      var k = 0;\n      // 17. Repeat, while k < len… (also steps a - h)\n      var kValue;\n      while (k < len) {\n        kValue = items[k];\n        if (mapFn) {\n          A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);\n        } else {\n          A[k] = kValue;\n        }\n        k += 1;\n      }\n      // 18. Let putStatus be Put(A, \"length\", len, true).\n      A.length = len;\n      // 20. Return A.\n      return A;\n    };\n  }());\n}\n/* eslint-enable */","/* eslint-disable */\n// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys\nif (!Object.keys) {\n  Object.keys = (function() {\n    'use strict';\n    var hasOwnProperty = Object.prototype.hasOwnProperty,\n        hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),\n        dontEnums = [\n          'toString',\n          'toLocaleString',\n          'valueOf',\n          'hasOwnProperty',\n          'isPrototypeOf',\n          'propertyIsEnumerable',\n          'constructor'\n        ],\n        dontEnumsLength = dontEnums.length;\n\n    return function(obj) {\n      if (typeof obj !== 'function' && (typeof obj !== 'object' || obj === null)) {\n        throw new TypeError('Object.keys called on non-object');\n      }\n\n      var result = [], prop, i;\n\n      for (prop in obj) {\n        if (hasOwnProperty.call(obj, prop)) {\n          result.push(prop);\n        }\n      }\n\n      if (hasDontEnumBug) {\n        for (i = 0; i < dontEnumsLength; i++) {\n          if (hasOwnProperty.call(obj, dontEnums[i])) {\n            result.push(dontEnums[i]);\n          }\n        }\n      }\n      return result;\n    };\n  }());\n}\n/* eslint-enable */","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport throttle from \"lodash.throttle\";\n\nconst cssClasses = {\n  hidden: \"backToTop--hidden\",\n};\nlet bttElem: HTMLElement;\nconst thresholdY = 500;\n\nfunction onScroll() {\n  const currentY = window.pageYOffset;\n  // display button when at least X pixel where scrolled\n  if (currentY > thresholdY) {\n    bttElem.classList.remove(cssClasses.hidden);\n  } else if (currentY < thresholdY) {\n    bttElem.classList.add(cssClasses.hidden);\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  bttElem = document.getElementById(\"backToTop-js\");\n  if (bttElem) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call\n    document.addEventListener(\"scroll\", throttle(onScroll, 500, { leading: true, trailing: true }));\n    bttElem.addEventListener(\"click\", () => {\n      bttElem.blur();\n      window.scrollTo(0, 0);\n    });\n  }\n});\n","type CountResponseJson = {\n  commentCounts: { [key: string]: number };\n  success: boolean;\n};\n\nfunction initCount(countSpan: HTMLElement) {\n  const commentsUrl = document.body.dataset.commentsUrl;\n  if (commentsUrl) {\n    const data = getPostData();\n    const request = new XMLHttpRequest();\n    request.open(\"POST\", `${commentsUrl}/api/comment/count`, true);\n    request.send(JSON.stringify(data));\n\n    request.onload = () => {\n      if (request.status === 200) {\n        displayCount(countSpan, request.response as string);\n      }\n    };\n  }\n}\n\nfunction displayCount(countSpan: HTMLElement, countResponse: string) {\n  try {\n    const responseJson = JSON.parse(countResponse) as CountResponseJson;\n    if (!responseJson.success) {\n      return;\n    }\n    let count;\n    if (\n      responseJson.commentCounts[location.pathname] &&\n      typeof responseJson.commentCounts[location.pathname] === \"number\"\n    ) {\n      count = responseJson.commentCounts[location.pathname];\n    } else {\n      count = 0;\n    }\n    countSpan.textContent = `${count} ${count === 1 ? \"comment\" : \"comments\"}`;\n  } catch (ex) {\n    // do nothing\n  }\n}\n\nfunction getPostData() {\n  return {\n    domain: location.host,\n    paths: [location.pathname],\n  };\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const countSpan = document.getElementById(\"post__meta-comments-js\");\n  if (countSpan) {\n    initCount(countSpan);\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n * Lazy-Loader for the comments section\n */\nconst observer = new IntersectionObserver(commentsSectionIntersecting);\n\nfunction commentsSectionIntersecting(entries: IntersectionObserverEntry[]) {\n  entries\n    .filter(e => e.isIntersecting)\n    .forEach(e => {\n      window.commento.main();\n      observer.unobserve(e.target);\n    });\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const commentsElem = document.getElementById(\"comments-section-js\");\n  if (commentsElem) {\n    if (typeof window.commento.main !== \"undefined\") {\n      observer.observe(commentsElem);\n    } else {\n      // if commento is not available, we remove the comments section\n      commentsElem.parentNode.removeChild(commentsElem);\n    }\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport { getCookie, setCookie } from \"../util/cookieHelper\";\n// name of the cookie\nconst cookieName = \"cookie-consent\";\n\n/* Check if cookie bar needs to be displayed */\nfunction setupCookieBar() {\n  const hasAccepted = getCookie(cookieName);\n  const cookieConsent = document.getElementById(\"cookie-consent-js\");\n  const cookieConsentButton = document.getElementById(\"cookie-consent__btn-js\");\n  if (cookieConsent && cookieConsentButton && !hasAccepted) {\n    cookieConsent.style.display = \"initial\";\n    cookieConsentButton.addEventListener(\"click\", function () {\n      setCookie(cookieName, \"true\", 365);\n      cookieConsent.classList.add(\"cookie-consent__fadeout\");\n    });\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  setupCookieBar();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n *\n * @param {string} name - name of the cookie\n * @returns {string} value of the cookie or null\n */\nexport function getCookie(name: string) {\n  const value = document.cookie.match(\"(^|;) ?\" + name + \"=([^;]*)(;|$)\");\n  return value ? value[2] : null;\n}\n\n/**\n *\n * @param {string} name - name of the cookie\n * @param {string} value - value of the cookie\n * @param {number} days - how many days the cookie is valid\n */\nexport function setCookie(name: string, value: string, days: number) {\n  const d = new Date();\n  d.setDate(d.getDate() + days);\n  document.cookie = name + \"=\" + value + \";path=/;expires=\" + d.toUTCString();\n}\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nimport throttle from \"lodash.throttle\";\nimport { observe } from \"./lazyLoader\";\n\nlet galleryTemplate: HTMLTemplateElement,\n  galleryElem: HTMLElement,\n  galleryLightbox: HTMLElement,\n  activeThumb: HTMLPictureElement,\n  scrollerLeft: HTMLElement[],\n  scrollerRight: HTMLElement[];\n\nlet swipeX: number = null;\n\nconst cssClasses = {\n  lightbox: \"gallery__lightbox\",\n  thumbnail: \"gallery__thumbnails-item\",\n  caption: \"gallery__caption\",\n  thumbnailActive: \"gallery__thumbnails-item--active\",\n  thumbnailList: \"gallery__thumbnails-list\",\n  item: \"gallery__item\",\n  scrollerHidden: \"gallery__scroller--hidden\",\n  scrollerLeft: \"gallery__scroller-left\",\n  scrollerRight: \"gallery__scroller-right\",\n};\n\nfunction initGallery() {\n  galleryTemplate = document.getElementById(\"gallery__item-template-js\") as HTMLTemplateElement;\n  galleryLightbox = document.getElementById(\"gallery__lightbox-js\");\n\n  const galleryThumbs = Array.from(galleryElem.getElementsByClassName(cssClasses.thumbnail)) as HTMLPictureElement[];\n  galleryThumbs.forEach(thumb => (thumb.onclick = e => showImage(e.currentTarget as HTMLPictureElement)));\n\n  const thumbsList = document.getElementsByClassName(cssClasses.thumbnailList)[0];\n  thumbsList.addEventListener(\"mousedown\", swipeLock, false);\n  thumbsList.addEventListener(\"touchstart\", swipeLock, false);\n  thumbsList.addEventListener(\"mouseup\", swipeMove, false);\n  thumbsList.addEventListener(\"touchend\", swipeMove, false);\n\n  scrollerLeft = Array.from(galleryElem.getElementsByClassName(cssClasses.scrollerLeft)) as HTMLElement[];\n  scrollerLeft.forEach(\n    scroller =>\n      (scroller.onclick = throttle(previousImage, 500, {\n        leading: true,\n        trailing: true,\n      })),\n  );\n\n  scrollerRight = Array.from(galleryElem.getElementsByClassName(cssClasses.scrollerRight)) as HTMLElement[];\n  scrollerRight.forEach(\n    scroller =>\n      (scroller.onclick = throttle(nextImage, 500, {\n        leading: true,\n        trailing: true,\n      })),\n  );\n\n  showImage(galleryThumbs[0]);\n}\n\nfunction showImage(thumb: HTMLPictureElement) {\n  // remove onclick listener\n  thumb.onclick = null;\n  // set active state\n  (\n    Array.from((thumb.parentNode as HTMLElement).getElementsByClassName(cssClasses.thumbnailActive)) as HTMLElement[]\n  ).forEach(activeItem => {\n    activeItem.onclick = e => showImage(e.currentTarget as HTMLPictureElement);\n    activeItem.classList.remove(cssClasses.thumbnailActive);\n  });\n  thumb.classList.add(cssClasses.thumbnailActive);\n\n  scrollToItem(thumb);\n\n  const galleryItemTemplate = createGalleryItem(thumb);\n\n  // reattach the element\n  const old = galleryElem.getElementsByClassName(cssClasses.item)[0];\n  galleryLightbox.replaceChild(galleryItemTemplate, old);\n\n  const galleryItem = galleryElem.getElementsByClassName(cssClasses.item)[0] as HTMLElement;\n\n  // trigger lazy-loading\n  observe(galleryItem);\n\n  // register event listener for swipe / touch\n  galleryItem.addEventListener(\"mousedown\", swipeLock, false);\n  galleryItem.addEventListener(\"touchstart\", swipeLock, false);\n  galleryItem.addEventListener(\"mouseup\", swipeMove, false);\n  galleryItem.addEventListener(\"touchend\", swipeMove, false);\n  // click should open next image\n  galleryItem.addEventListener(\"click\", nextImage, false);\n\n  updateScroller(thumb);\n  activeThumb = thumb;\n}\n\n/**\n * update all scroller buttons to match the new situation when thumb is displayed\n * @param thumb\n */\nfunction updateScroller(thumb: HTMLPictureElement) {\n  // if there is no next element, remove scroller right, otherwise display it\n  scrollerRight.forEach(s => {\n    if (thumb.nextElementSibling) {\n      s.classList.remove(cssClasses.scrollerHidden);\n    } else {\n      s.classList.add(cssClasses.scrollerHidden);\n    }\n  });\n  // if there is no prev element, remove scroller left, otherwise display it\n  scrollerLeft.forEach(s => {\n    if (thumb.previousElementSibling) {\n      s.classList.remove(cssClasses.scrollerHidden);\n    } else {\n      s.classList.add(cssClasses.scrollerHidden);\n    }\n  });\n}\n\n/**\n * create the gallery item from the given thumbnail using a template\n * @param thumb\n */\nfunction createGalleryItem(thumb: HTMLPictureElement) {\n  // create new item from template\n  const galleryItemTemplate = document.importNode(galleryTemplate.content, true);\n\n  const galleryPicture = galleryItemTemplate.getElementById(\"gallery__item-picture-js\");\n  // add new sources\n  const sources = Array.from(thumb.getElementsByTagName(\"source\"));\n  sources.reverse().forEach(e => {\n    const clone = e.cloneNode() as HTMLImageElement;\n    clone.sizes = \"(min-width: 120em) calc(1920px - 8em), (min-width: 64em) calc(100vw - 8em), calc(100vw - 2em)\";\n    galleryPicture.prepend(clone);\n  });\n\n  // set img src\n  const img = thumb.getElementsByTagName(\"img\")[0];\n  galleryPicture.querySelector(\"img\").dataset.src = img.src;\n\n  const caption = thumb.getElementsByClassName(cssClasses.caption)[0];\n  const templateCaption = galleryItemTemplate.getElementById(\"gallery__thumbnails-item-caption-js\");\n  if (caption) {\n    templateCaption.innerHTML = caption.innerHTML;\n  } else {\n    templateCaption.remove();\n  }\n  return galleryItemTemplate;\n}\n\nfunction nextImage() {\n  const next = activeThumb.nextElementSibling as HTMLPictureElement;\n  if (next) {\n    showImage(next);\n  }\n}\n\nfunction previousImage() {\n  const prev = activeThumb.previousElementSibling as HTMLPictureElement;\n  if (prev) {\n    showImage(prev);\n  }\n}\n\nfunction scrollToItem(thumb: HTMLPictureElement) {\n  const scrollable = thumb.parentNode as HTMLElement;\n  scrollable.scrollLeft = thumb.offsetLeft;\n}\n\n/**\n * Start swipe / mouse\n * @param e\n */\nfunction swipeLock(e: TouchEvent | MouseEvent) {\n  swipeX = unify(e);\n}\n\nfunction swipeMove(e: TouchEvent | MouseEvent) {\n  if (swipeX || swipeX === 0) {\n    const dx = unify(e) - swipeX;\n    if (dx > 0) {\n      previousImage();\n    } else if (dx < 0) {\n      nextImage();\n    }\n  }\n}\n\n/**\n * unify the two event types for mouse and swipe\n * @param e\n * @returns {Touch}\n */\nfunction unify(e: TouchEvent | MouseEvent): number {\n  return e instanceof TouchEvent ? e.changedTouches[0].clientX : e.clientX;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", () => {\n  galleryElem = document.getElementById(\"gallery-js\");\n  if (galleryElem) {\n    initGallery();\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\n/**\n * Lazy-Loader for all images marked as lazy-media.\n */\nconst observer = new IntersectionObserver(imageIntersecting);\n\n/**\n * Observe the given lazy image element\n * @param elem\n */\nfunction observe(elem: HTMLElement) {\n  observer.observe(elem);\n}\n\nexport { observe };\n\nfunction registerObserver() {\n  const elems = Array.from(document.getElementsByClassName(\"lazy-media\")) as HTMLElement[];\n\n  elems.forEach(e => {\n    observe(e);\n  });\n}\n\nfunction imageIntersecting(entries: IntersectionObserverEntry[]) {\n  entries\n    .filter(e => e.isIntersecting)\n    .forEach(e => {\n      loadMedia(e.target as HTMLElement);\n      observer.unobserve(e.target);\n    });\n}\n\n/**\n * Load the picture defined in the given element\n * @param elem\n */\nexport function loadMedia(elem: HTMLElement) {\n  let lazyMedia = elem.getElementsByTagName(\"picture\")[0];\n  let isVideo = false;\n  if (!lazyMedia) {\n    lazyMedia = elem.getElementsByTagName(\"video\")[0];\n    isVideo = true;\n  }\n  if (lazyMedia) {\n    // replace all the properties required to display an image\n    Array.from(lazyMedia.getElementsByTagName(\"source\")).forEach(source => {\n      if (source.dataset.srcset) {\n        source.srcset = source.dataset.srcset;\n        delete source.dataset.srcset;\n      } else if (source.dataset.src) {\n        source.src = source.dataset.src;\n        delete source.dataset.src;\n      }\n    });\n    // finally set img-src to trigger display\n    const img = lazyMedia.getElementsByTagName(\"img\")[0];\n    if (img) {\n      if (img.dataset.src) {\n        img.src = img.dataset.src;\n        delete img.dataset.src;\n      }\n\n      img.onload = e => {\n        const img = e.currentTarget as HTMLImageElement;\n        // remove event\n        img.onload = null;\n        const spinner = elem.getElementsByClassName(\"spinner\")[0];\n        if (spinner) {\n          elem.removeChild(spinner);\n        }\n      };\n    } else if (isVideo) {\n      (lazyMedia as HTMLVideoElement).load();\n      lazyMedia.onloadeddata = e => {\n        const video = e.currentTarget as HTMLVideoElement;\n        // remove event\n        video.onloadeddata = null;\n        const spinner = elem.getElementsByClassName(\"spinner\")[0];\n        if (spinner) {\n          elem.removeChild(spinner);\n        }\n      };\n    }\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", registerObserver);\n","/**\n * Disable scrolling on the body to show a lightbox\n */\nimport { loadMedia } from \"./lazyLoader\";\n\nexport function showLightbox() {\n  document.body.classList.add(\"lightbox__no-scroll\");\n}\n\n/**\n * close lightbox\n */\nexport function closeLightbox() {\n  document.body.classList.remove(\"lightbox__no-scroll\");\n}\n\nfunction initLightbox(trigger: HTMLElement) {\n  // the lightbox is always a parallel object to the trigger\n  //TODO: replace this with a unique ID per lightbox\n  const lightbox = trigger.parentElement.getElementsByClassName(\"lightbox\")[0];\n  const lightboxContent = lightbox.getElementsByClassName(\"lightbox__content\")[0] as HTMLElement;\n  if (lightbox && lightboxContent) {\n    trigger.addEventListener(\"click\", () => {\n      lightbox.classList.add(\"lightbox--open\");\n      // trigger image loading\n      loadMedia(lightboxContent);\n      showLightbox();\n    });\n    lightbox.addEventListener(\"click\", () => {\n      lightbox.classList.remove(\"lightbox--open\");\n      closeLightbox();\n    });\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const lightboxTrigger = Array.from(document.getElementsByClassName(\"lightbox__trigger-js\"));\n\n  lightboxTrigger.forEach(initLightbox);\n});\n","/**\n * Render all posts into matching columns\n */\nimport { getCurrentMQ, getViewportWidth, MQs } from \"../util/mqHelper\";\n\nimport throttle from \"lodash.throttle\";\nimport { observe } from \"./lazyLoader\";\n\nlet lastKnownWidth: number;\n\ntype ColDefinition = {\n  length: number;\n  elem: HTMLElement;\n};\n\nfunction renderPosts() {\n  // only render, if the width has changed (height changes don't matter for the postlist)\n  if (!viewportWidthChanged()) return;\n\n  const postList = document.getElementById(\"postlist-js\");\n  const posts = Array.from(postList.getElementsByTagName(\"template\"));\n  clearCols();\n  const numCols = getNumberActiveCols();\n  const cols: ColDefinition[] = [];\n  for (let i = 1; i <= numCols; i++) {\n    cols.push({\n      length: 0,\n      elem: document.getElementById(`postlist__col${i}-js`),\n    });\n  }\n  addPostsToColumns(posts, cols);\n\n  // make sure, that the lazy loader gets all new images\n  cols\n    .map(col => col.elem)\n    .forEach(elem => Array.from(elem.getElementsByClassName(\"lazy-media\")).forEach(e => observe(e as HTMLElement)));\n}\n\n/**\n *\n * @returns {boolean} - true if the viewport width has changed\n */\nfunction viewportWidthChanged() {\n  const viewPortWidth = getViewportWidth();\n  if (lastKnownWidth === viewPortWidth) {\n    return false;\n  }\n  lastKnownWidth = viewPortWidth;\n  return true;\n}\n\n/**\n *\n * @returns {number} - number of active cols (depending on the viewport width)\n */\nfunction getNumberActiveCols() {\n  const mq = getCurrentMQ();\n  if (mq === MQs.small) {\n    return 1;\n  } else if (mq === MQs.medium) {\n    return 2;\n  }\n  return 3;\n}\n\n/**\n * clear content of all cols\n */\nfunction clearCols() {\n  for (let i = 1; i <= 3; i++) {\n    document.getElementById(`postlist__col${i}-js`).innerHTML = \"\";\n  }\n}\n\n/**\n *\n * @param {Array} posts - all posts to be rendered\n * @param {Array} cols - columns which can be used\n */\nfunction addPostsToColumns(posts: HTMLTemplateElement[], cols: ColDefinition[]) {\n  if (cols.length === 1) {\n    const col = cols[0];\n    posts.forEach(post => {\n      col.elem.appendChild(post.content.cloneNode(true));\n    });\n  } else {\n    posts.forEach(post => {\n      addPostToShortestColumn(post, cols);\n    });\n  }\n}\n\n/**\n * Add given post to the shortest available column\n * @param {Object} post - post to be added\n * @param {Array} cols - all columns\n */\nfunction addPostToShortestColumn(post: HTMLTemplateElement, cols: ColDefinition[]) {\n  const shortest = findShortestColumn(cols);\n  const postToRender = post.content.cloneNode(true);\n  const shortestColElem = shortest.elem;\n  shortestColElem.appendChild(postToRender);\n  shortest.length += (shortestColElem.lastElementChild as HTMLElement).offsetHeight;\n}\n\n/**\n * return the shortest column\n * @param {array} cols\n * @return {object} - the shortest element from the array\n */\nfunction findShortestColumn(cols: ColDefinition[]) {\n  let shortest: ColDefinition;\n  cols.forEach(col => {\n    if (!shortest || col.length < shortest.length) {\n      shortest = col;\n    }\n  });\n  return shortest;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  if (document.getElementById(\"postlist-js\")) {\n    renderPosts();\n    // rerender on resize, throttled\n    window.addEventListener(\"resize\", throttle(renderPosts, 500, { leading: true, trailing: true }));\n  }\n});\n","import { getCurrentMQ, MQs } from \"../util/mqHelper\";\n\nimport throttle from \"lodash.throttle\";\n\nconst ids = {\n  content: \"post__nav-content-js\",\n  toggle: \"post__nav-toggle-id\",\n};\n\nlet contentElem: HTMLElement;\n\nconst getHeight = (el: HTMLElement) => {\n  const initialStyle = el.style;\n  const el_style = window.getComputedStyle(el),\n    el_display = el_style.display,\n    el_max_height = el_style.maxHeight.replace(\"px\", \"\").replace(\"%\", \"\");\n\n  // if it's not hidden we just return normal height\n  if (el_display !== \"none\" && el_max_height !== \"0\") {\n    return el.offsetHeight;\n  }\n\n  // the element is hidden so:\n  // making the el block so we can measure its height but still be hidden\n  el.style.position = \"absolute\";\n  el.style.visibility = \"hidden\";\n  el.style.display = \"block\";\n  el.style.maxHeight = \"initial\";\n\n  const height = el.offsetHeight;\n\n  // reverting to the original values\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  el.style = initialStyle;\n\n  return height;\n};\n\nconst init = (expand: boolean) => {\n  const height = getHeight(contentElem);\n  contentElem.style.setProperty(\"--post__nav-content-height\", `${height}px`);\n\n  if (expand) {\n    const mq = getCurrentMQ();\n    if (mq === MQs.small) {\n      // navi is shown on small devices by default\n      (document.getElementById(ids.toggle) as HTMLInputElement).checked = true;\n    }\n  }\n};\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  contentElem = document.getElementById(ids.content);\n  if (contentElem) {\n    init(true);\n    // rerender on resize, throttled\n    window.addEventListener(\n      \"resize\",\n      throttle(() => init(false), 500, { leading: true, trailing: true }),\n    );\n  }\n});\n","import throttle from \"lodash.throttle\";\n\nlet progressBar: HTMLProgressElement,\n  contentNavWrapper: HTMLElement,\n  startY: number,\n  currentY: number,\n  screenHeight: number;\nlet ticking = false;\n\nfunction onScroll() {\n  if (!ticking) {\n    currentY = window.pageYOffset || document.documentElement.scrollTop;\n    window.requestAnimationFrame(function () {\n      if (currentY >= startY) {\n        // the content-nav-wrapper's height might change, so we update max every time\n        progressBar.setAttribute(\"max\", (contentNavWrapper.clientHeight - screenHeight).toString());\n        progressBar.setAttribute(\"value\", (currentY - startY).toString());\n      } else {\n        progressBar.setAttribute(\"value\", \"0\");\n      }\n      ticking = false;\n    });\n    ticking = true;\n  }\n}\n\nfunction init() {\n  startY = contentNavWrapper.getBoundingClientRect().top + (window.pageYOffset || document.documentElement.scrollTop);\n  screenHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n  progressBar.setAttribute(\"max\", (contentNavWrapper.clientHeight - screenHeight).toString());\n  ticking = false;\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  progressBar = document.getElementById(\"progress-js\") as HTMLProgressElement;\n  contentNavWrapper = document.getElementById(\"page__content-nav-wrapper-js\");\n  if (progressBar && contentNavWrapper) {\n    init();\n    document.addEventListener(\"scroll\", onScroll);\n    window.addEventListener(\"resize\", throttle(init, 500, { leading: true, trailing: true }));\n  }\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nimport { closeLightbox, showLightbox } from \"./lightbox\";\nimport * as lunr from \"lunr\";\n\nconst selector = {\n  search: \"search-js\",\n  searchToggle: \"search__form-js\",\n  searchInput: \"search__input-js\",\n  result: \"search__result-js\",\n  closeButton: \"search__close-js\",\n  noResult: \"search__result-no-results-js\",\n  resultList: \"search__result-list-js\",\n  resultNumber: \"search__result-number-js\",\n};\n\ntype PageIndexEntry = {\n  date: string;\n  keywords: string[];\n  summary: string;\n  title: string;\n  uri: string;\n};\n\nlet lunrSearch: lunr.Index,\n  pageIndex: PageIndexEntry[],\n  resultTarget: HTMLElement,\n  noResultTarget: HTMLElement,\n  searchTarget: HTMLElement,\n  resultListTarget: HTMLElement,\n  resultNumberTarget: HTMLElement,\n  searchToggleTarget: HTMLElement;\n\n/**\n * Initialize lunr and load the required index\n */\nfunction initSearch() {\n  searchTarget = document.getElementById(selector.search);\n  searchToggleTarget = document.getElementById(selector.searchToggle);\n  resultTarget = document.getElementById(selector.result);\n  resultListTarget = document.getElementById(selector.resultList);\n  resultNumberTarget = document.getElementById(selector.resultNumber);\n  noResultTarget = document.getElementById(selector.noResult);\n  if (\n    searchTarget &&\n    searchTarget.dataset.searchUrl &&\n    resultTarget &&\n    searchToggleTarget &&\n    noResultTarget &&\n    resultListTarget &&\n    resultNumberTarget\n  ) {\n    initSearchBar();\n  }\n  /*\n    setTimeout(() => {\n      searchToggleTarget.click();\n    }, 500);\n\n    setTimeout(() => {\n      search(\"Foo\");\n    }, 1500);\n\n  /*setTimeout(() => {\n    search(\"Foobar\");\n  }, 3000);\n\n  setTimeout(() => {\n    document.getElementById(selector.closeButton).click();\n  }, 5000);\n   */\n}\n\nfunction initSearchBar() {\n  const searchInput = document.getElementById(selector.searchInput) as HTMLInputElement;\n  const closeButton = document.getElementById(selector.closeButton);\n  if (searchInput && closeButton) {\n    searchToggleTarget.addEventListener(\"click\", () => {\n      // open the searchbox\n      if (typeof lunrSearch === \"undefined\") {\n        initLunr();\n      }\n      searchTarget.classList.add(\"search--open\");\n      showLightbox();\n      searchInput.focus();\n    });\n\n    searchInput.addEventListener(\"input\", handleSearchInput);\n\n    closeButton.addEventListener(\"click\", () => {\n      // close the searchbox\n      searchInput.value = \"\";\n      searchInput.blur();\n      resultListTarget.innerHTML = \"\";\n      resultTarget.classList.add(\"search--hidden\");\n      searchTarget.classList.remove(\"search--open\");\n      closeLightbox();\n      noResultTarget.classList.add(\"search--hidden\");\n    });\n  }\n}\n\nfunction handleSearchInput(event: InputEvent) {\n  const target = event.currentTarget as HTMLInputElement;\n  // only search, if at least 3 characters were entered\n  if (target.value.length >= 3) {\n    search(target.value);\n  } else {\n    clearResults();\n  }\n}\n\nfunction initLunr() {\n  const request = new XMLHttpRequest();\n  request.open(\"GET\", searchTarget.dataset.searchUrl, true);\n  request.send();\n\n  request.onload = () => {\n    pageIndex = JSON.parse(request.responseText) as PageIndexEntry[];\n    lunrSearch = lunr(builder => {\n      builder.field(\"title\", { boost: 10 });\n      builder.field(\"keywords\", { boost: 5 });\n      builder.field(\"summary\");\n      builder.ref(\"uri\");\n      pageIndex.forEach(page => {\n        builder.add(page);\n      }, this);\n    });\n  };\n}\n\n/**\n * Perform a search for the given query and render the results\n *\n * @param {String} query - QueryString\n */\nfunction search(query: string) {\n  const results: PageIndexEntry[] = lunrSearch.search(query.trim() + \"*\").map(function (result) {\n    return pageIndex.filter(page => page.uri === result.ref)[0];\n  });\n  renderResults(results);\n}\n\n/**\n * Render the given results into the result target\n * @param {Object} results - Array with results\n *\n */\nfunction renderResults(results: PageIndexEntry[]) {\n  if (!results.length || !resultTarget) {\n    clearResults();\n    return;\n  }\n\n  const resultsHtml = results.map(result => renderResult(result)).join(\"\");\n\n  resultListTarget.innerHTML = resultsHtml.trim();\n  resultNumberTarget.innerHTML = `<span>Your search returned ${results.length} results<span>`;\n  resultTarget.classList.remove(\"search--hidden\");\n  noResultTarget.classList.add(\"search--hidden\");\n}\n\n/**\n * Render a single result\n * @param result\n * @return {string} result as html\n */\nfunction renderResult(result: PageIndexEntry) {\n  const tagsHtml = result.keywords ? result.keywords.map(keyword => renderTag(keyword)).join(\"\") : \"\";\n  const dateFormatted = formatDate(result.date);\n  return `<div class=\"search__result-item\">\n<a class=\"search__result-item-link\" href=\"${result.uri}\">\n<h5 class=\"search__result-item-meta\">${dateFormatted}</h5>\n<h2 class=\"search__result-item-headline\">${result.title}</h2>\n<div class=\"search__result-item-text\">\n<span>${result.summary}</span>\n</div>\n<ul class=\"search__result-item-tags\">\n${tagsHtml}\n</ul>\n</a>\n</div>\n`;\n}\n\n/**\n *\n * @param {String} dateString - the date as iso\n */\nfunction formatDate(dateString: string) {\n  const date = new Date(dateString);\n  const day = \"00\" + String(date.getDate()).slice(-2);\n  const month = \"00\" + String(date.getMonth() + 1).slice(-2);\n  return `${day}.${month}.${date.getFullYear()}`;\n}\n\nfunction renderTag(tag: string) {\n  return `<li class=\"e-tag-item\">${tag}</li>`;\n}\n\nfunction clearResults() {\n  resultListTarget.innerHTML = \"\";\n  resultTarget.classList.add(\"search--hidden\");\n  noResultTarget.classList.remove(\"search--hidden\");\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", () => {\n  initSearch();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n\nconst selector = \"svg-sprite\";\n\nfunction loadSvg() {\n  const svgTarget = document.getElementById(selector);\n\n  if (svgTarget && svgTarget.dataset.svgUrl) {\n    const request = new XMLHttpRequest();\n    request.open(\"GET\", svgTarget.dataset.svgUrl, true);\n    request.send();\n\n    request.onload = () => {\n      svgTarget.innerHTML = request.responseText;\n    };\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function() {\n  loadSvg();\n});\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nrequire(\"./components/cookieConsent\");\nrequire(\"./components/svgLoader\");\nrequire(\"./components/search\");\nrequire(\"./components/postList\");\nrequire(\"./components/backToTop\");\nrequire(\"./components/postNav\");\nrequire(\"./components/lightbox\");\nrequire(\"./components/gallery\");\nrequire(\"./components/commentsLazyLoader\");\nrequire(\"./components/commento/count\");\nrequire(\"./components/lazyLoader\");\nrequire(\"./components/readingPositionIndicator\");\nrequire(\"./util/navObserver\");\n","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\n/**\n * JS file used for legacy browsers which need polyfills\n */\nrequire(\"./external/polyfills/mozilla_array-from\");\nrequire(\"./external/polyfills/mozilla_array-find\");\nrequire(\"./external/polyfills/mozilla_object-keys\");\nrequire(\"@webcomponents/template\");\nrequire(\"picturefill\");\nrequire(\"intersection-observer\");\nrequire(\"./main\");\n","/**\n * All breakpoints\n * @type {{small: number, large: number, xlarge: number, xxlarge: number, medium: number}}\n */\nexport const MQs: { [key: string]: number } = {\n  xxlarge: 160,\n  xlarge: 120,\n  large: 85.375,\n  medium: 64,\n  small: 48,\n};\n\nimport throttle from \"lodash.throttle\";\nlet lastViewportHeight: number;\n\n/**\n *\n * @returns {Number} the current breakpoint\n */\nexport function getCurrentMQ() {\n  const widthEm = getViewportWidth();\n\n  // find first MQ that has at least the calculated width (min-width in media-query)\n  const mq = Object.keys(MQs).find(mq => {\n    return widthEm >= MQs[mq];\n  });\n  return mq ? MQs[mq] : MQs.small;\n}\n\n/**\n *\n * @returns {number} - viewport width in em\n */\nexport function getViewportWidth() {\n  // we define the mqs in em, therefor we first need to calculate the width in ems\n  const width = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n  const fontSize = parseFloat(getComputedStyle(document.body).fontSize);\n  return width / fontSize;\n}\n\nfunction updateViewportSize() {\n  // First we get the viewport height and we multiple it by 1% to get a value for a vh unit\n  const vh = window.innerHeight * 0.01;\n  if (!lastViewportHeight || lastViewportHeight !== vh) {\n    // Then we set the value in the --vh custom property to the root of the document\n    document.documentElement.style.setProperty(\"--vh\", `${vh}px`);\n    lastViewportHeight = vh;\n  }\n}\n\n/**\n * Ensure, that the --vh variable is set\n */\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  updateViewportSize();\n  // rerender on resize, throttled\n  window.addEventListener(\"resize\", throttle(updateViewportSize, 500, { leading: true, trailing: true }));\n});\n","/**\n * Observer for a navigation\n */\nclass NavObserver {\n  private navElem: HTMLElement;\n  private content: HTMLElement;\n  private readonly activeClass: string;\n  private observer: IntersectionObserver;\n\n  private navAnchors: Map<string, HTMLAnchorElement>;\n  /**\n   * Constructor\n   * @param navElem - element where the anchors are\n   * @param content - content to observe\n   * @param activeClass - css class to add for active elements\n   */\n  constructor(navElem: HTMLElement, content: HTMLElement, activeClass: string) {\n    this.navElem = navElem;\n    this.content = content;\n    this.activeClass = activeClass;\n    this.observer = new IntersectionObserver(e => this.elementIntersecting(e), {\n      threshold: 0.75,\n    });\n    const headings = this.findHeadings();\n    if (headings.length >= 0) {\n      headings.forEach(h => this.observer.observe(h));\n      this.navAnchors = this.findAnchors();\n    }\n  }\n\n  /**\n   * @returns {any[]} array with all headlines from the content\n   */\n  findHeadings() {\n    return Array.from(this.content.getElementsByTagName(\"h2\"));\n  }\n\n  /**\n   * @return {Map} map - map with all anchors in the nav element\n   */\n  findAnchors() {\n    return new Map(Array.from(this.navElem.getElementsByTagName(\"a\")).map(ele => [decodeURI(ele.hash), ele]));\n  }\n\n  elementIntersecting(entries: IntersectionObserverEntry[]) {\n    this.elementBecomesVisible(\n      entries\n        .filter(e => e.isIntersecting && e.intersectionRatio >= 0.75)\n        .map(e => {\n          return this.navAnchors.get(`#${e.target.id}`);\n        })\n        .filter(e => e),\n    );\n    this.elementBecomesInvisible(\n      entries\n        .filter(e => !e.isIntersecting)\n        .map(e => this.navAnchors.get(`#${e.target.id}`))\n        .filter(e => e),\n    );\n  }\n\n  elementBecomesVisible(enteringAnchors: HTMLElement[]) {\n    const rev = enteringAnchors.reverse();\n    for (let i = 0; i < rev.length; i++) {\n      rev[i].parentElement.classList.add(this.activeClass);\n    }\n  }\n\n  elementBecomesInvisible(leavingAnchors: HTMLElement[]) {\n    leavingAnchors.forEach(anchor => anchor.parentElement.classList.remove(this.activeClass));\n  }\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  const postContent = document.getElementById(\"post-content-js\");\n  if (postContent) {\n    const pageNav = document.getElementById(\"page-nav-js\");\n    if (pageNav) {\n      new NavObserver(pageNav, postContent, \"page__nav-item--active\");\n    }\n    const postNav = document.getElementById(\"post-nav-js\");\n    if (postNav) {\n      new NavObserver(postNav, postContent, \"post__nav-item--active\");\n    }\n  }\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","/*\n * Copyright (c) 2019. dev-eth0.de All rights reserved.\n */\nrequire(\"../themes/deveth0-theme/src/mainLegacy\");\n"],"names":["needsTemplate","HTMLTemplateElement","brokenDocFragment","document","createDocumentFragment","cloneNode","DocumentFragment","needsDocFrag","test","navigator","userAgent","origCloneNode","Node","prototype","deep","newDom","call","this","__proto__","querySelectorAll","HTMLElement","querySelector","Object","defineProperties","get","DOCUMENT_FRAGMENT_NODE","configurable","origInsertBefore","insertBefore","newNode","refNode","child","firstChild","origAppendChild","appendChild","origRemoveChild","removeChild","origReplaceChild","replaceChild","newChild","oldChild","Document","frag","createElement","origImportNode","importNode","impNode","capturedCloneNode","capturedCreateElement","capturedImportNode","capturedRemoveChild","capturedAppendChild","capturedReplaceChild","capturedParseFromString","DOMParser","parseFromString","capturedHTMLElementInnerHTML","getOwnPropertyDescriptor","window","innerHTML","set","text","capturedChildNodes","childNodes","elementQuerySelectorAll","Element","docQuerySelectorAll","fragQuerySelectorAll","QSA","node","selector","length","nodeType","DOCUMENT_NODE","needsCloning","t","t2","content","clone","TEMPLATE_TAG","PolyfilledHTMLTemplateElement","contentDoc","implementation","createHTMLDocument","canDecorate","templateStyle","textContent","head","firstElementChild","create","canProtoPatch","hasOwnProperty","decorate","template","namespaceURI","documentElement","_cloneNode","defineInnerHTML","defineOuterHTML","err","bootstrap","topLevelWrappingMap","obj","defineProperty","getInnerHTML","wrap","exec","toLowerCase","getTagName","i","body","j","lastChild","concat","parentNode","Error","docFrag","ownerDocument","doc","templates","l","addEventListener","el","apply","arguments","localName","enumerable","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","escapeAttr","s","replace","makeSet","arr","voidElements","plaintextParents","getOuterHTML","callback","ELEMENT_NODE","attr","tagName","attrs","attributes","name","value","TEXT_NODE","data","escapeData","COMMENT_NODE","console","error","c$","fixClonedDom","source","s$","t$","dom","element","fragment","ns","scripts","a","ai","setAttribute","fixClonedScripts","_typeof","IntersectionObserverEntry","intersectionRatio","startDoc","frame","getFrameElement","registry","crossOriginUpdater","crossOriginRect","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","top","bottom","left","right","width","height","forEach","observer","_checkForIntersections","_resetCrossOriginUpdater","observe","target","_observationTargets","some","item","_registerInstance","push","entry","_monitorIntersections","unobserve","filter","_unmonitorIntersections","_unregisterInstance","disconnect","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","slice","_initThresholds","opt_threshold","threshold","Array","isArray","sort","isNaN","_parseRootMargin","opt_rootMargin","margins","split","map","margin","parts","parseFloat","unit","win","defaultView","_monitoringDocuments","indexOf","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","rootDoc","root","index","hasDependentTargets","itemDoc","unsubscribe","splice","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","rootBounds","newEntry","time","performance","now","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","rect1","rect2","parent","getParentNode","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","overflow","Math","max","min","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","e","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","fn","timeout","timer","options","bind","setTimeout","rootMargin","join","event","opt_useCapture","attachEvent","removeEventListener","detachEvent","y","x","parentBoundingRect","parentIntersectionRect","assignedSlot","host","FUNC_ERROR_TEXT","NAN","symbolTag","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","global","freeSelf","self","Function","objectToString","toString","nativeMax","nativeMin","Date","debounce","func","wait","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","args","thisArg","undefined","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","remainingWait","debounced","isInvoking","leadingEdge","toNumber","isObject","cancel","clearTimeout","flush","type","isSymbol","isObjectLike","other","valueOf","isBinary","module","exports","step2list","step3list","v","C","V","meq1","mgr1","s_v","re_mgr0","re_mgr1","re_meq1","re_s_v","re_1a","re2_1a","re_1b","re2_1b","re_1b_2","re2_1b_2","re3_1b_2","re4_1b_2","re_1c","re_2","re_3","re_4","re2_4","re_5","re_5_1","re3_5","porterStemmer","lunr","config","builder","Builder","pipeline","add","trimmer","stopWordFilter","stemmer","searchPipeline","build","version","utils","warn","message","asString","keys","key","val","FieldRef","docRef","fieldName","stringValue","_stringValue","joiner","fromString","n","fieldRef","Set","elements","complete","intersect","union","contains","empty","object","b","intersection","idf","posting","documentCount","documentsWithTerm","log","abs","Token","str","metadata","update","tokenizer","len","tokens","sliceEnd","sliceStart","sliceLength","charAt","match","separator","tokenMetadata","Pipeline","_stack","registeredFunctions","registerFunction","label","warnIfFunctionNotRegistered","load","serialised","fnName","after","existingFn","newFn","pos","before","remove","run","stackLength","memo","k","runString","token","reset","toJSON","Vector","_magnitude","positionForIndex","start","end","pivotPoint","floor","pivotIndex","insert","insertIdx","upsert","position","magnitude","sumOfSquares","elementsLength","sqrt","dot","otherVector","dotProduct","aLen","bLen","aVal","bVal","similarity","toArray","output","RegExp","w","stem","suffix","firstch","re","re2","re3","re4","substr","toUpperCase","fp","generateStopWordFilter","stopWords","words","reduce","stopWord","TokenSet","final","edges","id","_nextId","fromArray","finish","fromClause","clause","fromFuzzyString","term","editDistance","stack","editsRemaining","pop","noEditNode","char","insertionNode","substitutionNode","transposeNode","charA","charB","next","prefix","edge","_str","labels","qNode","qEdges","qLen","nEdges","nLen","q","qEdge","nEdge","previousWord","uncheckedNodes","minimizedNodes","word","commonPrefix","minimize","nextNode","downTo","childKey","Index","invertedIndex","fieldVectors","tokenSet","fields","search","queryString","query","QueryParser","parse","Query","matchingFields","queryVectors","termFieldCache","requiredMatches","prohibitedMatches","clauses","terms","clauseMatches","usePipeline","m","termTokenSet","expandedTerms","presence","REQUIRED","field","expandedTerm","termIndex","_index","fieldPosting","matchingDocumentRefs","termField","matchingDocumentsSet","PROHIBITED","boost","fieldMatch","matchingDocumentRef","matchingFieldRef","MatchData","allRequiredMatches","allProhibitedMatches","matchingFieldRefs","results","matches","isNegated","docMatch","fieldVector","score","matchData","combine","ref","serializedIndex","serializedVectors","serializedInvertedIndex","tokenSetBuilder","tuple","_ref","_fields","_documents","fieldTermFrequencies","fieldLengths","_b","_k1","metadataWhitelist","RangeError","number","k1","extractor","fieldTerms","metadataKey","calculateAverageFieldLengths","fieldRefs","numberOfFields","accumulator","documentsWithField","averageFieldLength","createFieldVectors","fieldRefsLength","termIdfCache","fieldLength","termFrequencies","termsLength","fieldBoost","docBoost","scoreWithPrecision","tf","round","createTokenSet","use","unshift","clonedMetadata","metadataKeys","otherMatchData","allFields","wildcard","String","NONE","LEADING","TRAILING","OPTIONAL","QueryParseError","QueryLexer","lexemes","escapeCharPositions","state","lexText","sliceString","subSlices","emit","escapeCharacter","EOS","ignore","backup","acceptDigitRun","charCode","charCodeAt","more","FIELD","TERM","EDIT_DISTANCE","BOOST","PRESENCE","lexField","lexer","lexTerm","lexEditDistance","lexBoost","lexEOS","termSeparator","currentClause","lexemeIdx","parseClause","peekLexeme","consumeLexeme","lexeme","nextClause","completedClause","parser","parsePresence","parseField","parseTerm","errorMessage","nextLexeme","possibleFields","f","parseEditDistance","parseBoost","define","dummySrc","fixRespimg","findPictureImgs","onResize","mq","init","ua","HTMLPictureElement","$1","img","sizes","picture","nodeName","_pfLastSize","offsetWidth","imgs","matchMedia","addListener","srcset","readyState","eminpx","alwaysCheckWDescriptor","evalId","pf","isSupportTestReady","noop","image","getImgAttr","getAttribute","setImgAttr","removeImgAttr","removeAttribute","docElem","types","cfg","algorithm","srcAttr","srcsetAttr","supportAbort","curSrcProp","regWDesc","regSize","setOptions","picturefillCFG","fsCss","isVwDirty","cssCache","sizeLengthCache","DPR","devicePixelRatio","units","px","anchor","alreadyRun","regexLeadingSpaces","regexLeadingCommasOrSpaces","regexLeadingNotSpaces","regexTrailingCommas","regexNonNegativeInteger","regexFloatingPoint","on","evt","capture","memoize","cache","input","isSpace","regLength","buildStr","image2","width1","isDomReady","timestamp","later","regReady","lastClientWidth","evalCSS","css","string","parsedLength","setResolution","candidate","sizesattr","cWidth","calcListLength","res","d","picturefill","opt","plen","context","qsa","reevaluate","reselect","sel","selShort","setupRun","fillImg","teardownRun","ascendingSort","getCandidateForSrc","src","candidates","parseSet","makeUrl","url","hasFeature","getTime","supSrcset","supSizes","supPicture","onload","onerror","u","setSize","href","matchesMedia","media","mMQ","calcLength","sourceSizeValue","supportsType","parseSize","sourceSizeStr","cands","collectCharacters","regEx","chars","substring","descriptors","currentDescriptor","inputLength","parseDescriptors","h","desc","lastChar","intVal","floatVal","pError","has1x","tokenize","parseSrcset","getEmValue","div","originalHTMLCSS","style","cssText","originalBodyCSS","sourceSizeListStr","uT","winningLength","strValue","unparsedSizesList","unparsedSizesListLength","unparsedSize","lastComponentValue","size","regexCssLengthWithUnits","regexCssCalc","chrctr","component","componentArray","listArray","parenDepth","inComment","pushComponent","pushComponentArray","parseComponentValues","parseSizes","setRes","applySetCandidate","bestCandidate","curSrc","curCan","candidateSrc","abortCurSrc","lowerValue","higherValue","dprValue","isCached","bonusFactor","bonus","meanDensity","imageData","dpr","sets","setSrcToCur","cached","pow","setSrc","origWidth","getSet","parseSets","srcsetAttribute","imageSet","isWDescripor","srcsetParsed","hasPicture","pic","sources","getElementsByTagName","getAllSourceElements","supported","parsed","extreme","evaled","srcSetCandidates","matchingSet","evaluated","applyBestCandidate","innerWidth","innerHeight","vw","vh","em","rem","fillImgs","last","_","shift","typeUri","Image","detectTypeSupport","find","predicate","o","kValue","writable","toStr","isCallable","maxSafeInteger","toLength","from","isFinite","toInteger","arrayLike","items","T","mapFn","A","hasDontEnumBug","propertyIsEnumerable","dontEnums","dontEnumsLength","prop","cssClasses","bttElem","onScroll","currentY","pageYOffset","classList","getElementById","blur","scrollTo","initCount","countSpan","commentsUrl","dataset","domain","location","paths","pathname","request","XMLHttpRequest","open","send","JSON","stringify","status","countResponse","responseJson","success","count","commentCounts","ex","displayCount","response","entries","commento","main","commentsElem","cookieName","setupCookieBar","hasAccepted","cookie","getCookie","cookieConsent","cookieConsentButton","days","setDate","getDate","toUTCString","setCookie","galleryTemplate","galleryElem","galleryLightbox","activeThumb","scrollerLeft","scrollerRight","swipeX","lightbox","thumbnail","caption","thumbnailActive","thumbnailList","scrollerHidden","showImage","thumb","onclick","getElementsByClassName","activeItem","currentTarget","scrollable","scrollLeft","offsetLeft","scrollToItem","galleryItemTemplate","galleryPicture","reverse","prepend","templateCaption","createGalleryItem","old","galleryItem","swipeLock","swipeMove","nextImage","nextElementSibling","previousElementSibling","updateScroller","previousImage","prev","unify","dx","TouchEvent","changedTouches","clientX","galleryThumbs","thumbsList","scroller","initGallery","loadMedia","elem","lazyMedia","isVideo","spinner","onloadeddata","showLightbox","closeLightbox","initLightbox","trigger","parentElement","lightboxContent","lastKnownWidth","renderPosts","viewPortWidth","viewportWidthChanged","postList","posts","clearCols","numCols","small","medium","getNumberActiveCols","cols","col","post","shortest","findShortestColumn","postToRender","shortestColElem","lastElementChild","offsetHeight","addPostToShortestColumn","addPostsToColumns","ids","contentElem","expand","initialStyle","el_style","el_display","el_max_height","maxHeight","visibility","getHeight","setProperty","checked","progressBar","contentNavWrapper","startY","screenHeight","ticking","scrollTop","requestAnimationFrame","searchToggle","searchInput","closeButton","noResult","resultList","resultNumber","lunrSearch","pageIndex","resultTarget","noResultTarget","searchTarget","resultListTarget","resultNumberTarget","searchToggleTarget","initSearch","searchUrl","responseText","page","initLunr","focus","handleSearchInput","initSearchBar","clearResults","resultsHtml","tagsHtml","keywords","keyword","dateFormatted","dateString","date","day","month","getMonth","getFullYear","formatDate","uri","title","summary","renderResult","trim","renderResults","svgTarget","svgUrl","loadSvg","MQs","xxlarge","xlarge","large","lastViewportHeight","getCurrentMQ","widthEm","getViewportWidth","fontSize","updateViewportSize","NavObserver","constructor","navElem","activeClass","elementIntersecting","headings","findHeadings","navAnchors","findAnchors","Map","ele","decodeURI","hash","elementBecomesVisible","elementBecomesInvisible","enteringAnchors","rev","leavingAnchors","postContent","pageNav","postNav","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","getter","__esModule","definition","g","globalThis","r","Symbol","toStringTag","nmd","children"],"sourceRoot":""}