govuk_tech_docs 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d445bcd8c1daf9778f0a3e0d8cb352fab848b46c
-  data.tar.gz: d7fbb83f2f8e7f339033063acb560ad555fae7ce
+  metadata.gz: a0b627893fa39ba6cc6484a977b7b9c00639ad28
+  data.tar.gz: a45ebcff76937b949bb5c7388359bbd26cbe1d53
 SHA512:
-  metadata.gz: 5708cfb64dd99b8741711fcea030bffbcf81c7da49dfaed23a99215fae6140e07200a390760ff0e2334555787ffc9af191c454be96f74a679d74b93cf2723996
-  data.tar.gz: 42eb4aa9614ae826b2214ebfc4db24aae6c089e1d571986858baf348527382600940b3c7dc80c2fa864477397aca3752a2b8c4972185685f190173fe6ca72988
+  metadata.gz: fe4b821226d40bff2fd3d2eff34887862e74eda39c00ef058f512b448f995d1d0181aff90e3448c5493108dbae2eb76d5ee34746a5c7077adb4fede3107c3553
+  data.tar.gz: b9e34c88cfc72c46f4cab5e73bd3946e4475e6a1a3a42f2140ef8fb024f48f57ef6f8e57a8f1dc5b47aef41a9ccf7f07bb7ce080d6cb7f81a806da52d5ee8881

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.5.0
+
+### New feature: Search
+
+Adds search functionality. This indexes pages only and is not recommended for single-page sites. To enable write `enable_search: true` in in tech-docs.yml.
+
+More info:
+- https://github.com/alphagov/tech-docs-gem/pull/28
+
+### Google Analytics tracking for old headings
+
+An event category 'Broken fragment ID' will be pushed to Google Analytics when a user lands on a page with a URL that points to a fragment ID that does not exist on the page.
+
+More info:
+- https://github.com/alphagov/tech-docs-gem/pull/30
+
 ## 1.4.0
 
 Adds multiple page navigation support and collapsible top level navigation

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in govuk_tech_docs.gemspec
 gemspec
+
+gem 'middleman-search', :git => "git://github.com/alphagov/middleman-search.git"

data/docs/configuration.md

@@ -28,6 +28,14 @@ Adds a [Google Site Verification code](https://support.google.com/webmasters/ans
 google_site_verification: TvDTuyvdstyusadrCSDrctyd
 ```
 
+## `enable_search`
+
+Enables search functionality. This indexes pages only and is not recommended for single-page sites.
+
+```yaml
+enable_search: true
+```
+
 ## `header_links`
 
 Right hand side navigation.

data/example/config/tech-docs.yml

@@ -33,6 +33,8 @@ prevent_indexing: false
 
 google_site_verification: dstbao8TVS^DRVDS&rv76
 
+enable_search: true
+
 show_contribution_banner: true
 
 github_repo: alphagov/example-repo

data/govuk_tech_docs.gemspec

@@ -29,9 +29,11 @@ Gem::Specification.new do |spec|
   spec.add_dependency "middleman-livereload"
   spec.add_dependency "middleman-sprockets", "~> 4.0.0"
   spec.add_dependency "middleman-syntax", "~> 3.0.0"
+  spec.add_dependency "middleman-search"
   spec.add_dependency "nokogiri"
   spec.add_dependency "redcarpet", "~> 3.3.2"
 
+
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "capybara", "~> 2.18.0"

data/lib/assets/javascripts/_analytics.js

@@ -19,6 +19,20 @@
     };
   };
 
+  function catchBrokenFragmentLinks() {
+    var fragment = window.location.hash;
+    var $target = $(fragment);
+    if(!$target.get(0)) {
+      ga(
+        'send',
+        'event',
+        'Broken fragment ID', // Event Category
+        'pageview', // Event Action
+        window.location.pathname + fragment // Event Label
+      );
+    }
+  }
+
   $(document).on('ready', function() {
     if (typeof ga === 'undefined') {
       return;
@@ -27,5 +41,6 @@
     $('.technical-documentation a').on('click', linkTrackingEventHandler('inTextClick'));
     $('.header a').on('click', linkTrackingEventHandler('topNavigationClick'));
     $('.toc a').on('click', linkTrackingEventHandler('tableOfContentsNavigationClick'));
+    catchBrokenFragmentLinks();
   });
 })(jQuery);

data/lib/assets/javascripts/_modules/search.js

@@ -0,0 +1,198 @@
+//= require lunr.min
+//= require _vendor/jquery.mark.js
+(function($, Modules) {
+  'use strict';
+
+  Modules.Search = function Search() {
+    var s = this;
+    var $html = $('html');
+    s.lunrIndex;
+    s.lunrData;
+    var $searchForm;
+    var $searchLabel;
+    var $searchInput;
+    var $searchResults;
+    var $searchResultsTitle;
+    var $searchResultsWrapper;
+    var $searchResultsClose;
+    var results;
+    var maxSearchEntries = 10;
+
+    this.start = function start($element) {
+      $searchForm = $element.find('form');
+      $searchInput = $element.find('#search');
+      $searchLabel = $element.find('.search__label');
+      $searchResultsWrapper = $element.find('.search-results')
+      $searchResults = $searchResultsWrapper.find('.search-results__content');
+      $searchResultsTitle = $searchResultsWrapper.find('.search-results__title');
+      $searchResultsClose = $searchResultsWrapper.find('.search-results__close');
+      s.downloadSearchIndex();
+      attach();
+      changeSearchLabel();
+    };
+
+    this.downloadSearchIndex = function downloadSearchIndex() {
+      updateTitle('Loading search index')
+      $.ajax({
+        url: '/search.json',
+        cache: true,
+        method: 'GET',
+        success: function(data) {
+          s.lunrData = data;
+          s.lunrIndex = lunr.Index.load(s.lunrData.index);
+          $(document).trigger('lunrIndexLoaded');
+        }
+      });
+    }
+
+    function attach() {
+      // Search functionality on search text input
+      $searchInput.on('input', function (e) {
+        e.preventDefault();
+        var query = $(this).val();
+        s.search(query, function(r) {
+          results = r;
+          renderResults(query);
+          updateTitle();
+        });
+      });
+
+      // Set focus on the first search result instead of submiting the search
+      // form to Google
+      $searchForm.on('submit', function(e) {
+        e.preventDefault();
+        showResults();
+        $searchResults.find('.search-result__title a').first().focus();
+      });
+
+      // Closing the search results, move focus back to the search input
+      $searchResultsClose.on('click', function(e) {
+        e.preventDefault();
+        $searchInput.focus();
+        hideResults();
+      });
+    }
+
+    function changeSearchLabel() {
+      $searchLabel.text('Search');
+    }
+
+    function getResults(query) {
+      var results = [];
+      s.lunrIndex.search(query).forEach( function (item, index) {
+        if ( index < maxSearchEntries ) {
+          results.push(s.lunrData.docs[item.ref]);
+        }
+      });
+
+      return results;
+    }
+
+    this.search = function search(query, callback) {
+      if(query === '') {
+        hideResults();
+        return;
+      }
+      showResults();
+      // The index has not been downloaded yet, exit early and wait.
+      if(!s.lunrIndex) {
+        $(document).on('lunrIndexLoaded', function() {
+          s.search(query, callback);
+        });
+        return;
+      }
+      callback(getResults(query));
+    }
+
+    function renderResults(query) {
+      var output = '';
+      if (results.length == 0) {
+        output += '<p>Nothing found</p>';
+      }
+      output += '<ul>';
+      for(var index in results) {
+        var result = results[index];
+        var content = s.processContent(result.content, query);
+        output += '<li class="search-result">';
+        output += '<h3 class="search-result__title">';
+        output += '<a href="' + result.url + '">';
+        output += result.title;
+        output += '</a>';
+        output += '</h3>';
+        if(typeof content !== 'undefined') {
+          output += '<p>' + content + '</p>';
+        }
+        output += '</li>';
+      }
+      output += '</ul>';
+
+      $searchResults.html( output );
+    }
+
+    this.processContent = function processContent(content, query) {
+      var output;
+      content = '<div>'+  content + '</div>';
+      content = $(content).mark(query);
+
+      // Split content by sentence.
+      var sentences = content.html().replace(/(\.+|\:|\!|\?|\r|\n)(\"*|\'*|\)*|}*|]*)/gm, "|").split("|");
+
+      // Select the first five sentences that contain a <mark>
+      var selectedSentences = [];
+      for (var i = 0; i < sentences.length; i++) {
+        if(selectedSentences.length === 5) {
+          break;
+        }
+
+        var containsMark = sentences[i].includes('mark>');
+        if (containsMark) {
+          selectedSentences.push(sentences[i].trim());
+        }
+      }
+      if(selectedSentences.length > 0) {
+        output = ' … ' + selectedSentences.join(' … ') + ' … ';
+      }
+      return output;
+    }
+
+    // Default text is to display the number of search results
+    function updateTitle(text) {
+      if(typeof text == "undefined") {
+        var count = results.length;
+        var text = count + ' results';
+      }
+      $searchResultsTitle.text(text);
+    }
+
+    function showResults() {
+      $searchResultsWrapper.addClass('is-open')
+      .attr('aria-hidden', 'false');
+      $html.addClass('has-search-results-open');
+    }
+
+    function hideResults() {
+      $searchResultsWrapper.removeClass('is-open')
+      .attr('aria-hidden', 'true');
+      $html.removeClass('has-search-results-open');
+    }
+  };
+
+  // Polyfill includes
+  if (!String.prototype.includes) {
+    String.prototype.includes = function(search, start) {
+      'use strict';
+      if (typeof start !== 'number') {
+        start = 0;
+      }
+
+      if (start + search.length > this.length) {
+        return false;
+      } else {
+        return this.indexOf(search, start) !== -1;
+      }
+    };
+  }
+})(jQuery, window.GOVUK.Modules);
+
+
+

data/lib/assets/javascripts/_start-modules.js

@@ -4,8 +4,10 @@
 //= require _modules/navigation
 //= require _modules/page-expiry
 //= require _modules/table-of-contents
+//= require _modules/search
 //= require _modules/collapsible-navigation
 
+
 $(document).ready(function() {
   GOVUK.modules.start();
 });

data/lib/assets/javascripts/_vendor/jquery.mark.js

@@ -0,0 +1,1081 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :
+  typeof define === 'function' && define.amd ? define(['jquery'], factory) :
+  (global.Mark = factory(global.jQuery));
+}(this, (function ($) { 'use strict';
+
+  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  };
+
+  var classCallCheck = function (instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  };
+
+  var createClass = function () {
+    function defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+
+    return function (Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  }();
+
+  var _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  var DOMIterator = function () {
+    function DOMIterator(ctx) {
+      var iframes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var exclude = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var iframesTimeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 5000;
+      classCallCheck(this, DOMIterator);
+
+      this.ctx = ctx;
+      this.iframes = iframes;
+      this.exclude = exclude;
+      this.iframesTimeout = iframesTimeout;
+    }
+
+    createClass(DOMIterator, [{
+      key: 'getContexts',
+      value: function getContexts() {
+        var ctx = void 0,
+            filteredCtx = [];
+        if (typeof this.ctx === 'undefined' || !this.ctx) {
+          ctx = [];
+        } else if (NodeList.prototype.isPrototypeOf(this.ctx)) {
+          ctx = Array.prototype.slice.call(this.ctx);
+        } else if (Array.isArray(this.ctx)) {
+          ctx = this.ctx;
+        } else if (typeof this.ctx === 'string') {
+          ctx = Array.prototype.slice.call(document.querySelectorAll(this.ctx));
+        } else {
+          ctx = [this.ctx];
+        }
+        ctx.forEach(function (ctx) {
+          var isDescendant = filteredCtx.filter(function (contexts) {
+            return contexts.contains(ctx);
+          }).length > 0;
+          if (filteredCtx.indexOf(ctx) === -1 && !isDescendant) {
+            filteredCtx.push(ctx);
+          }
+        });
+        return filteredCtx;
+      }
+    }, {
+      key: 'getIframeContents',
+      value: function getIframeContents(ifr, successFn) {
+        var errorFn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
+
+        var doc = void 0;
+        try {
+          var ifrWin = ifr.contentWindow;
+          doc = ifrWin.document;
+          if (!ifrWin || !doc) {
+            throw new Error('iframe inaccessible');
+          }
+        } catch (e) {
+          errorFn();
+        }
+        if (doc) {
+          successFn(doc);
+        }
+      }
+    }, {
+      key: 'isIframeBlank',
+      value: function isIframeBlank(ifr) {
+        var bl = 'about:blank',
+            src = ifr.getAttribute('src').trim(),
+            href = ifr.contentWindow.location.href;
+        return href === bl && src !== bl && src;
+      }
+    }, {
+      key: 'observeIframeLoad',
+      value: function observeIframeLoad(ifr, successFn, errorFn) {
+        var _this = this;
+
+        var called = false,
+            tout = null;
+        var listener = function listener() {
+          if (called) {
+            return;
+          }
+          called = true;
+          clearTimeout(tout);
+          try {
+            if (!_this.isIframeBlank(ifr)) {
+              ifr.removeEventListener('load', listener);
+              _this.getIframeContents(ifr, successFn, errorFn);
+            }
+          } catch (e) {
+            errorFn();
+          }
+        };
+        ifr.addEventListener('load', listener);
+        tout = setTimeout(listener, this.iframesTimeout);
+      }
+    }, {
+      key: 'onIframeReady',
+      value: function onIframeReady(ifr, successFn, errorFn) {
+        try {
+          if (ifr.contentWindow.document.readyState === 'complete') {
+            if (this.isIframeBlank(ifr)) {
+              this.observeIframeLoad(ifr, successFn, errorFn);
+            } else {
+              this.getIframeContents(ifr, successFn, errorFn);
+            }
+          } else {
+            this.observeIframeLoad(ifr, successFn, errorFn);
+          }
+        } catch (e) {
+          errorFn();
+        }
+      }
+    }, {
+      key: 'waitForIframes',
+      value: function waitForIframes(ctx, done) {
+        var _this2 = this;
+
+        var eachCalled = 0;
+        this.forEachIframe(ctx, function () {
+          return true;
+        }, function (ifr) {
+          eachCalled++;
+          _this2.waitForIframes(ifr.querySelector('html'), function () {
+            if (! --eachCalled) {
+              done();
+            }
+          });
+        }, function (handled) {
+          if (!handled) {
+            done();
+          }
+        });
+      }
+    }, {
+      key: 'forEachIframe',
+      value: function forEachIframe(ctx, filter, each) {
+        var _this3 = this;
+
+        var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+
+        var ifr = ctx.querySelectorAll('iframe'),
+            open = ifr.length,
+            handled = 0;
+        ifr = Array.prototype.slice.call(ifr);
+        var checkEnd = function checkEnd() {
+          if (--open <= 0) {
+            end(handled);
+          }
+        };
+        if (!open) {
+          checkEnd();
+        }
+        ifr.forEach(function (ifr) {
+          if (DOMIterator.matches(ifr, _this3.exclude)) {
+            checkEnd();
+          } else {
+            _this3.onIframeReady(ifr, function (con) {
+              if (filter(ifr)) {
+                handled++;
+                each(con);
+              }
+              checkEnd();
+            }, checkEnd);
+          }
+        });
+      }
+    }, {
+      key: 'createIterator',
+      value: function createIterator(ctx, whatToShow, filter) {
+        return document.createNodeIterator(ctx, whatToShow, filter, false);
+      }
+    }, {
+      key: 'createInstanceOnIframe',
+      value: function createInstanceOnIframe(contents) {
+        return new DOMIterator(contents.querySelector('html'), this.iframes);
+      }
+    }, {
+      key: 'compareNodeIframe',
+      value: function compareNodeIframe(node, prevNode, ifr) {
+        var compCurr = node.compareDocumentPosition(ifr),
+            prev = Node.DOCUMENT_POSITION_PRECEDING;
+        if (compCurr & prev) {
+          if (prevNode !== null) {
+            var compPrev = prevNode.compareDocumentPosition(ifr),
+                after = Node.DOCUMENT_POSITION_FOLLOWING;
+            if (compPrev & after) {
+              return true;
+            }
+          } else {
+            return true;
+          }
+        }
+        return false;
+      }
+    }, {
+      key: 'getIteratorNode',
+      value: function getIteratorNode(itr) {
+        var prevNode = itr.previousNode();
+        var node = void 0;
+        if (prevNode === null) {
+          node = itr.nextNode();
+        } else {
+          node = itr.nextNode() && itr.nextNode();
+        }
+        return {
+          prevNode: prevNode,
+          node: node
+        };
+      }
+    }, {
+      key: 'checkIframeFilter',
+      value: function checkIframeFilter(node, prevNode, currIfr, ifr) {
+        var key = false,
+            handled = false;
+        ifr.forEach(function (ifrDict, i) {
+          if (ifrDict.val === currIfr) {
+            key = i;
+            handled = ifrDict.handled;
+          }
+        });
+        if (this.compareNodeIframe(node, prevNode, currIfr)) {
+          if (key === false && !handled) {
+            ifr.push({
+              val: currIfr,
+              handled: true
+            });
+          } else if (key !== false && !handled) {
+            ifr[key].handled = true;
+          }
+          return true;
+        }
+        if (key === false) {
+          ifr.push({
+            val: currIfr,
+            handled: false
+          });
+        }
+        return false;
+      }
+    }, {
+      key: 'handleOpenIframes',
+      value: function handleOpenIframes(ifr, whatToShow, eCb, fCb) {
+        var _this4 = this;
+
+        ifr.forEach(function (ifrDict) {
+          if (!ifrDict.handled) {
+            _this4.getIframeContents(ifrDict.val, function (con) {
+              _this4.createInstanceOnIframe(con).forEachNode(whatToShow, eCb, fCb);
+            });
+          }
+        });
+      }
+    }, {
+      key: 'iterateThroughNodes',
+      value: function iterateThroughNodes(whatToShow, ctx, eachCb, filterCb, doneCb) {
+        var _this5 = this;
+
+        var itr = this.createIterator(ctx, whatToShow, filterCb);
+        var ifr = [],
+            elements = [],
+            node = void 0,
+            prevNode = void 0,
+            retrieveNodes = function retrieveNodes() {
+          var _getIteratorNode = _this5.getIteratorNode(itr);
+
+          prevNode = _getIteratorNode.prevNode;
+          node = _getIteratorNode.node;
+
+          return node;
+        };
+        while (retrieveNodes()) {
+          if (this.iframes) {
+            this.forEachIframe(ctx, function (currIfr) {
+              return _this5.checkIframeFilter(node, prevNode, currIfr, ifr);
+            }, function (con) {
+              _this5.createInstanceOnIframe(con).forEachNode(whatToShow, function (ifrNode) {
+                return elements.push(ifrNode);
+              }, filterCb);
+            });
+          }
+          elements.push(node);
+        }
+        elements.forEach(function (node) {
+          eachCb(node);
+        });
+        if (this.iframes) {
+          this.handleOpenIframes(ifr, whatToShow, eachCb, filterCb);
+        }
+        doneCb();
+      }
+    }, {
+      key: 'forEachNode',
+      value: function forEachNode(whatToShow, each, filter) {
+        var _this6 = this;
+
+        var done = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+
+        var contexts = this.getContexts();
+        var open = contexts.length;
+        if (!open) {
+          done();
+        }
+        contexts.forEach(function (ctx) {
+          var ready = function ready() {
+            _this6.iterateThroughNodes(whatToShow, ctx, each, filter, function () {
+              if (--open <= 0) {
+                done();
+              }
+            });
+          };
+          if (_this6.iframes) {
+            _this6.waitForIframes(ctx, ready);
+          } else {
+            ready();
+          }
+        });
+      }
+    }], [{
+      key: 'matches',
+      value: function matches(element, selector) {
+        var selectors = typeof selector === 'string' ? [selector] : selector,
+            fn = element.matches || element.matchesSelector || element.msMatchesSelector || element.mozMatchesSelector || element.oMatchesSelector || element.webkitMatchesSelector;
+        if (fn) {
+          var match = false;
+          selectors.every(function (sel) {
+            if (fn.call(element, sel)) {
+              match = true;
+              return false;
+            }
+            return true;
+          });
+          return match;
+        } else {
+          return false;
+        }
+      }
+    }]);
+    return DOMIterator;
+  }();
+
+  var RegExpCreator = function () {
+    function RegExpCreator(options) {
+      classCallCheck(this, RegExpCreator);
+
+      this.opt = _extends({}, {
+        'diacritics': true,
+        'synonyms': {},
+        'accuracy': 'partially',
+        'caseSensitive': false,
+        'ignoreJoiners': false,
+        'ignorePunctuation': [],
+        'wildcards': 'disabled'
+      }, options);
+    }
+
+    createClass(RegExpCreator, [{
+      key: 'create',
+      value: function create(str) {
+        if (this.opt.wildcards !== 'disabled') {
+          str = this.setupWildcardsRegExp(str);
+        }
+        str = this.escapeStr(str);
+        if (Object.keys(this.opt.synonyms).length) {
+          str = this.createSynonymsRegExp(str);
+        }
+        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+          str = this.setupIgnoreJoinersRegExp(str);
+        }
+        if (this.opt.diacritics) {
+          str = this.createDiacriticsRegExp(str);
+        }
+        str = this.createMergedBlanksRegExp(str);
+        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+          str = this.createJoinersRegExp(str);
+        }
+        if (this.opt.wildcards !== 'disabled') {
+          str = this.createWildcardsRegExp(str);
+        }
+        str = this.createAccuracyRegExp(str);
+        return new RegExp(str, 'gm' + (this.opt.caseSensitive ? '' : 'i'));
+      }
+    }, {
+      key: 'escapeStr',
+      value: function escapeStr(str) {
+        return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+      }
+    }, {
+      key: 'createSynonymsRegExp',
+      value: function createSynonymsRegExp(str) {
+        var syn = this.opt.synonyms,
+            sens = this.opt.caseSensitive ? '' : 'i',
+            joinerPlaceholder = this.opt.ignoreJoiners || this.opt.ignorePunctuation.length ? '\0' : '';
+        for (var index in syn) {
+          if (syn.hasOwnProperty(index)) {
+            var value = syn[index],
+                k1 = this.opt.wildcards !== 'disabled' ? this.setupWildcardsRegExp(index) : this.escapeStr(index),
+                k2 = this.opt.wildcards !== 'disabled' ? this.setupWildcardsRegExp(value) : this.escapeStr(value);
+            if (k1 !== '' && k2 !== '') {
+              str = str.replace(new RegExp('(' + this.escapeStr(k1) + '|' + this.escapeStr(k2) + ')', 'gm' + sens), joinerPlaceholder + ('(' + this.processSynonyms(k1) + '|') + (this.processSynonyms(k2) + ')') + joinerPlaceholder);
+            }
+          }
+        }
+        return str;
+      }
+    }, {
+      key: 'processSynonyms',
+      value: function processSynonyms(str) {
+        if (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) {
+          str = this.setupIgnoreJoinersRegExp(str);
+        }
+        return str;
+      }
+    }, {
+      key: 'setupWildcardsRegExp',
+      value: function setupWildcardsRegExp(str) {
+        str = str.replace(/(?:\\)*\?/g, function (val) {
+          return val.charAt(0) === '\\' ? '?' : '\x01';
+        });
+        return str.replace(/(?:\\)*\*/g, function (val) {
+          return val.charAt(0) === '\\' ? '*' : '\x02';
+        });
+      }
+    }, {
+      key: 'createWildcardsRegExp',
+      value: function createWildcardsRegExp(str) {
+        var spaces = this.opt.wildcards === 'withSpaces';
+        return str.replace(/\u0001/g, spaces ? '[\\S\\s]?' : '\\S?').replace(/\u0002/g, spaces ? '[\\S\\s]*?' : '\\S*');
+      }
+    }, {
+      key: 'setupIgnoreJoinersRegExp',
+      value: function setupIgnoreJoinersRegExp(str) {
+        return str.replace(/[^(|)\\]/g, function (val, indx, original) {
+          var nextChar = original.charAt(indx + 1);
+          if (/[(|)\\]/.test(nextChar) || nextChar === '') {
+            return val;
+          } else {
+            return val + '\0';
+          }
+        });
+      }
+    }, {
+      key: 'createJoinersRegExp',
+      value: function createJoinersRegExp(str) {
+        var joiner = [];
+        var ignorePunctuation = this.opt.ignorePunctuation;
+        if (Array.isArray(ignorePunctuation) && ignorePunctuation.length) {
+          joiner.push(this.escapeStr(ignorePunctuation.join('')));
+        }
+        if (this.opt.ignoreJoiners) {
+          joiner.push('\\u00ad\\u200b\\u200c\\u200d');
+        }
+        return joiner.length ? str.split(/\u0000+/).join('[' + joiner.join('') + ']*') : str;
+      }
+    }, {
+      key: 'createDiacriticsRegExp',
+      value: function createDiacriticsRegExp(str) {
+        var sens = this.opt.caseSensitive ? '' : 'i',
+            dct = this.opt.caseSensitive ? ['aàáảãạăằắẳẵặâầấẩẫậäåāą', 'AÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ', 'cçćč', 'CÇĆČ', 'dđď', 'DĐĎ', 'eèéẻẽẹêềếểễệëěēę', 'EÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ', 'iìíỉĩịîïī', 'IÌÍỈĨỊÎÏĪ', 'lł', 'LŁ', 'nñňń', 'NÑŇŃ', 'oòóỏõọôồốổỗộơởỡớờợöøō', 'OÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ', 'rř', 'RŘ', 'sšśșş', 'SŠŚȘŞ', 'tťțţ', 'TŤȚŢ', 'uùúủũụưừứửữựûüůū', 'UÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ', 'yýỳỷỹỵÿ', 'YÝỲỶỸỴŸ', 'zžżź', 'ZŽŻŹ'] : ['aàáảãạăằắẳẵặâầấẩẫậäåāąAÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ', 'cçćčCÇĆČ', 'dđďDĐĎ', 'eèéẻẽẹêềếểễệëěēęEÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ', 'iìíỉĩịîïīIÌÍỈĨỊÎÏĪ', 'lłLŁ', 'nñňńNÑŇŃ', 'oòóỏõọôồốổỗộơởỡớờợöøōOÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ', 'rřRŘ', 'sšśșşSŠŚȘŞ', 'tťțţTŤȚŢ', 'uùúủũụưừứửữựûüůūUÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ', 'yýỳỷỹỵÿYÝỲỶỸỴŸ', 'zžżźZŽŻŹ'];
+        var handled = [];
+        str.split('').forEach(function (ch) {
+          dct.every(function (dct) {
+            if (dct.indexOf(ch) !== -1) {
+              if (handled.indexOf(dct) > -1) {
+                return false;
+              }
+              str = str.replace(new RegExp('[' + dct + ']', 'gm' + sens), '[' + dct + ']');
+              handled.push(dct);
+            }
+            return true;
+          });
+        });
+        return str;
+      }
+    }, {
+      key: 'createMergedBlanksRegExp',
+      value: function createMergedBlanksRegExp(str) {
+        return str.replace(/[\s]+/gmi, '[\\s]+');
+      }
+    }, {
+      key: 'createAccuracyRegExp',
+      value: function createAccuracyRegExp(str) {
+        var _this = this;
+
+        var chars = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~¡¿';
+        var acc = this.opt.accuracy,
+            val = typeof acc === 'string' ? acc : acc.value,
+            ls = typeof acc === 'string' ? [] : acc.limiters,
+            lsJoin = '';
+        ls.forEach(function (limiter) {
+          lsJoin += '|' + _this.escapeStr(limiter);
+        });
+        switch (val) {
+          case 'partially':
+          default:
+            return '()(' + str + ')';
+          case 'complementary':
+            lsJoin = '\\s' + (lsJoin ? lsJoin : this.escapeStr(chars));
+            return '()([^' + lsJoin + ']*' + str + '[^' + lsJoin + ']*)';
+          case 'exactly':
+            return '(^|\\s' + lsJoin + ')(' + str + ')(?=$|\\s' + lsJoin + ')';
+        }
+      }
+    }]);
+    return RegExpCreator;
+  }();
+
+  var Mark = function () {
+    function Mark(ctx) {
+      classCallCheck(this, Mark);
+
+      this.ctx = ctx;
+      this.ie = false;
+      var ua = window.navigator.userAgent;
+      if (ua.indexOf('MSIE') > -1 || ua.indexOf('Trident') > -1) {
+        this.ie = true;
+      }
+    }
+
+    createClass(Mark, [{
+      key: 'log',
+      value: function log(msg) {
+        var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'debug';
+
+        var log = this.opt.log;
+        if (!this.opt.debug) {
+          return;
+        }
+        if ((typeof log === 'undefined' ? 'undefined' : _typeof(log)) === 'object' && typeof log[level] === 'function') {
+          log[level]('mark.js: ' + msg);
+        }
+      }
+    }, {
+      key: 'getSeparatedKeywords',
+      value: function getSeparatedKeywords(sv) {
+        var _this = this;
+
+        var stack = [];
+        sv.forEach(function (kw) {
+          if (!_this.opt.separateWordSearch) {
+            if (kw.trim() && stack.indexOf(kw) === -1) {
+              stack.push(kw);
+            }
+          } else {
+            kw.split(' ').forEach(function (kwSplitted) {
+              if (kwSplitted.trim() && stack.indexOf(kwSplitted) === -1) {
+                stack.push(kwSplitted);
+              }
+            });
+          }
+        });
+        return {
+          'keywords': stack.sort(function (a, b) {
+            return b.length - a.length;
+          }),
+          'length': stack.length
+        };
+      }
+    }, {
+      key: 'isNumeric',
+      value: function isNumeric(value) {
+        return Number(parseFloat(value)) == value;
+      }
+    }, {
+      key: 'checkRanges',
+      value: function checkRanges(array) {
+        var _this2 = this;
+
+        if (!Array.isArray(array) || Object.prototype.toString.call(array[0]) !== '[object Object]') {
+          this.log('markRanges() will only accept an array of objects');
+          this.opt.noMatch(array);
+          return [];
+        }
+        var stack = [];
+        var last = 0;
+        array.sort(function (a, b) {
+          return a.start - b.start;
+        }).forEach(function (item) {
+          var _callNoMatchOnInvalid = _this2.callNoMatchOnInvalidRanges(item, last),
+              start = _callNoMatchOnInvalid.start,
+              end = _callNoMatchOnInvalid.end,
+              valid = _callNoMatchOnInvalid.valid;
+
+          if (valid) {
+            item.start = start;
+            item.length = end - start;
+            stack.push(item);
+            last = end;
+          }
+        });
+        return stack;
+      }
+    }, {
+      key: 'callNoMatchOnInvalidRanges',
+      value: function callNoMatchOnInvalidRanges(range, last) {
+        var start = void 0,
+            end = void 0,
+            valid = false;
+        if (range && typeof range.start !== 'undefined') {
+          start = parseInt(range.start, 10);
+          end = start + parseInt(range.length, 10);
+          if (this.isNumeric(range.start) && this.isNumeric(range.length) && end - last > 0 && end - start > 0) {
+            valid = true;
+          } else {
+            this.log('Ignoring invalid or overlapping range: ' + ('' + JSON.stringify(range)));
+            this.opt.noMatch(range);
+          }
+        } else {
+          this.log('Ignoring invalid range: ' + JSON.stringify(range));
+          this.opt.noMatch(range);
+        }
+        return {
+          start: start,
+          end: end,
+          valid: valid
+        };
+      }
+    }, {
+      key: 'checkWhitespaceRanges',
+      value: function checkWhitespaceRanges(range, originalLength, string) {
+        var end = void 0,
+            valid = true,
+            max = string.length,
+            offset = originalLength - max,
+            start = parseInt(range.start, 10) - offset;
+        start = start > max ? max : start;
+        end = start + parseInt(range.length, 10);
+        if (end > max) {
+          end = max;
+          this.log('End range automatically set to the max value of ' + max);
+        }
+        if (start < 0 || end - start < 0 || start > max || end > max) {
+          valid = false;
+          this.log('Invalid range: ' + JSON.stringify(range));
+          this.opt.noMatch(range);
+        } else if (string.substring(start, end).replace(/\s+/g, '') === '') {
+          valid = false;
+          this.log('Skipping whitespace only range: ' + JSON.stringify(range));
+          this.opt.noMatch(range);
+        }
+        return {
+          start: start,
+          end: end,
+          valid: valid
+        };
+      }
+    }, {
+      key: 'getTextNodes',
+      value: function getTextNodes(cb) {
+        var _this3 = this;
+
+        var val = '',
+            nodes = [];
+        this.iterator.forEachNode(NodeFilter.SHOW_TEXT, function (node) {
+          nodes.push({
+            start: val.length,
+            end: (val += node.textContent).length,
+            node: node
+          });
+        }, function (node) {
+          if (_this3.matchesExclude(node.parentNode)) {
+            return NodeFilter.FILTER_REJECT;
+          } else {
+            return NodeFilter.FILTER_ACCEPT;
+          }
+        }, function () {
+          cb({
+            value: val,
+            nodes: nodes
+          });
+        });
+      }
+    }, {
+      key: 'matchesExclude',
+      value: function matchesExclude(el) {
+        return DOMIterator.matches(el, this.opt.exclude.concat(['script', 'style', 'title', 'head', 'html']));
+      }
+    }, {
+      key: 'wrapRangeInTextNode',
+      value: function wrapRangeInTextNode(node, start, end) {
+        var hEl = !this.opt.element ? 'mark' : this.opt.element,
+            startNode = node.splitText(start),
+            ret = startNode.splitText(end - start);
+        var repl = document.createElement(hEl);
+        repl.setAttribute('data-markjs', 'true');
+        if (this.opt.className) {
+          repl.setAttribute('class', this.opt.className);
+        }
+        repl.textContent = startNode.textContent;
+        startNode.parentNode.replaceChild(repl, startNode);
+        return ret;
+      }
+    }, {
+      key: 'wrapRangeInMappedTextNode',
+      value: function wrapRangeInMappedTextNode(dict, start, end, filterCb, eachCb) {
+        var _this4 = this;
+
+        dict.nodes.every(function (n, i) {
+          var sibl = dict.nodes[i + 1];
+          if (typeof sibl === 'undefined' || sibl.start > start) {
+            if (!filterCb(n.node)) {
+              return false;
+            }
+            var s = start - n.start,
+                e = (end > n.end ? n.end : end) - n.start,
+                startStr = dict.value.substr(0, n.start),
+                endStr = dict.value.substr(e + n.start);
+            n.node = _this4.wrapRangeInTextNode(n.node, s, e);
+            dict.value = startStr + endStr;
+            dict.nodes.forEach(function (k, j) {
+              if (j >= i) {
+                if (dict.nodes[j].start > 0 && j !== i) {
+                  dict.nodes[j].start -= e;
+                }
+                dict.nodes[j].end -= e;
+              }
+            });
+            end -= e;
+            eachCb(n.node.previousSibling, n.start);
+            if (end > n.end) {
+              start = n.end;
+            } else {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+    }, {
+      key: 'wrapGroups',
+      value: function wrapGroups(node, pos, len, eachCb) {
+        node = this.wrapRangeInTextNode(node, pos, pos + len);
+        eachCb(node.previousSibling);
+        return node;
+      }
+    }, {
+      key: 'separateGroups',
+      value: function separateGroups(node, match, matchIdx, filterCb, eachCb) {
+        var matchLen = match.length;
+        for (var i = 1; i < matchLen; i++) {
+          var pos = node.textContent.indexOf(match[i]);
+          if (match[i] && pos > -1 && filterCb(match[i], node)) {
+            node = this.wrapGroups(node, pos, match[i].length, eachCb);
+          }
+        }
+        return node;
+      }
+    }, {
+      key: 'wrapMatches',
+      value: function wrapMatches(regex, ignoreGroups, filterCb, eachCb, endCb) {
+        var _this5 = this;
+
+        var matchIdx = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+        this.getTextNodes(function (dict) {
+          dict.nodes.forEach(function (node) {
+            node = node.node;
+            var match = void 0;
+            while ((match = regex.exec(node.textContent)) !== null && match[matchIdx] !== '') {
+              if (_this5.opt.separateGroups) {
+                node = _this5.separateGroups(node, match, matchIdx, filterCb, eachCb);
+              } else {
+                if (!filterCb(match[matchIdx], node)) {
+                  continue;
+                }
+                var pos = match.index;
+                if (matchIdx !== 0) {
+                  for (var i = 1; i < matchIdx; i++) {
+                    pos += match[i].length;
+                  }
+                }
+                node = _this5.wrapGroups(node, pos, match[matchIdx].length, eachCb);
+              }
+              regex.lastIndex = 0;
+            }
+          });
+          endCb();
+        });
+      }
+    }, {
+      key: 'wrapMatchesAcrossElements',
+      value: function wrapMatchesAcrossElements(regex, ignoreGroups, filterCb, eachCb, endCb) {
+        var _this6 = this;
+
+        var matchIdx = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+        this.getTextNodes(function (dict) {
+          var match = void 0;
+          while ((match = regex.exec(dict.value)) !== null && match[matchIdx] !== '') {
+            var start = match.index;
+            if (matchIdx !== 0) {
+              for (var i = 1; i < matchIdx; i++) {
+                start += match[i].length;
+              }
+            }
+            var end = start + match[matchIdx].length;
+            _this6.wrapRangeInMappedTextNode(dict, start, end, function (node) {
+              return filterCb(match[matchIdx], node);
+            }, function (node, lastIndex) {
+              regex.lastIndex = lastIndex;
+              eachCb(node);
+            });
+          }
+          endCb();
+        });
+      }
+    }, {
+      key: 'wrapRangeFromIndex',
+      value: function wrapRangeFromIndex(ranges, filterCb, eachCb, endCb) {
+        var _this7 = this;
+
+        this.getTextNodes(function (dict) {
+          var originalLength = dict.value.length;
+          ranges.forEach(function (range, counter) {
+            var _checkWhitespaceRange = _this7.checkWhitespaceRanges(range, originalLength, dict.value),
+                start = _checkWhitespaceRange.start,
+                end = _checkWhitespaceRange.end,
+                valid = _checkWhitespaceRange.valid;
+
+            if (valid) {
+              _this7.wrapRangeInMappedTextNode(dict, start, end, function (node) {
+                return filterCb(node, range, dict.value.substring(start, end), counter);
+              }, function (node) {
+                eachCb(node, range);
+              });
+            }
+          });
+          endCb();
+        });
+      }
+    }, {
+      key: 'unwrapMatches',
+      value: function unwrapMatches(node) {
+        var parent = node.parentNode;
+        var docFrag = document.createDocumentFragment();
+        while (node.firstChild) {
+          docFrag.appendChild(node.removeChild(node.firstChild));
+        }
+        parent.replaceChild(docFrag, node);
+        if (!this.ie) {
+          parent.normalize();
+        } else {
+          this.normalizeTextNode(parent);
+        }
+      }
+    }, {
+      key: 'normalizeTextNode',
+      value: function normalizeTextNode(node) {
+        if (!node) {
+          return;
+        }
+        if (node.nodeType === 3) {
+          while (node.nextSibling && node.nextSibling.nodeType === 3) {
+            node.nodeValue += node.nextSibling.nodeValue;
+            node.parentNode.removeChild(node.nextSibling);
+          }
+        } else {
+          this.normalizeTextNode(node.firstChild);
+        }
+        this.normalizeTextNode(node.nextSibling);
+      }
+    }, {
+      key: 'markRegExp',
+      value: function markRegExp(regexp, opt) {
+        var _this8 = this;
+
+        this.opt = opt;
+        this.log('Searching with expression "' + regexp + '"');
+        var totalMatches = 0,
+            fn = 'wrapMatches';
+        var eachCb = function eachCb(element) {
+          totalMatches++;
+          _this8.opt.each(element);
+        };
+        if (this.opt.acrossElements) {
+          fn = 'wrapMatchesAcrossElements';
+        }
+        this[fn](regexp, this.opt.ignoreGroups, function (match, node) {
+          return _this8.opt.filter(node, match, totalMatches);
+        }, eachCb, function () {
+          if (totalMatches === 0) {
+            _this8.opt.noMatch(regexp);
+          }
+          _this8.opt.done(totalMatches);
+        });
+      }
+    }, {
+      key: 'mark',
+      value: function mark(sv, opt) {
+        var _this9 = this;
+
+        this.opt = opt;
+        var totalMatches = 0,
+            fn = 'wrapMatches';
+
+        var _getSeparatedKeywords = this.getSeparatedKeywords(typeof sv === 'string' ? [sv] : sv),
+            kwArr = _getSeparatedKeywords.keywords,
+            kwArrLen = _getSeparatedKeywords.length,
+            handler = function handler(kw) {
+          var regex = new RegExpCreator(_this9.opt).create(kw);
+          var matches = 0;
+          _this9.log('Searching with expression "' + regex + '"');
+          _this9[fn](regex, 1, function (term, node) {
+            return _this9.opt.filter(node, kw, totalMatches, matches);
+          }, function (element) {
+            matches++;
+            totalMatches++;
+            _this9.opt.each(element);
+          }, function () {
+            if (matches === 0) {
+              _this9.opt.noMatch(kw);
+            }
+            if (kwArr[kwArrLen - 1] === kw) {
+              _this9.opt.done(totalMatches);
+            } else {
+              handler(kwArr[kwArr.indexOf(kw) + 1]);
+            }
+          });
+        };
+
+        if (this.opt.acrossElements) {
+          fn = 'wrapMatchesAcrossElements';
+        }
+        if (kwArrLen === 0) {
+          this.opt.done(totalMatches);
+        } else {
+          handler(kwArr[0]);
+        }
+      }
+    }, {
+      key: 'markRanges',
+      value: function markRanges(rawRanges, opt) {
+        var _this10 = this;
+
+        this.opt = opt;
+        var totalMatches = 0,
+            ranges = this.checkRanges(rawRanges);
+        if (ranges && ranges.length) {
+          this.log('Starting to mark with the following ranges: ' + JSON.stringify(ranges));
+          this.wrapRangeFromIndex(ranges, function (node, range, match, counter) {
+            return _this10.opt.filter(node, range, match, counter);
+          }, function (element, range) {
+            totalMatches++;
+            _this10.opt.each(element, range);
+          }, function () {
+            _this10.opt.done(totalMatches);
+          });
+        } else {
+          this.opt.done(totalMatches);
+        }
+      }
+    }, {
+      key: 'unmark',
+      value: function unmark(opt) {
+        var _this11 = this;
+
+        this.opt = opt;
+        var sel = this.opt.element ? this.opt.element : '*';
+        sel += '[data-markjs]';
+        if (this.opt.className) {
+          sel += '.' + this.opt.className;
+        }
+        this.log('Removal selector "' + sel + '"');
+        this.iterator.forEachNode(NodeFilter.SHOW_ELEMENT, function (node) {
+          _this11.unwrapMatches(node);
+        }, function (node) {
+          var matchesSel = DOMIterator.matches(node, sel),
+              matchesExclude = _this11.matchesExclude(node);
+          if (!matchesSel || matchesExclude) {
+            return NodeFilter.FILTER_REJECT;
+          } else {
+            return NodeFilter.FILTER_ACCEPT;
+          }
+        }, this.opt.done);
+      }
+    }, {
+      key: 'opt',
+      set: function set$$1(val) {
+        this._opt = _extends({}, {
+          'element': '',
+          'className': '',
+          'exclude': [],
+          'iframes': false,
+          'iframesTimeout': 5000,
+          'separateWordSearch': true,
+          'acrossElements': false,
+          'ignoreGroups': 0,
+          'each': function each() {},
+          'noMatch': function noMatch() {},
+          'filter': function filter() {
+            return true;
+          },
+          'done': function done() {},
+          'debug': false,
+          'log': window.console
+        }, val);
+      },
+      get: function get$$1() {
+        return this._opt;
+      }
+    }, {
+      key: 'iterator',
+      get: function get$$1() {
+        return new DOMIterator(this.ctx, this.opt.iframes, this.opt.exclude, this.opt.iframesTimeout);
+      }
+    }]);
+    return Mark;
+  }();
+
+  $.fn.mark = function (sv, opt) {
+    new Mark(this.get()).mark(sv, opt);
+    return this;
+  };
+  $.fn.markRegExp = function (regexp, opt) {
+    new Mark(this.get()).markRegExp(regexp, opt);
+    return this;
+  };
+  $.fn.markRanges = function (ranges, opt) {
+    new Mark(this.get()).markRanges(ranges, opt);
+    return this;
+  };
+  $.fn.unmark = function (opt) {
+    new Mark(this.get()).unmark(opt);
+    return this;
+  };
+
+  return $;
+
+})));