@ohos-ports/advanced-mark.js 3.0.0-beta.0

package/dist/mark.js

@@ -0,0 +1,1682 @@
+/*!***************************************************
+* advanced-mark.js v3.0.0
+* https://github.com/angezid/advanced-mark.js
+* MIT licensed
+* Copyright (c) 2022–2026, angezid
+* Based on 'mark.js', license https://git.io/vwTVl
+*****************************************************/
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Mark = factory());
+})(this, (function () { 'use strict';
+
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a 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, _toPropertyKey(descriptor.key), descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : 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;
+    };
+    return _extends.apply(this, arguments);
+  }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+
+  var DOMIterator = /*#__PURE__*/function () {
+    function DOMIterator(ctx, opt) {
+      _classCallCheck(this, DOMIterator);
+      this.ctx = ctx;
+      this.opt = opt;
+      this.map = new Map();
+    }
+    _createClass(DOMIterator, [{
+      key: "getContexts",
+      value: function getContexts() {
+        var ctx = this.ctx,
+          win = this.opt.window,
+          sort = false;
+        if (!ctx) return [];
+        if (Array.isArray(ctx)) {
+          sort = true;
+        } else if (typeof ctx === 'string') {
+          ctx = win.document.querySelectorAll(ctx);
+        } else if (typeof ctx.length === 'undefined') {
+          ctx = [ctx];
+        }
+        var array = [];
+        var _loop = function _loop(i) {
+          if (!array.includes(ctx[i]) && !array.some(function (node) {
+            return node.contains(ctx[i]);
+          })) {
+            array.push(ctx[i]);
+          }
+        };
+        for (var i = 0; i < ctx.length; i++) {
+          _loop(i);
+        }
+        if (sort) {
+          array.sort(function (a, b) {
+            return (a.compareDocumentPosition(b) & win.Node.DOCUMENT_POSITION_FOLLOWING) > 0 ? -1 : 1;
+          });
+        }
+        return array;
+      }
+    }, {
+      key: "getIframeContents",
+      value: function getIframeContents(iframe, successFn, errorFn) {
+        try {
+          var doc = iframe.contentWindow.document;
+          if (doc) {
+            this.map.set(iframe, 'ready');
+            successFn({
+              iframe: iframe,
+              context: doc
+            });
+          }
+        } catch (e) {
+          errorFn({
+            iframe: iframe,
+            error: e
+          });
+        }
+      }
+    }, {
+      key: "observeIframeLoad",
+      value: function observeIframeLoad(ifr, successFn, errorFn) {
+        var _this = this;
+        if (this.map.has(ifr)) return;
+        var id = null;
+        var listener = function listener() {
+          clearTimeout(id);
+          ifr.removeEventListener('load', listener);
+          _this.getIframeContents(ifr, successFn, errorFn);
+        };
+        ifr.addEventListener('load', listener);
+        this.map.set(ifr, true);
+        id = setTimeout(listener, this.opt.iframesTimeout);
+      }
+    }, {
+      key: "onIframeReady",
+      value: function onIframeReady(ifr, successFn, errorFn) {
+        var bl = 'about:blank',
+          src = ifr.getAttribute('src'),
+          win = ifr.contentWindow;
+        try {
+          if (win.document.readyState !== 'complete' || src && src.trim() !== bl && win.location.href === bl) {
+            this.observeIframeLoad(ifr, successFn, errorFn);
+          } else {
+            this.getIframeContents(ifr, successFn, errorFn);
+          }
+        } catch (e) {
+          errorFn(e);
+        }
+      }
+    }, {
+      key: "waitForIframes",
+      value: function waitForIframes(ctx, doneCb) {
+        var _this2 = this;
+        var shadow = this.opt.shadowDOM;
+        var count = 0,
+          iframes = 0,
+          array,
+          node;
+        var collect = function collect(context) {
+          var iterator = _this2.createIterator(context, _this2.opt.window.NodeFilter.SHOW_ELEMENT);
+          while (node = iterator.nextNode()) {
+            if (_this2.isIframe(node) && !_this2.map.has(node)) {
+              array.push(node);
+              iframes++;
+            }
+            if (shadow && node.shadowRoot && node.shadowRoot.mode === 'open') {
+              collect(node.shadowRoot);
+            }
+          }
+        };
+        var loop = function loop(obj) {
+          array = [];
+          if (!obj.iframe || obj.context.location.href !== 'about:blank') {
+            collect(obj.context);
+            if (!obj.iframe && !array.length) {
+              doneCb();
+              return;
+            }
+          }
+          if (array.length) {
+            array.forEach(function (iframe) {
+              _this2.onIframeReady(iframe, function (obj) {
+                count++;
+                loop(obj);
+              }, function (obj) {
+                if (_this2.opt.debug) {
+                  console.log(obj.error || obj);
+                }
+                if (++count === iframes) doneCb();
+              });
+            });
+          } else if (count === iframes) {
+            doneCb();
+          }
+        };
+        loop({
+          context: ctx
+        });
+      }
+    }, {
+      key: "createIterator",
+      value: function createIterator(ctx, whatToShow) {
+        var win = this.opt.window;
+        return win.document.createNodeIterator(ctx, whatToShow, function () {
+          return win.NodeFilter.FILTER_ACCEPT;
+        }, false);
+      }
+    }, {
+      key: "addRemoveStyle",
+      value: function addRemoveStyle(root, style, add) {
+        if (add && !style) return;
+        var elem = root.querySelector('style[data-markjs]');
+        if (add) {
+          if (!elem) {
+            elem = this.opt.window.document.createElement('style');
+            elem.setAttribute('data-markjs', 'true');
+            root.appendChild(elem);
+          }
+          elem.textContent = style;
+        } else if (elem) {
+          root.removeChild(elem);
+        }
+      }
+    }, {
+      key: "isIframe",
+      value: function isIframe(node) {
+        return node.tagName === 'IFRAME' && !DOMIterator.matches(node, this.opt.exclude);
+      }
+    }, {
+      key: "iterateThroughNodes",
+      value: function iterateThroughNodes(ctx, whatToShow, filterCb, eachCb, doneCb) {
+        var _this3 = this;
+        var filter = this.opt.window.NodeFilter,
+          shadow = this.opt.shadowDOM,
+          iframe = this.opt.iframes;
+        if (iframe || shadow) {
+          var showElement = (whatToShow & filter.SHOW_ELEMENT) > 0,
+            showText = (whatToShow & filter.SHOW_TEXT) > 0;
+          var traverse = function traverse(node) {
+            var iterator = _this3.createIterator(node, whatToShow | filter.SHOW_ELEMENT),
+              root;
+            while (node = iterator.nextNode()) {
+              if (node.nodeType === 1) {
+                if (showElement && filterCb(node)) {
+                  eachCb(node);
+                }
+                if (iframe && _this3.isIframe(node) && _this3.map.get(node) === 'ready') {
+                  var doc = node.contentWindow.document;
+                  if (doc) {
+                    if (_this3.opt.highlight && showText) {
+                      node.contentWindow.CSS.highlights.set(_this3.opt.highlightName, _this3.opt.highlight);
+                    }
+                    _this3.addRemoveStyle(doc.head, iframe.style, showText);
+                    traverse(doc);
+                  }
+                }
+                if (shadow && (root = node.shadowRoot) && root.mode === 'open') {
+                  _this3.addRemoveStyle(root, shadow.style, showText);
+                  traverse(root);
+                }
+              } else if (showText && node.nodeType === 3 && filterCb(node)) {
+                eachCb(node);
+              }
+            }
+          };
+          traverse(ctx);
+        } else {
+          var iterator = this.createIterator(ctx, whatToShow);
+          var node;
+          while (node = iterator.nextNode()) {
+            if (filterCb(node)) {
+              eachCb(node);
+            }
+          }
+        }
+        doneCb();
+      }
+    }, {
+      key: "forEachNode",
+      value: function forEachNode(whatToShow, each, filter) {
+        var _this4 = this;
+        var done = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+        var contexts = this.getContexts();
+        var open = contexts.length;
+        if (!open) done();
+        var ready = function ready() {
+          contexts.forEach(function (ctx) {
+            _this4.iterateThroughNodes(ctx, whatToShow, filter, each, function () {
+              if (--open <= 0) done();
+            });
+          });
+        };
+        if (this.opt.iframes) {
+          var count = open;
+          contexts.forEach(function (ctx) {
+            _this4.waitForIframes(ctx, function () {
+              if (--count <= 0) ready();
+            });
+          });
+        } else {
+          ready();
+        }
+      }
+    }], [{
+      key: "matches",
+      value: function matches(element, selector) {
+        if (!selector || !selector.length) {
+          return false;
+        }
+        var selectors = typeof selector === 'string' ? [selector] : selector,
+          fn = element.matches;
+        return fn && selectors.some(function (sel) {
+          return fn.call(element, sel);
+        });
+      }
+    }]);
+    return DOMIterator;
+  }();
+
+  var RegExpCreator = /*#__PURE__*/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: "chars",
+      get: function get() {
+        var _this = this;
+        if (!this._chars) {
+          this._chars = [];
+          ['aàáảãạăằắẳẵặâầấẩẫậäåāą', 'cçćč', 'dđď', 'eèéẻẽẹêềếểễệëěēę', 'iìíỉĩịîïī', 'lł', 'nñňń', 'oòóỏõọôồốổỗộơởỡớờợöøōő', 'rř', 'sšśșş', 'tťțţ', 'uùúủũụưừứửữựûüůūű', 'yýỳỷỹỵÿ', 'zžżź'].forEach(function (str) {
+            _this._chars.push(str, str.toUpperCase());
+          });
+        }
+        return this._chars;
+      }
+    }, {
+      key: "create",
+      value: function create(terms) {
+        var _this2 = this;
+        var flags = "g".concat(this.opt.caseSensitive ? '' : 'i');
+        terms = terms.map(function (str) {
+          return '(' + _this2.createPattern(str, flags) + ')';
+        });
+        var obj = this.createAccuracy(terms.join('|'));
+        return new RegExp("".concat(obj.lookbehind, "(").concat(obj.pattern, ")").concat(obj.lookahead), flags);
+      }
+    }, {
+      key: "createPattern",
+      value: function createPattern(str, flags) {
+        str = this.checkWildcardsEscape(str);
+        str = this.createSynonyms(str, flags);
+        var joiners = this.getJoinersPunctuation();
+        if (joiners) {
+          str = this.setupIgnoreJoiners(str);
+        }
+        if (this.opt.diacritics) {
+          str = this.createDiacritics(str);
+        }
+        str = str.replace(/\s+/g, '[\\s]+');
+        if (joiners) {
+          str = this.createJoiners(str, joiners);
+        }
+        if (this.opt.wildcards !== 'disabled') {
+          str = this.createWildcards(str);
+        }
+        return str;
+      }
+    }, {
+      key: "escape",
+      value: function escape(str) {
+        return str.replace(/[[\]/{}()*+?.\\^$|]/g, '\\$&');
+      }
+    }, {
+      key: "preprocess",
+      value: function preprocess(val) {
+        if (val && val.length) {
+          return this.distinct(typeof val === 'string' ? val.split('') : val).join('').replace(/[-^\]\\]/g, '\\$&');
+        }
+        return '';
+      }
+    }, {
+      key: "distinct",
+      value: function distinct(array) {
+        var result = [];
+        array.forEach(function (item) {
+          if (item.trim() && !result.includes(item)) {
+            result.push(item);
+          }
+        });
+        return result;
+      }
+    }, {
+      key: "createSynonyms",
+      value: function createSynonyms(str, flags) {
+        var _this3 = this;
+        var syn = this.opt.synonyms;
+        for (var key in syn) {
+          if (syn.hasOwnProperty(key)) {
+            var array = Array.isArray(syn[key]) ? syn[key] : [syn[key]];
+            array.unshift(key);
+            array = this.distinct(array);
+            if (array.length > 1) {
+              array.sort(function (a, b) {
+                return b.length - a.length;
+              });
+              array = array.map(function (term) {
+                return _this3.checkWildcardsEscape(term);
+              });
+              var pattern = array.map(function (term) {
+                return _this3.escape(term);
+              }).join('|');
+              str = str.replace(new RegExp(pattern, flags), "(?:".concat(array.join('|'), ")"));
+            }
+          }
+        }
+        return str;
+      }
+    }, {
+      key: "checkWildcardsEscape",
+      value: function checkWildcardsEscape(str) {
+        if (this.opt.wildcards !== 'disabled') {
+          str = str.replace(/(\\.)+|[?*]/g, function (m, gr) {
+            return gr ? m : m === '?' ? '\x01' : '\x02';
+          }).replace(/\\(?=[?*\x01\x02])/g, '');
+        }
+        return this.escape(str);
+      }
+    }, {
+      key: "createWildcards",
+      value: function createWildcards(str) {
+        var spaces = this.opt.wildcards === 'withSpaces',
+          boundary = this.opt.blockElementsBoundary,
+          anyChar = "[^".concat(spaces && boundary ? '\x01' : '', "]*?");
+        return str.replace(/\x01/g, spaces ? '[^]?' : '\\S?').replace(/\x02/g, spaces ? anyChar : '\\S*');
+      }
+    }, {
+      key: "setupIgnoreJoiners",
+      value: function setupIgnoreJoiners(str) {
+        var reg = /((?:\\\\)+|\x02|\(\?:|\|)|\\?(?:[\uD800-\uDBFF][\uDC00-\uDFFF]|.)(?=([|)\x02]|$)|.)/g;
+        return str.replace(reg, function (m, gr1, gr2) {
+          return gr1 || typeof gr2 !== 'undefined' ? m : m + '\x00';
+        });
+      }
+    }, {
+      key: "createJoiners",
+      value: function createJoiners(str, joiners) {
+        return str.split(/\x00+/).join("[".concat(joiners, "]*"));
+      }
+    }, {
+      key: "getJoinersPunctuation",
+      value: function getJoinersPunctuation() {
+        var punct = this.preprocess(this.opt.ignorePunctuation),
+          str = punct ? punct : '';
+        if (this.opt.ignoreJoiners) {
+          str += "\\u00ad\\u200b\\u200c\\u200d";
+        }
+        return str;
+      }
+    }, {
+      key: "createDiacritics",
+      value: function createDiacritics(str) {
+        var _this4 = this;
+        var array = this.chars;
+        return str.split('').map(function (ch) {
+          for (var i = 0; i < array.length; i += 2) {
+            var lowerCase = array[i].includes(ch);
+            if (_this4.opt.caseSensitive) {
+              if (lowerCase) {
+                return '[' + array[i] + ']';
+              }
+              if (array[i + 1].includes(ch)) {
+                return '[' + array[i + 1] + ']';
+              }
+            } else if (lowerCase || array[i + 1].includes(ch)) {
+              return '[' + array[i] + array[i + 1] + ']';
+            }
+          }
+          return ch;
+        }).join('');
+      }
+    }, {
+      key: "createAccuracy",
+      value: function createAccuracy(str) {
+        var chars = '!-/:-@[-`{-~¡¿';
+        var accuracy = this.opt.accuracy,
+          lookbehind = '()',
+          pattern = str,
+          lookahead = '',
+          limiters;
+        if (accuracy !== 'partially') {
+          if (typeof accuracy !== 'string') {
+            limiters = this.preprocess(accuracy.limiters);
+            accuracy = accuracy.value;
+          }
+          if (accuracy === 'exactly') {
+            var charSet = limiters ? '[\\s' + limiters + ']' : '\\s';
+            lookbehind = "(^|".concat(charSet, ")");
+            lookahead = "(?=$|".concat(charSet, ")");
+          } else {
+            var chs = limiters || chars,
+              _charSet = "[^\\s".concat(chs, "]*");
+            pattern = "(?:".concat(str, ")");
+            if (accuracy === 'complementary') {
+              pattern = _charSet + pattern + _charSet;
+            } else if (accuracy === 'startsWith') {
+              lookbehind = "(^|[\\s".concat(chs, "])");
+              pattern = pattern.split(/\[\\s\]\+/).join(_charSet + '[\\s]+') + _charSet;
+            }
+          }
+        }
+        return {
+          lookbehind: lookbehind,
+          pattern: pattern,
+          lookahead: lookahead
+        };
+      }
+    }]);
+    return RegExpCreator;
+  }();
+
+  var Mark$1 = /*#__PURE__*/function () {
+    function Mark(ctx) {
+      _classCallCheck(this, Mark);
+      this.ctx = ctx;
+      this.nodeNames = ['script', 'style', 'title', 'head', 'html'];
+    }
+    _createClass(Mark, [{
+      key: "opt",
+      get: function get() {
+        return this._opt;
+      },
+      set: function set(val) {
+        if (!(val && val.window && val.window.document) && typeof window === 'undefined') {
+          throw new Error('Mark.js: please provide a window object as an option.');
+        }
+        var win = val && val.window || window,
+          highlight = val && val.highlight && val.highlight instanceof Highlight;
+        this._opt = _extends({}, {
+          'window': win,
+          'element': '',
+          'className': '',
+          'exclude': [],
+          'iframes': false,
+          'iframesTimeout': 5000,
+          'separateWordSearch': true,
+          'staticRanges': true,
+          'rangeAcrossElements': true,
+          'acrossElements': false,
+          'ignoreGroups': 0,
+          'each': function each() {},
+          'noMatch': function noMatch() {},
+          'filter': function filter() {
+            return true;
+          },
+          'done': function done() {},
+          'debug': false,
+          'log': win.console
+        }, val);
+        if (!this._opt.element) {
+          this._opt.element = 'mark';
+        }
+        this.filter = win.NodeFilter;
+        this.empty = win.document.createTextNode('');
+        if (!this._opt.highlightName) {
+          this._opt.highlightName = 'advanced-markjs';
+        }
+        if (highlight) {
+          this.rangeArray = [];
+        } else {
+          this._opt.highlight = null;
+        }
+      }
+    }, {
+      key: "iterator",
+      get: function get() {
+        return new DOMIterator(this.ctx, this.opt);
+      }
+    }, {
+      key: "log",
+      value: function log(msg) {
+        var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'debug';
+        if (this.opt.debug) {
+          var log = this.opt.log;
+          if (_typeof(log) === 'object' && typeof log[level] === 'function') {
+            log[level]("mark.js: ".concat(msg));
+          }
+        }
+      }
+    }, {
+      key: "report",
+      value: function report(array) {
+        var _this = this;
+        array.forEach(function (item) {
+          _this.log("".concat(item.text, " ").concat(JSON.stringify(item.obj)), item.level || 'debug');
+          if (!item.skip) {
+            _this.opt.noMatch(item.obj);
+          }
+        });
+      }
+    }, {
+      key: "getSeachTerms",
+      value: function getSeachTerms(sv) {
+        var search = typeof sv === 'string' ? [sv] : sv,
+          separate = this.opt.separateWordSearch,
+          array = [],
+          termStats = {},
+          split = function split(str) {
+            str.split(/ +/).forEach(function (word) {
+              return add(word);
+            });
+          },
+          add = function add(str) {
+            if (str.trim() && !array.includes(str)) {
+              array.push(str);
+              termStats[str] = 0;
+            }
+          };
+        search.forEach(function (str) {
+          if (separate) {
+            if (separate === 'preserveTerms') {
+              str.split(/"("*[^"]+"*)"/).forEach(function (term, i) {
+                if (i % 2 > 0) add(term);else split(term);
+              });
+            } else {
+              split(str);
+            }
+          } else {
+            add(str);
+          }
+        });
+        array.sort(function (a, b) {
+          return b.length - a.length;
+        });
+        return {
+          terms: array,
+          termStats: termStats
+        };
+      }
+    }, {
+      key: "isNumeric",
+      value: function isNumeric(value) {
+        return Number(parseFloat(value)) == value;
+      }
+    }, {
+      key: "checkRanges",
+      value: function checkRanges(array, logs, min, max) {
+        var _this2 = this;
+        var level = 'error';
+        var ranges = array.filter(function (range) {
+          if (_this2.isNumeric(range.start) && _this2.isNumeric(range.length)) {
+            range.start = parseInt(range.start);
+            range.length = parseInt(range.length);
+            if (range.start >= min && range.start < max && range.length > 0) {
+              return true;
+            }
+          }
+          logs.push({
+            text: 'Invalid range: ',
+            obj: range,
+            level: level
+          });
+          return false;
+        }).sort(function (a, b) {
+          return a.start - b.start;
+        });
+        if (this.opt.wrapAllRanges) {
+          return ranges;
+        }
+        var lastIndex = 0,
+          index;
+        return ranges.filter(function (range) {
+          index = range.start + range.length;
+          if (range.start >= lastIndex) {
+            lastIndex = index;
+            return true;
+          }
+          logs.push({
+            text: (index < lastIndex ? 'Nest' : 'Overlapp') + 'ing range: ',
+            obj: range,
+            level: level
+          });
+          return false;
+        });
+      }
+    }, {
+      key: "setType",
+      value: function setType(tags, boundary) {
+        var custom = Array.isArray(boundary.tagNames) && boundary.tagNames.length;
+        if (custom) {
+          boundary.tagNames.forEach(function (name) {
+            return tags[name.toLowerCase()] = 2;
+          });
+        }
+        if (!custom || boundary.extend) {
+          for (var key in tags) {
+            tags[key] = 2;
+          }
+        }
+        tags['br'] = 3;
+      }
+    }, {
+      key: "getTextNodesAcross",
+      value: function getTextNodesAcross(cb) {
+        var _this3 = this;
+        var tags = {
+          div: 1,
+          p: 1,
+          li: 1,
+          td: 1,
+          tr: 1,
+          th: 1,
+          ul: 1,
+          ol: 1,
+          dd: 1,
+          dl: 1,
+          dt: 1,
+          h1: 1,
+          h2: 1,
+          h3: 1,
+          h4: 1,
+          h5: 1,
+          h6: 1,
+          hr: 1,
+          blockquote: 1,
+          figcaption: 1,
+          figure: 1,
+          pre: 1,
+          table: 1,
+          thead: 1,
+          tbody: 1,
+          tfoot: 1,
+          input: 1,
+          img: 1,
+          nav: 1,
+          details: 1,
+          label: 1,
+          form: 1,
+          select: 1,
+          menu: 1,
+          br: 3,
+          menuitem: 1,
+          main: 1,
+          section: 1,
+          article: 1,
+          aside: 1,
+          picture: 1,
+          output: 1,
+          button: 1,
+          header: 1,
+          footer: 1,
+          address: 1,
+          area: 1,
+          canvas: 1,
+          map: 1,
+          fieldset: 1,
+          textarea: 1,
+          track: 1,
+          video: 1,
+          audio: 1,
+          body: 1,
+          iframe: 1,
+          meter: 1,
+          object: 1,
+          svg: 1
+        };
+        var nodes = [],
+          boundary = this.opt.blockElementsBoundary,
+          priorityType = boundary ? 2 : 1;
+        var ch = '\x01',
+          tempType,
+          type,
+          prevNode;
+        if (boundary) {
+          this.setType(tags, boundary);
+          if (boundary["char"]) {
+            ch = boundary["char"].charAt(0);
+          }
+        }
+        var obj = {
+          text: '',
+          regex: /\s/,
+          tags: tags,
+          boundary: boundary,
+          str: '',
+          ch: ch
+        };
+        this.iterator.forEachNode(this.filter.SHOW_ELEMENT | this.filter.SHOW_TEXT, function (node) {
+          if (prevNode) {
+            nodes.push(_this3.getNodeInfo(prevNode, node, type, obj));
+          }
+          type = null;
+          prevNode = node;
+        }, function (node) {
+          if (node.nodeType === 1) {
+            tempType = tags[node.nodeName.toLowerCase()];
+            if (tempType === 3) {
+              obj.str += '\n';
+            }
+            if (!type || tempType === priorityType) {
+              type = tempType;
+            }
+            return false;
+          }
+          return !_this3.excluded(node.parentNode);
+        }, function () {
+          if (prevNode) {
+            nodes.push(_this3.getNodeInfo(prevNode, null, type, obj));
+          }
+          cb({
+            text: obj.text,
+            nodes: nodes,
+            lastIndex: 0
+          });
+        });
+      }
+    }, {
+      key: "getNodeInfo",
+      value: function getNodeInfo(prevNode, node, type, obj) {
+        var start = obj.text.length,
+          ch = obj.ch;
+        var offset = 0,
+          str = obj.str,
+          text = prevNode.textContent;
+        if (node) {
+          var startBySpace = obj.regex.test(node.textContent[0]),
+            both = startBySpace && obj.regex.test(text[text.length - 1]);
+          if (obj.boundary || !both) {
+            var separate = type;
+            if (!type) {
+              var parent = prevNode.parentNode;
+              while (parent) {
+                type = obj.tags[parent.nodeName.toLowerCase()];
+                if (type) {
+                  separate = !(parent === node.parentNode || parent.contains(node));
+                  break;
+                }
+                parent = parent.parentNode;
+              }
+            }
+            if (separate) {
+              if (!both) {
+                str += type === 1 ? ' ' : type === 2 ? ' ' + ch + ' ' : '';
+              } else if (type === 2) {
+                str += both ? ch : startBySpace ? ' ' + ch : ch + ' ';
+              }
+            }
+          }
+        }
+        if (str) {
+          text += str;
+          offset = str.length;
+          obj.str = '';
+        }
+        obj.text += text;
+        return this.createInfo(prevNode, start, obj.text.length - offset, offset);
+      }
+    }, {
+      key: "getRangesTextNodes",
+      value: function getRangesTextNodes(cb, lines) {
+        var _this4 = this;
+        var nodes = [],
+          regex = /\n/g,
+          newLines = [0],
+          show = this.filter.SHOW_TEXT | (lines ? this.filter.SHOW_ELEMENT : 0);
+        var text = '',
+          len = 0,
+          rm;
+        this.iterator.forEachNode(show, function (node) {
+          if (lines) {
+            while ((rm = regex.exec(node.textContent)) !== null) {
+              newLines.push(len + rm.index);
+            }
+          }
+          text += node.textContent;
+          nodes.push({
+            start: len,
+            end: len = text.length,
+            offset: 0,
+            node: node
+          });
+        }, function (node) {
+          if (lines && node.nodeType === 1) {
+            if (node.tagName.toLowerCase() === 'br') {
+              newLines.push(len);
+            }
+            return false;
+          }
+          return !_this4.excluded(node.parentNode);
+        }, function () {
+          var dict = {
+            text: text,
+            nodes: nodes,
+            lastIndex: 0
+          };
+          if (lines) {
+            newLines.push(len);
+            dict.newLines = newLines;
+          }
+          cb(dict);
+        });
+      }
+    }, {
+      key: "getTextNodes",
+      value: function getTextNodes(cb) {
+        var _this5 = this;
+        var nodes = [];
+        var start = 0;
+        this.iterator.forEachNode(this.filter.SHOW_TEXT, function (node) {
+          nodes.push({
+            node: node,
+            start: start
+          });
+          start += node.textContent.length;
+        }, function (node) {
+          return !_this5.excluded(node.parentNode);
+        }, function () {
+          cb({
+            nodes: nodes,
+            lastIndex: 0
+          });
+        });
+      }
+    }, {
+      key: "excluded",
+      value: function excluded(elem) {
+        return this.nodeNames.includes(elem.nodeName.toLowerCase()) || DOMIterator.matches(elem, this.opt.exclude);
+      }
+    }, {
+      key: "wrapRangeInsert",
+      value: function wrapRangeInsert(dict, n, s, e, start, index) {
+        var ended = e === n.node.textContent.length,
+          end = n.end;
+        var type = 1,
+          splitIndex = e,
+          node = n.node;
+        if (s !== 0) {
+          node = node.splitText(s);
+          splitIndex = e - s;
+          type = ended ? 2 : 3;
+        } else if (ended) {
+          type = 0;
+        }
+        var retNode = ended ? this.empty : node.splitText(splitIndex),
+          mark = this.createElement(node),
+          markChild = mark.childNodes[0],
+          nodeInfo = this.createInfo(retNode, type === 0 || type === 2 ? end : n.start + e, end, n.offset);
+        if (type === 0) {
+          n.node = markChild;
+          return {
+            mark: mark,
+            nodeInfo: nodeInfo,
+            increment: 0
+          };
+        }
+        var info = this.createInfo(markChild, type === 1 ? n.start : start, n.start + e, 0);
+        if (type === 1) {
+          dict.nodes.splice(index, 1, info, nodeInfo);
+        } else {
+          if (type === 2) {
+            dict.nodes.splice(index + 1, 0, info);
+          } else {
+            dict.nodes.splice(index + 1, 0, info, nodeInfo);
+          }
+          n.end = start;
+          n.offset = 0;
+        }
+        return {
+          mark: mark,
+          nodeInfo: nodeInfo,
+          increment: type < 3 ? 1 : 2
+        };
+      }
+    }, {
+      key: "createInfo",
+      value: function createInfo(node, start, end, offset) {
+        return {
+          node: node,
+          start: start,
+          end: end,
+          offset: offset
+        };
+      }
+    }, {
+      key: "wrapRange",
+      value: function wrapRange(n, start, end, eachCb) {
+        var node = n.node,
+          retNode;
+        if (this.rangeArray) {
+          this.createRange(node, start, node, end, n.start + start, eachCb);
+          retNode = node;
+        } else {
+          var ended = end === node.textContent.length,
+            index = end;
+          if (start !== 0) {
+            node = node.splitText(start);
+            index = end - start;
+          }
+          retNode = ended ? this.empty : node.splitText(index);
+          eachCb(this.createElement(node));
+        }
+        return retNode;
+      }
+    }, {
+      key: "createRange",
+      value: function createRange(startNode, startOffset, endNode, endOffset, absoluteOffset, eachCb) {
+        var range;
+        if (this.opt.staticRanges) {
+          range = new StaticRange({
+            startContainer: startNode,
+            startOffset: startOffset,
+            endContainer: endNode,
+            endOffset: endOffset
+          });
+        } else {
+          range = new Range();
+          range.setStart(startNode, startOffset);
+          range.setEnd(endNode, endOffset);
+        }
+        range.absoluteOffset = absoluteOffset;
+        eachCb(range, true);
+        if (range) this.rangeArray.push(range);
+      }
+    }, {
+      key: "createElement",
+      value: function createElement(node) {
+        var markNode = this.opt.window.document.createElement(this.opt.element);
+        markNode.setAttribute('data-markjs', 'true');
+        if (this.opt.className) {
+          markNode.setAttribute('class', this.opt.className);
+        }
+        markNode.textContent = node.textContent;
+        node.parentNode.replaceChild(markNode, node);
+        return markNode;
+      }
+    }, {
+      key: "wrapRangeAcross",
+      value: function wrapRangeAcross(dict, start, end, filterCb, eachCb) {
+        var i = dict.lastIndex,
+          rangeStart = true,
+          startInfo,
+          filterNodes = [],
+          e;
+        var wrapAllRanges = this.opt.wrapAllRanges,
+          highlightAPI = !!this.opt.highlight,
+          singleRange = highlightAPI && this.opt.rangeAcrossElements;
+        if (wrapAllRanges) {
+          while (i > 0 && dict.nodes[i].start > start) {
+            i--;
+          }
+        }
+        for (i; i < dict.nodes.length; i++) {
+          if (i + 1 === dict.nodes.length || dict.nodes[i + 1].start > start) {
+            var n = dict.nodes[i];
+            if (singleRange) {
+              filterNodes.push(n.node);
+            } else if (!filterCb(n.node)) {
+              break;
+            }
+            var s = start - n.start;
+            e = (end > n.end ? n.end : end) - n.start;
+            if (s >= 0 && e > s) {
+              if (singleRange) {
+                if (rangeStart) {
+                  startInfo = [n.node, s, n.start + s];
+                }
+              } else if (!highlightAPI && wrapAllRanges) {
+                var obj = this.wrapRangeInsert(dict, n, s, e, start, i);
+                n = obj.nodeInfo;
+                eachCb(obj.mark, rangeStart);
+              } else {
+                n.node = this.wrapRange(n, s, e, function (elemOrRange) {
+                  eachCb(elemOrRange, rangeStart);
+                });
+                if (!highlightAPI) n.start += e;
+              }
+              rangeStart = false;
+            }
+            if (end > n.end) {
+              start = n.end + n.offset;
+            } else {
+              if (startInfo && filterCb(filterNodes)) {
+                this.createRange(startInfo[0], startInfo[1], n.node, e, startInfo[2], eachCb);
+              }
+              break;
+            }
+          }
+        }
+        dict.lastIndex = i;
+      }
+    }, {
+      key: "wrapGroups",
+      value: function wrapGroups(n, match, regex, filterCb, eachCb) {
+        var lastIndex = 0,
+          offset = 0,
+          i = 0,
+          highlightAPI = this.opt.highlight,
+          isWrapped = false,
+          group,
+          start,
+          end = 0;
+        while (++i < match.length) {
+          group = match[i];
+          if (group) {
+            start = match.indices[i][0];
+            if (start >= lastIndex) {
+              end = match.indices[i][1];
+              if (filterCb(n.node, group, i)) {
+                n.node = this.wrapRange(n, start - offset, end - offset, function (elemOrRange) {
+                  eachCb(elemOrRange);
+                });
+                if (end > lastIndex) {
+                  lastIndex = end;
+                }
+                if (!highlightAPI) offset = end;
+                isWrapped = true;
+              }
+            }
+          }
+        }
+        if (isWrapped) {
+          if (!highlightAPI) regex.lastIndex = 0;
+        } else if (match[0].length === 0) {
+          this.setLastIndex(regex, end);
+        }
+      }
+    }, {
+      key: "wrapGroupsAcross",
+      value: function wrapGroupsAcross(dict, match, regex, filterCb, eachCb) {
+        var lastIndex = 0,
+          i = 0,
+          end = 0,
+          start,
+          group,
+          isWrapped;
+        while (++i < match.length) {
+          group = match[i];
+          if (group) {
+            start = match.indices[i][0];
+            if (this.opt.wrapAllRanges || start >= lastIndex) {
+              end = match.indices[i][1];
+              isWrapped = false;
+              this.wrapRangeAcross(dict, start, end, function (nodeOrArray) {
+                return filterCb(nodeOrArray, group, i);
+              }, function (elemOrRange, groupStart) {
+                isWrapped = true;
+                eachCb(elemOrRange, groupStart);
+              });
+              if (isWrapped && end > lastIndex) {
+                lastIndex = end;
+              }
+            }
+          }
+        }
+        if (match[0].length === 0) {
+          this.setLastIndex(regex, end);
+        }
+      }
+    }, {
+      key: "setLastIndex",
+      value: function setLastIndex(regex, end) {
+        var index = regex.lastIndex;
+        regex.lastIndex = end > index ? end : end > 0 ? index + 1 : Infinity;
+      }
+    }, {
+      key: "processGroups",
+      value: function processGroups(regex, unused, info, filterCb, eachCb, endCb) {
+        var _this6 = this;
+        var count = info.count,
+          match,
+          filterStart,
+          eachStart;
+        this.getTextNodes(function (dict) {
+          dict.nodes.every(function (n) {
+            while ((match = regex.exec(n.node.textContent)) !== null) {
+              info.match = match;
+              filterStart = eachStart = true;
+              _this6.wrapGroups(n, match, regex, function (node, group, grIndex) {
+                info.matchStart = filterStart;
+                info.groupIndex = grIndex;
+                filterStart = false;
+                return filterCb(node, group, info);
+              }, function (elemOrRange) {
+                if (eachStart) count++;
+                info.count = count;
+                info.matchStart = eachStart;
+                eachStart = false;
+                eachCb(elemOrRange, info);
+              });
+              if (info.abort) break;
+            }
+            return !info.abort;
+          });
+          endCb(count);
+        });
+      }
+    }, {
+      key: "processGroupsAcross",
+      value: function processGroupsAcross(regex, unused, info, filterCb, eachCb, endCb) {
+        var _this7 = this;
+        var count = info.count,
+          match,
+          filterStart,
+          eachStart;
+        this.getTextNodesAcross(function (dict) {
+          while ((match = regex.exec(dict.text)) !== null) {
+            info.match = match;
+            filterStart = eachStart = true;
+            _this7.wrapGroupsAcross(dict, match, regex, function (nodeOrArray, group, grIndex) {
+              info.groupStart = undefined;
+              info.matchStart = filterStart;
+              info.groupIndex = grIndex;
+              filterStart = false;
+              return filterCb(nodeOrArray, group, info);
+            }, function (elemOrRange, groupStart) {
+              if (eachStart) count++;
+              info.count = count;
+              info.matchStart = eachStart;
+              info.groupStart = groupStart;
+              eachCb(elemOrRange, info);
+              eachStart = false;
+            });
+            if (info.abort) break;
+          }
+          endCb(count);
+        });
+      }
+    }, {
+      key: "processMatches",
+      value: function processMatches(regex, ignoreGroups, info, filterCb, eachCb, endCb) {
+        var _this8 = this;
+        var index = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+        var count = info.count,
+          match,
+          str;
+        this.getTextNodes(function (dict) {
+          dict.nodes.every(function (n) {
+            while ((match = regex.exec(n.node.textContent)) !== null) {
+              if ((str = match[index]) === '') {
+                regex.lastIndex++;
+                continue;
+              }
+              info.match = match;
+              if (!filterCb(n.node, str, info)) {
+                continue;
+              }
+              var i = 0,
+                start = match.index;
+              while (++i < index) {
+                if (match[i]) {
+                  start += match[i].length;
+                }
+              }
+              n.node = _this8.wrapRange(n, start, start + str.length, function (elemOrRange) {
+                info.count = ++count;
+                eachCb(elemOrRange, info);
+              });
+              if (!_this8.opt.highlight) regex.lastIndex = 0;
+              if (info.abort) break;
+            }
+            return !info.abort;
+          });
+          endCb(count);
+        });
+      }
+    }, {
+      key: "processMatchesAcross",
+      value: function processMatchesAcross(regex, ignoreGroups, info, filterCb, eachCb, endCb) {
+        var _this9 = this;
+        var index = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+        var count = info.count,
+          match,
+          str,
+          matchStart;
+        this.getTextNodesAcross(function (dict) {
+          while ((match = regex.exec(dict.text)) !== null) {
+            if ((str = match[index]) === '') {
+              regex.lastIndex++;
+              continue;
+            }
+            info.match = match;
+            matchStart = true;
+            var i = 0,
+              start = match.index;
+            while (++i < index) {
+              if (match[i]) {
+                start += match[i].length;
+              }
+            }
+            _this9.wrapRangeAcross(dict, start, start + str.length, function (nodeOrArray) {
+              info.matchStart = matchStart;
+              matchStart = false;
+              return filterCb(nodeOrArray, str, info);
+            }, function (elemOrRange, mStart) {
+              if (mStart) count++;
+              info.count = count;
+              info.matchStart = mStart;
+              eachCb(elemOrRange, info);
+            });
+            if (info.abort) break;
+          }
+          endCb(count);
+        });
+      }
+    }, {
+      key: "processRanges",
+      value: function processRanges(ranges, filterCb, eachCb, endCb) {
+        var _this10 = this;
+        var lines = this.opt.markLines,
+          logs = [],
+          skipped = [],
+          level = 'warn';
+        var count = 0;
+        this.getRangesTextNodes(function (dict) {
+          var max = lines ? dict.newLines.length : dict.text.length,
+            array = _this10.checkRanges(ranges, logs, lines ? 1 : 0, max);
+          array.forEach(function (range, index) {
+            var start = range.start,
+              end = start + range.length;
+            if (end > max) {
+              logs.push({
+                text: "Range was limited to: ".concat(max),
+                obj: range,
+                skip: true,
+                level: level
+              });
+              end = max;
+            }
+            if (lines) {
+              start = dict.newLines[start - 1];
+              if (dict.text[start] === '\n') {
+                start++;
+              }
+              end = dict.newLines[end - 1];
+            }
+            var substr = dict.text.slice(start, end);
+            if (substr.trim()) {
+              _this10.wrapRangeAcross(dict, start, end, function (nodeOrArray) {
+                return filterCb(nodeOrArray, range, substr, index);
+              }, function (elemOrRange, rangeStart) {
+                if (rangeStart) {
+                  count++;
+                }
+                eachCb(elemOrRange, range, {
+                  matchStart: rangeStart,
+                  count: count
+                });
+              });
+            } else {
+              logs.push({
+                text: 'Skipping whitespace only range: ',
+                obj: range,
+                level: level
+              });
+              skipped.push(range);
+            }
+          });
+          _this10.log("Valid ranges: ".concat(JSON.stringify(array.filter(function (range) {
+            return !skipped.includes(range);
+          }))));
+          endCb(count, logs);
+        }, lines);
+      }
+    }, {
+      key: "unwrapMatches",
+      value: function unwrapMatches(node) {
+        var parent = node.parentNode,
+          first = node.firstChild;
+        if (node.childNodes.length === 1) {
+          if (first.nodeType === 3) {
+            var previous = node.previousSibling,
+              next = node.nextSibling;
+            if (previous && previous.nodeType === 3) {
+              if (next && next.nodeType === 3) {
+                previous.nodeValue += first.nodeValue + next.nodeValue;
+                parent.removeChild(next);
+              } else {
+                previous.nodeValue += first.nodeValue;
+              }
+            } else if (next && next.nodeType === 3) {
+              next.nodeValue = first.nodeValue + next.nodeValue;
+            } else {
+              parent.replaceChild(node.firstChild, node);
+              return;
+            }
+            parent.removeChild(node);
+          } else {
+            parent.replaceChild(node.firstChild, node);
+          }
+        } else {
+          if (!first) {
+            parent.removeChild(node);
+          } else {
+            var docFrag = this.opt.window.document.createDocumentFragment();
+            while (node.firstChild) {
+              docFrag.appendChild(node.removeChild(node.firstChild));
+            }
+            parent.replaceChild(docFrag, node);
+          }
+          parent.normalize();
+        }
+      }
+    }, {
+      key: "markRegExp",
+      value: function markRegExp(regexp, opt) {
+        var _this11 = this;
+        this.opt = opt;
+        var totalMarks = 0,
+          matchesSoFar = 0,
+          across = this.opt.acrossElements,
+          fn = 'processMatches';
+        if (this.opt.separateGroups) {
+          if (!regexp.hasIndices) {
+            throw new Error('Mark.js: RegExp must have a `d` flag');
+          }
+          fn = across ? 'processGroupsAcross' : 'processGroups';
+        } else if (across) {
+          fn = 'processMatchesAcross';
+        }
+        var info = {
+          count: 0,
+          abort: false
+        };
+        if (!regexp.global && !regexp.sticky) {
+          var splits = regexp.toString().split('/');
+          regexp = new RegExp(regexp.source, 'g' + splits[splits.length - 1]);
+          this.log('RegExp is recompiled - it must have a `g` flag', 'warn');
+        }
+        this.log("RegExp \"".concat(regexp, "\""));
+        this[fn](regexp, this.opt.ignoreGroups, info, function (nodeOrArray, match, filterInfo) {
+          return _this11.opt.filter(nodeOrArray, match, matchesSoFar, filterInfo);
+        }, function (elemOrRange, eachInfo) {
+          matchesSoFar = eachInfo.count;
+          totalMarks++;
+          _this11.opt.each(elemOrRange, eachInfo);
+        }, function (totalMatches) {
+          if (totalMatches === 0) {
+            _this11.opt.noMatch(regexp);
+          }
+          _this11.registerHighlight();
+          _this11.opt.done(totalMarks, totalMatches);
+        });
+      }
+    }, {
+      key: "mark",
+      value: function mark(sv, opt) {
+        var _this12 = this;
+        this.opt = opt;
+        var _this$getSeachTerms = this.getSeachTerms(sv),
+          terms = _this$getSeachTerms.terms,
+          termStats = _this$getSeachTerms.termStats;
+        if (!terms.length) {
+          this.opt.done(0, 0, termStats);
+          return;
+        }
+        var index = 0,
+          totalMarks = 0,
+          matchesSoFar = 0,
+          term;
+        var across = this.opt.acrossElements,
+          fn = across ? 'processMatchesAcross' : 'processMatches',
+          array = this.getRegExps(terms),
+          info = {
+            count: 0,
+            abort: false
+          };
+        var loop = function loop(_ref) {
+          var regex = _ref.regex,
+            regTerms = _ref.regTerms;
+          _this12.log("RegExp ".concat(regex));
+          _this12[fn](regex, 1, info, function (nodeOrArray, _, filterInfo) {
+            if (!across || filterInfo.matchStart) {
+              term = _this12.getCurrentTerm(filterInfo.match, regTerms);
+            }
+            return _this12.opt.filter(nodeOrArray, term, matchesSoFar, termStats[term], filterInfo);
+          }, function (elemOrRange, eachInfo) {
+            totalMarks++;
+            matchesSoFar = eachInfo.count;
+            if (!across || eachInfo.matchStart) {
+              termStats[term] += 1;
+            }
+            _this12.opt.each(elemOrRange, eachInfo);
+          }, function (totalMatches) {
+            var noMatches = regTerms.filter(function (term) {
+              return termStats[term] === 0;
+            });
+            if (noMatches.length) {
+              _this12.opt.noMatch(noMatches);
+            }
+            if (!info.abort && ++index < array.length) {
+              loop(array[index]);
+            } else {
+              _this12.registerHighlight();
+              _this12.opt.done(totalMarks, totalMatches, termStats);
+            }
+          });
+        };
+        loop(array[0]);
+      }
+    }, {
+      key: "getCurrentTerm",
+      value: function getCurrentTerm(match, terms) {
+        var i = match.length;
+        while (--i > 2) {
+          if (match[i]) {
+            return terms[i - 3];
+          }
+        }
+        return ' ';
+      }
+    }, {
+      key: "getRegExps",
+      value: function getRegExps(terms) {
+        var creator = new RegExpCreator(this.opt),
+          option = this.opt.combineBy || this.opt.combinePatterns,
+          length = terms.length,
+          array = [];
+        var num = 100,
+          value;
+        if (option === Infinity) {
+          num = length;
+        } else if (!isNaN(+option) && (value = parseInt(option)) > 0) {
+          num = value;
+        }
+        for (var i = 0; i < length; i += num) {
+          var chunk = terms.slice(i, Math.min(i + num, length));
+          array.push({
+            regex: creator.create(chunk),
+            regTerms: chunk
+          });
+        }
+        return array;
+      }
+    }, {
+      key: "markRanges",
+      value: function markRanges(ranges, opt) {
+        var _this13 = this;
+        this.opt = opt;
+        if (Array.isArray(ranges)) {
+          var totalMarks = 0;
+          this.processRanges(ranges, function (nodeOrArray, range, match, index) {
+            return _this13.opt.filter(nodeOrArray, range, match, index);
+          }, function (elemOrRange, range, rangeInfo) {
+            totalMarks++;
+            _this13.opt.each(elemOrRange, range, rangeInfo);
+          }, function (totalRanges, logs) {
+            _this13.report(logs);
+            _this13.registerHighlight();
+            _this13.opt.done(totalMarks, totalRanges);
+          });
+        } else {
+          this.report([{
+            text: 'markRanges() accept an array of objects: ',
+            obj: ranges,
+            level: 'error'
+          }]);
+          this.opt.done(0, 0);
+        }
+      }
+    }, {
+      key: "unmark",
+      value: function unmark(opt) {
+        var _this14 = this;
+        this.opt = opt;
+        var registry = CSS.highlights,
+          exclude = this.opt.exclude && this.opt.exclude.length;
+        if (registry) {
+          var names = this.opt.highlightName,
+            highlight;
+          if (typeof names === 'string') names = [names];
+          names.forEach(function (name) {
+            if ((highlight = registry.get(name)) && highlight.size) {
+              registry["delete"](name);
+              if (exclude) {
+                highlight.forEach(function (range) {
+                  var node = range.startContainer;
+                  if (node.nodeType === 3) node = node.parentNode;
+                  if (!_this14.excluded(node)) highlight["delete"](range);
+                });
+              } else {
+                highlight.clear();
+              }
+              if (highlight.size) registry.set(name, highlight);
+            }
+          });
+        }
+        if (this.opt.highlight) {
+          this.opt.done();
+          return;
+        }
+        var selector = this.opt.element + '[data-markjs]';
+        if (this.opt.className) {
+          selector += ".".concat(this.opt.className);
+        }
+        this.log("Removal selector \"".concat(selector, "\""));
+        this.iterator.forEachNode(this.filter.SHOW_ELEMENT, function (node) {
+          _this14.unwrapMatches(node);
+        }, function (node) {
+          return DOMIterator.matches(node, selector) && !(exclude && _this14.excluded(node));
+        }, this.opt.done);
+      }
+    }, {
+      key: "registerHighlight",
+      value: function registerHighlight() {
+        var _this15 = this;
+        var highlight = this.opt.highlight;
+        if (highlight) {
+          var name = this.opt.highlightName,
+            registry = CSS.highlights;
+          if (this.rangeArray.length) {
+            registry["delete"](name);
+            if (highlight.size) {
+              highlight.forEach(function (range) {
+                _this15.rangeArray.push(range);
+              });
+              highlight.clear();
+            }
+            this.rangeArray.sort(function (a, b) {
+              return a.absoluteOffset - b.absoluteOffset;
+            });
+            this.rangeArray.forEach(function (range) {
+              highlight.add(range);
+            });
+            this.rangeArray = [];
+          }
+          if (highlight.size) registry.set(name, highlight);
+        }
+      }
+    }]);
+    return Mark;
+  }();
+
+  function Mark(ctx) {
+    var _this = this;
+    var instance = new Mark$1(ctx);
+    this.mark = function (sv, opt) {
+      instance.mark(sv, opt);
+      return _this;
+    };
+    this.markRegExp = function (sv, opt) {
+      instance.markRegExp(sv, opt);
+      return _this;
+    };
+    this.markRanges = function (sv, opt) {
+      instance.markRanges(sv, opt);
+      return _this;
+    };
+    this.unmark = function (opt) {
+      instance.unmark(opt);
+      return _this;
+    };
+    this.getVersion = function () {
+      return '3.0.0';
+    };
+    return this;
+  }
+
+  return Mark;
+
+}));