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

package/dist/mark.es6.js

@@ -0,0 +1,1284 @@
+/*!***************************************************
+* 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
+*****************************************************/
+
+class DOMIterator {
+  constructor(ctx, opt) {
+    this.ctx = ctx;
+    this.opt = opt;
+    this.map = new Map();
+  }
+  static matches(element, selector) {
+    if ( !selector || !selector.length) {
+      return false;
+    }
+    const selectors = typeof selector === 'string' ? [selector] : selector,
+      fn = element.matches;
+    return fn && selectors.some(sel => fn.call(element, sel));
+  }
+  getContexts() {
+    let 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];
+    }
+    const array = [];
+    for (let i = 0; i < ctx.length; i++) {
+      if ( !array.includes(ctx[i]) && !array.some(node => node.contains(ctx[i]))) {
+        array.push(ctx[i]);
+      }
+    }
+    if (sort) {
+      array.sort((a, b) => {
+        return (a.compareDocumentPosition(b) & win.Node.DOCUMENT_POSITION_FOLLOWING) > 0 ? -1 : 1;
+      });
+    }
+    return array;
+  }
+  getIframeContents(iframe, successFn, errorFn) {
+    try {
+      const doc = iframe.contentWindow.document;
+      if (doc) {
+        this.map.set(iframe, 'ready');
+        successFn({ iframe: iframe, context: doc });
+      }
+    } catch (e) {
+      errorFn({ iframe: iframe, error: e });
+    }
+  }
+  observeIframeLoad(ifr, successFn, errorFn) {
+    if (this.map.has(ifr)) return;
+    let id = null;
+    const 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);
+  }
+  onIframeReady(ifr, successFn, errorFn) {
+    const 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);
+    }
+  }
+  waitForIframes(ctx, doneCb) {
+    const shadow = this.opt.shadowDOM;
+    let count = 0,
+      iframes = 0,
+      array,
+      node;
+    const collect = context => {
+      const iterator = this.createIterator(context, this.opt.window.NodeFilter.SHOW_ELEMENT);
+      while ((node = iterator.nextNode())) {
+        if (this.isIframe(node) && !this.map.has(node)) {
+          array.push(node);
+          iframes++;
+        }
+        if (shadow && node.shadowRoot && node.shadowRoot.mode === 'open') {
+          collect(node.shadowRoot);
+        }
+      }
+    };
+    const 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(iframe => {
+          this.onIframeReady(iframe, obj => {
+            count++;
+            loop(obj);
+          }, obj => {
+            if (this.opt.debug) {
+              console.log(obj.error || obj);
+            }
+            if (++count === iframes) doneCb();
+          });
+        });
+      } else if (count === iframes) {
+        doneCb();
+      }
+    };
+    loop({ context: ctx });
+  }
+  createIterator(ctx, whatToShow) {
+    const win = this.opt.window;
+    return win.document.createNodeIterator(ctx, whatToShow, () => win.NodeFilter.FILTER_ACCEPT, false);
+  }
+  addRemoveStyle(root, style, add) {
+    if (add && !style) return;
+    let 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);
+    }
+  }
+  isIframe(node) {
+    return node.tagName === 'IFRAME' && !DOMIterator.matches(node, this.opt.exclude);
+  }
+  iterateThroughNodes(ctx, whatToShow, filterCb, eachCb, doneCb) {
+    const filter = this.opt.window.NodeFilter,
+      shadow = this.opt.shadowDOM,
+      iframe = this.opt.iframes;
+    if (iframe || shadow) {
+      const showElement = (whatToShow & filter.SHOW_ELEMENT) > 0,
+        showText = (whatToShow & filter.SHOW_TEXT) > 0;
+      const traverse = node => {
+        let iterator = this.createIterator(node, whatToShow | filter.SHOW_ELEMENT),
+          root;
+        while ((node = iterator.nextNode())) {
+          if (node.nodeType === 1) {
+            if (showElement && filterCb(node)) {
+              eachCb(node);
+            }
+            if (iframe && this.isIframe(node) && this.map.get(node) === 'ready') {
+              const doc = node.contentWindow.document;
+              if (doc) {
+                if (this.opt.highlight && showText) {
+                  node.contentWindow.CSS.highlights.set(this.opt.highlightName, this.opt.highlight);
+                }
+                this.addRemoveStyle(doc.head, iframe.style, showText);
+                traverse(doc);
+              }
+            }
+            if (shadow && (root = node.shadowRoot) && root.mode === 'open') {
+              this.addRemoveStyle(root, shadow.style, showText);
+              traverse(root);
+            }
+          } else  if (showText && node.nodeType === 3 && filterCb(node)) {
+            eachCb(node);
+          }
+        }
+      };
+      traverse(ctx);
+    } else {
+      const iterator = this.createIterator(ctx, whatToShow);
+      let node;
+      while ((node = iterator.nextNode())) {
+        if (filterCb(node)) {
+          eachCb(node);
+        }
+      }
+    }
+    doneCb();
+  }
+  forEachNode(whatToShow, each, filter, done = () => {}) {
+    const contexts = this.getContexts();
+    let open = contexts.length;
+    if ( !open) done();
+    const ready = () => {
+      contexts.forEach(ctx => {
+        this.iterateThroughNodes(ctx, whatToShow, filter, each, () => {
+          if (--open <= 0) done();
+        });
+      });
+    };
+    if (this.opt.iframes) {
+      let count = open;
+      contexts.forEach(ctx => {
+        this.waitForIframes(ctx, () => {
+          if (--count <= 0) ready();
+        });
+      });
+    } else {
+      ready();
+    }
+  }
+}
+
+class RegExpCreator {
+  constructor(options) {
+    this.opt = Object.assign({}, {
+      'diacritics': true,
+      'synonyms': {},
+      'accuracy': 'partially',
+      'caseSensitive': false,
+      'ignoreJoiners': false,
+      'ignorePunctuation': [],
+      'wildcards': 'disabled'
+    }, options);
+  }
+  get chars() {
+    if ( !this._chars) {
+      this._chars = [];
+      ['aàáảãạăằắẳẵặâầấẩẫậäåāą', 'cçćč', 'dđď', 'eèéẻẽẹêềếểễệëěēę',
+        'iìíỉĩịîïī',  'lł', 'nñňń', 'oòóỏõọôồốổỗộơởỡớờợöøōő',  'rř',
+        'sšśșş', 'tťțţ', 'uùúủũụưừứửữựûüůūű', 'yýỳỷỹỵÿ', 'zžżź'].forEach(str => {
+        this._chars.push(str, str.toUpperCase());
+      });
+    }
+    return this._chars;
+  }
+  create(terms) {
+    const flags = `g${this.opt.caseSensitive ? '' : 'i'}`;
+    terms = terms.map(str => {
+      return '(' + this.createPattern(str, flags) + ')';
+    });
+    const obj = this.createAccuracy(terms.join('|'));
+    return new RegExp(`${obj.lookbehind}(${obj.pattern})${obj.lookahead}`, flags);
+  }
+  createPattern(str, flags) {
+    str = this.checkWildcardsEscape(str);
+    str = this.createSynonyms(str, flags);
+    const 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;
+  }
+  escape(str) {
+    return str.replace(/[[\]/{}()*+?.\\^$|]/g, '\\$&');
+  }
+  preprocess(val) {
+    if (val && val.length) {
+      return this.distinct(typeof val === 'string' ? val.split('') : val).join('').replace(/[-^\]\\]/g, '\\$&');
+    }
+    return '';
+  }
+  distinct(array) {
+    const result = [];
+    array.forEach(item => {
+      if (item.trim() && !result.includes(item)) {
+        result.push(item);
+      }
+    });
+    return result;
+  }
+  createSynonyms(str, flags) {
+    const syn = this.opt.synonyms;
+    for (const key in syn) {
+      if (syn.hasOwnProperty(key)) {
+        let array = Array.isArray(syn[key]) ? syn[key] : [syn[key]];
+        array.unshift(key);
+        array = this.distinct(array);
+        if (array.length > 1) {
+          array.sort((a, b) => b.length - a.length);
+          array = array.map(term => this.checkWildcardsEscape(term));
+          const pattern = array.map(term => this.escape(term)).join('|');
+          str = str.replace(new RegExp(pattern, flags), `(?:${array.join('|')})`);
+        }
+      }
+    }
+    return str;
+  }
+  checkWildcardsEscape(str) {
+    if (this.opt.wildcards !== 'disabled') {
+      str = str.replace(/(\\.)+|[?*]/g, (m, gr) => gr ? m : m === '?' ? '\x01' : '\x02')
+        .replace(/\\(?=[?*\x01\x02])/g, '');
+    }
+    return this.escape(str);
+  }
+  createWildcards(str) {
+    const spaces = this.opt.wildcards === 'withSpaces',
+      boundary = this.opt.blockElementsBoundary,
+      anyChar = `[^${spaces && boundary ? '\x01' : ''}]*?`;
+    return str
+      .replace(/\x01/g, spaces ? '[^]?' : '\\S?')
+      .replace(/\x02/g, spaces ? anyChar : '\\S*');
+  }
+  setupIgnoreJoiners(str) {
+    const reg = /((?:\\\\)+|\x02|\(\?:|\|)|\\?(?:[\uD800-\uDBFF][\uDC00-\uDFFF]|.)(?=([|)\x02]|$)|.)/g;
+    return str.replace(reg, (m, gr1, gr2) => {
+      return gr1 || typeof gr2 !== 'undefined' ? m : m + '\x00';
+    });
+  }
+  createJoiners(str, joiners) {
+    return str.split(/\x00+/).join(`[${joiners}]*`);
+  }
+  getJoinersPunctuation() {
+    let punct = this.preprocess(this.opt.ignorePunctuation),
+      str = punct ? punct : '';
+    if (this.opt.ignoreJoiners) {
+      str += '\\u00ad\\u200b\\u200c\\u200d';
+    }
+    return str;
+  }
+  createDiacritics(str) {
+    const array = this.chars;
+    return str.split('').map(ch => {
+      for (let i = 0; i < array.length; i += 2) {
+        const lowerCase = array[i].includes(ch);
+        if (this.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('');
+  }
+  createAccuracy(str) {
+    const chars = '!-/:-@[-`{-~¡¿';
+    let 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') {
+        const charSet = limiters ? '[\\s' + limiters + ']' : '\\s';
+        lookbehind = `(^|${charSet})`;
+        lookahead = `(?=$|${charSet})`;
+      } else {
+        const chs = limiters || chars,
+          charSet = `[^\\s${chs}]*`;
+        pattern = `(?:${str})`;
+        if (accuracy === 'complementary') {
+          pattern = charSet + pattern + charSet;
+        } else if (accuracy === 'startsWith') {
+          lookbehind = `(^|[\\s${chs}])`;
+          pattern = pattern.split(/\[\\s\]\+/).join(charSet + '[\\s]+') + charSet;
+        }
+      }
+    }
+    return { lookbehind, pattern, lookahead };
+  }
+}
+
+class Mark$1 {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.nodeNames = ['script', 'style', 'title', 'head', 'html'];
+  }
+  set opt(val) {
+    if ( !(val && val.window && val.window.document) && typeof window === 'undefined') {
+      throw new Error('Mark.js: please provide a window object as an option.');
+    }
+    const win = val && val.window || window,
+      highlight = val && val.highlight && val.highlight instanceof Highlight;
+    this._opt = Object.assign({}, {
+      'window': win,
+      'element': '',
+      'className': '',
+      'exclude': [],
+      'iframes': false,
+      'iframesTimeout': 5000,
+      'separateWordSearch': true,
+      'staticRanges': true,
+      'rangeAcrossElements': true,
+      'acrossElements': false,
+      'ignoreGroups': 0,
+      'each': () => {},
+      'noMatch': () => {},
+      'filter': () => true,
+      '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;
+    }
+  }
+  get opt() {
+    return this._opt;
+  }
+  get iterator() {
+    return new DOMIterator(this.ctx, this.opt);
+  }
+  log(msg, level = 'debug') {
+    if (this.opt.debug) {
+      const log = this.opt.log;
+      if (typeof log === 'object' && typeof log[level] === 'function') {
+        log[level](`mark.js: ${msg}`);
+      }
+    }
+  }
+  report(array) {
+    array.forEach(item => {
+      this.log(`${item.text} ${JSON.stringify(item.obj)}`, item.level || 'debug');
+      if ( !item.skip) {
+        this.opt.noMatch(item.obj);
+      }
+    });
+  }
+  getSeachTerms(sv) {
+    const search = typeof sv === 'string' ? [sv] : sv,
+      separate = this.opt.separateWordSearch,
+      array = [],
+      termStats = {},
+      split = str => {
+        str.split(/ +/).forEach(word => add(word));
+      },
+      add = str => {
+        if (str.trim() && !array.includes(str)) {
+          array.push(str);
+          termStats[str] = 0;
+        }
+      };
+    search.forEach(str => {
+      if (separate) {
+        if (separate === 'preserveTerms') {
+          str.split(/"("*[^"]+"*)"/).forEach((term, i) => {
+            if (i % 2 > 0) add(term);
+            else split(term);
+          });
+        } else {
+          split(str);
+        }
+      } else {
+        add(str);
+      }
+    });
+    array.sort((a, b) => b.length - a.length);
+    return { terms: array, termStats };
+  }
+  isNumeric(value) {
+    return Number(parseFloat(value)) == value;
+  }
+  checkRanges(array, logs, min, max) {
+    const level = 'error';
+    const ranges = array.filter(range => {
+      if (this.isNumeric(range.start) && this.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 });
+      return false;
+    }).sort((a, b) => a.start - b.start);
+    if (this.opt.wrapAllRanges) {
+      return ranges;
+    }
+    let lastIndex = 0, index;
+    return ranges.filter(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 });
+      return false;
+    });
+  }
+  setType(tags, boundary) {
+    const custom = Array.isArray(boundary.tagNames) && boundary.tagNames.length;
+    if (custom) {
+      boundary.tagNames.forEach(name => tags[name.toLowerCase()] = 2);
+    }
+    if ( !custom || boundary.extend) {
+      for (const key in tags) {
+        tags[key] = 2;
+      }
+    }
+    tags['br'] = 3;
+  }
+  getTextNodesAcross(cb) {
+    const 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 };
+    const nodes = [],
+      boundary = this.opt.blockElementsBoundary,
+      priorityType = boundary ? 2 : 1;
+    let ch = '\x01', tempType, type, prevNode;
+    if (boundary) {
+      this.setType(tags, boundary);
+      if (boundary.char) {
+        ch = boundary.char.charAt(0);
+      }
+    }
+    const obj = {
+      text: '', regex: /\s/, tags: tags,
+      boundary: boundary, str: '', ch: ch
+    };
+    this.iterator.forEachNode(this.filter.SHOW_ELEMENT | this.filter.SHOW_TEXT, node => {
+      if (prevNode) {
+        nodes.push(this.getNodeInfo(prevNode, node, type, obj));
+      }
+      type = null;
+      prevNode = node;
+    }, 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 !this.excluded(node.parentNode);
+    }, () => {
+      if (prevNode) {
+        nodes.push(this.getNodeInfo(prevNode, null, type, obj));
+      }
+      cb({
+        text: obj.text,
+        nodes: nodes,
+        lastIndex: 0
+      });
+    });
+  }
+  getNodeInfo(prevNode, node, type, obj) {
+    const start = obj.text.length,
+      ch = obj.ch;
+    let offset = 0,
+      str = obj.str,
+      text = prevNode.textContent;
+    if (node) {
+      const startBySpace = obj.regex.test(node.textContent[0]),
+        both = startBySpace && obj.regex.test(text[text.length - 1]);
+      if (obj.boundary || !both) {
+        let separate = type;
+        if (!type) {
+          let 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);
+  }
+  getRangesTextNodes(cb, lines) {
+    const nodes = [],
+      regex = /\n/g,
+      newLines = [0],
+      show = this.filter.SHOW_TEXT | (lines ? this.filter.SHOW_ELEMENT : 0);
+    let text = '',
+      len = 0,
+      rm;
+    this.iterator.forEachNode(show, 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
+      });
+    }, node => {
+      if (lines && node.nodeType === 1) {
+        if (node.tagName.toLowerCase() === 'br') {
+          newLines.push(len);
+        }
+        return false;
+      }
+      return !this.excluded(node.parentNode);
+    }, () => {
+      const dict = { text, nodes, lastIndex: 0 };
+      if (lines) {
+        newLines.push(len);
+        dict.newLines = newLines;
+      }
+      cb(dict);
+    });
+  }
+  getTextNodes(cb) {
+    const nodes = [];
+    let start = 0;
+    this.iterator.forEachNode(this.filter.SHOW_TEXT, node => {
+      nodes.push({
+        node,
+        start
+      });
+      start += node.textContent.length;
+    }, node => {
+      return !this.excluded(node.parentNode);
+    }, () => {
+      cb({ nodes, lastIndex: 0 });
+    });
+  }
+  excluded(elem) {
+    return this.nodeNames.includes(elem.nodeName.toLowerCase()) || DOMIterator.matches(elem, this.opt.exclude);
+  }
+  wrapRangeInsert(dict, n, s, e, start, index) {
+    const ended = e === n.node.textContent.length,
+      end = n.end;
+    let 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;
+    }
+    const 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, nodeInfo, increment: 0 };
+    }
+    const 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, nodeInfo, increment: type < 3 ? 1 : 2 };
+  }
+  createInfo(node, start, end, offset) {
+    return { node, start, end, offset };
+  }
+  wrapRange(n, start, end, eachCb) {
+    let node = n.node,
+      retNode;
+    if (this.rangeArray) {
+      this.createRange(node, start, node, end, n.start + start, eachCb);
+      retNode = node;
+    } else {
+      let 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;
+  }
+  createRange(startNode, startOffset, endNode, endOffset, absoluteOffset, eachCb) {
+    let range;
+    if (this.opt.staticRanges) {
+      range = new StaticRange({ startContainer: startNode, startOffset, endContainer: endNode, 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);
+  }
+  createElement(node) {
+    let 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;
+  }
+  wrapRangeAcross(dict, start, end, filterCb, eachCb) {
+    let i = dict.lastIndex,
+      rangeStart = true,
+      startInfo,
+      filterNodes = [],
+      e;
+    const 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) {
+        let n = dict.nodes[i];
+        if (singleRange) {
+          filterNodes.push(n.node);
+        } else if ( !filterCb(n.node)) {
+          break;
+        }
+        const 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) {
+            const obj = this.wrapRangeInsert(dict, n, s, e, start, i);
+            n = obj.nodeInfo;
+            eachCb(obj.mark, rangeStart);
+          } else {
+            n.node = this.wrapRange(n, s, e, 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;
+  }
+  wrapGroups(n, match, regex, filterCb, eachCb) {
+    let 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, 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);
+    }
+  }
+  wrapGroupsAcross(dict, match, regex, filterCb, eachCb) {
+    let 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, nodeOrArray => {
+            return filterCb(nodeOrArray, group, i);
+          }, (elemOrRange, groupStart) => {
+            isWrapped = true;
+            eachCb(elemOrRange, groupStart);
+          });
+          if (isWrapped && end > lastIndex) {
+            lastIndex = end;
+          }
+        }
+      }
+    }
+    if (match[0].length === 0) {
+      this.setLastIndex(regex, end);
+    }
+  }
+  setLastIndex(regex, end) {
+    const index = regex.lastIndex;
+    regex.lastIndex = end > index ? end : end > 0 ? index + 1 : Infinity;
+  }
+  processGroups(regex, unused, info, filterCb, eachCb, endCb) {
+    let count = info.count, match, filterStart, eachStart;
+    this.getTextNodes(dict => {
+      dict.nodes.every(n => {
+        while ((match = regex.exec(n.node.textContent)) !== null) {
+          info.match = match;
+          filterStart = eachStart = true;
+          this.wrapGroups(n, match, regex, (node, group, grIndex) => {
+            info.matchStart = filterStart;
+            info.groupIndex = grIndex;
+            filterStart = false;
+            return filterCb(node, group, info);
+          }, (elemOrRange) => {
+            if (eachStart) count++;
+            info.count = count;
+            info.matchStart = eachStart;
+            eachStart = false;
+            eachCb(elemOrRange, info);
+          });
+          if (info.abort) break;
+        }
+        return !info.abort;
+      });
+      endCb(count);
+    });
+  }
+  processGroupsAcross(regex, unused, info, filterCb, eachCb, endCb) {
+    let count = info.count, match, filterStart, eachStart;
+    this.getTextNodesAcross(dict => {
+      while ((match = regex.exec(dict.text)) !== null) {
+        info.match = match;
+        filterStart = eachStart = true;
+        this.wrapGroupsAcross(dict, match, regex, (nodeOrArray, group, grIndex) => {
+          info.groupStart = undefined;
+          info.matchStart = filterStart;
+          info.groupIndex = grIndex;
+          filterStart = false;
+          return filterCb(nodeOrArray, group, info);
+        }, (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);
+    });
+  }
+  processMatches(regex, ignoreGroups, info, filterCb, eachCb, endCb) {
+    const index = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+    let count = info.count, match, str;
+    this.getTextNodes(dict => {
+      dict.nodes.every(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;
+          }
+          let i = 0, start = match.index;
+          while (++i < index) {
+            if (match[i]) {
+              start += match[i].length;
+            }
+          }
+          n.node = this.wrapRange(n, start, start + str.length, elemOrRange => {
+            info.count = ++count;
+            eachCb(elemOrRange, info);
+          });
+          if ( !this.opt.highlight) regex.lastIndex = 0;
+          if (info.abort) break;
+        }
+        return !info.abort;
+      });
+      endCb(count);
+    });
+  }
+  processMatchesAcross(regex, ignoreGroups, info, filterCb, eachCb, endCb) {
+    const index = ignoreGroups === 0 ? 0 : ignoreGroups + 1;
+    let count = info.count, match, str, matchStart;
+    this.getTextNodesAcross(dict => {
+      while ((match = regex.exec(dict.text)) !== null) {
+        if ((str = match[index]) === '') {
+          regex.lastIndex++;
+          continue;
+        }
+        info.match = match;
+        matchStart = true;
+        let i = 0, start = match.index;
+        while (++i < index) {
+          if (match[i]) {
+            start += match[i].length;
+          }
+        }
+        this.wrapRangeAcross(dict, start, start + str.length, nodeOrArray => {
+          info.matchStart = matchStart;
+          matchStart = false;
+          return filterCb(nodeOrArray, str, info);
+        }, (elemOrRange, mStart) => {
+          if (mStart) count++;
+          info.count = count;
+          info.matchStart = mStart;
+          eachCb(elemOrRange, info);
+        });
+        if (info.abort) break;
+      }
+      endCb(count);
+    });
+  }
+  processRanges(ranges, filterCb, eachCb, endCb) {
+    const lines = this.opt.markLines,
+      logs = [],
+      skipped = [],
+      level = 'warn';
+    let count = 0;
+    this.getRangesTextNodes(dict => {
+      const max = lines ? dict.newLines.length : dict.text.length,
+        array = this.checkRanges(ranges, logs, lines ? 1 : 0, max);
+      array.forEach((range, index) => {
+        let start = range.start,
+          end = start + range.length;
+        if (end > max) {
+          logs.push({ text: `Range was limited to: ${max}`, obj: range, skip: true, level });
+          end = max;
+        }
+        if (lines) {
+          start = dict.newLines[start-1];
+          if (dict.text[start] === '\n') {
+            start++;
+          }
+          end = dict.newLines[end-1];
+        }
+        const substr = dict.text.slice(start, end);
+        if (substr.trim()) {
+          this.wrapRangeAcross(dict, start, end, nodeOrArray => {
+            return filterCb(nodeOrArray, range, substr, index);
+          }, (elemOrRange, rangeStart) => {
+            if (rangeStart) {
+              count++;
+            }
+            eachCb(elemOrRange, range, {
+              matchStart: rangeStart,
+              count: count
+            });
+          });
+        } else {
+          logs.push({ text: 'Skipping whitespace only range: ', obj: range, level });
+          skipped.push(range);
+        }
+      });
+      this.log(`Valid ranges: ${JSON.stringify(array.filter(range => !skipped.includes(range)))}`);
+      endCb(count, logs);
+    }, lines);
+  }
+  unwrapMatches(node) {
+    const parent = node.parentNode,
+      first = node.firstChild;
+    if (node.childNodes.length === 1) {
+      if (first.nodeType === 3) {
+        const 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 {
+        let docFrag = this.opt.window.document.createDocumentFragment();
+        while (node.firstChild) {
+          docFrag.appendChild(node.removeChild(node.firstChild));
+        }
+        parent.replaceChild(docFrag, node);
+      }
+      parent.normalize();
+    }
+  }
+  markRegExp(regexp, opt) {
+    this.opt = opt;
+    let 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';
+    }
+    const info = { count: 0, abort: false };
+    if ( !regexp.global && !regexp.sticky) {
+      let 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 "${regexp}"`);
+    this[fn](regexp, this.opt.ignoreGroups, info, (nodeOrArray, match, filterInfo) => {
+      return this.opt.filter(nodeOrArray, match, matchesSoFar, filterInfo);
+    }, (elemOrRange, eachInfo) => {
+      matchesSoFar = eachInfo.count;
+      totalMarks++;
+      this.opt.each(elemOrRange, eachInfo);
+    }, (totalMatches) => {
+      if (totalMatches === 0) {
+        this.opt.noMatch(regexp);
+      }
+      this.registerHighlight();
+      this.opt.done(totalMarks, totalMatches);
+    });
+  }
+  mark(sv, opt) {
+    this.opt = opt;
+    const { terms, termStats } = this.getSeachTerms(sv);
+    if ( !terms.length) {
+      this.opt.done(0, 0, termStats);
+      return;
+    }
+    let index = 0,
+      totalMarks = 0,
+      matchesSoFar = 0,
+      term;
+    const across = this.opt.acrossElements,
+      fn = across ? 'processMatchesAcross' : 'processMatches',
+      array = this.getRegExps(terms),
+      info = { count: 0, abort: false };
+    const loop = ({ regex, regTerms }) => {
+      this.log(`RegExp ${regex}`);
+      this[fn](regex, 1, info, (nodeOrArray, _, filterInfo) => {
+        if ( !across || filterInfo.matchStart) {
+          term = this.getCurrentTerm(filterInfo.match, regTerms);
+        }
+        return this.opt.filter(nodeOrArray, term, matchesSoFar, termStats[term], filterInfo);
+      }, (elemOrRange, eachInfo) => {
+        totalMarks++;
+        matchesSoFar = eachInfo.count;
+        if ( !across || eachInfo.matchStart) {
+          termStats[term] += 1;
+        }
+        this.opt.each(elemOrRange, eachInfo);
+      }, (totalMatches) => {
+        const noMatches = regTerms.filter(term => termStats[term] === 0);
+        if (noMatches.length) {
+          this.opt.noMatch(noMatches);
+        }
+        if ( !info.abort && ++index < array.length) {
+          loop(array[index]);
+        } else {
+          this.registerHighlight();
+          this.opt.done(totalMarks, totalMatches, termStats);
+        }
+      });
+    };
+    loop(array[0]);
+  }
+  getCurrentTerm(match, terms) {
+    let i = match.length;
+    while (--i > 2) {
+      if (match[i]) {
+        return terms[i-3];
+      }
+    }
+    return ' ';
+  }
+  getRegExps(terms) {
+    const creator = new RegExpCreator(this.opt),
+      option = this.opt.combineBy || this.opt.combinePatterns,
+      length = terms.length,
+      array = [];
+    let num = 100,
+      value;
+    if (option === Infinity) {
+      num = length;
+    } else if ( !isNaN(+option) && (value = parseInt(option)) > 0) {
+      num = value;
+    }
+    for (let i = 0; i < length; i += num) {
+      const chunk = terms.slice(i, Math.min(i + num, length));
+      array.push({ regex: creator.create(chunk), regTerms: chunk });
+    }
+    return array;
+  }
+  markRanges(ranges, opt) {
+    this.opt = opt;
+    if (Array.isArray(ranges)) {
+      let totalMarks = 0;
+      this.processRanges(ranges, (nodeOrArray, range, match, index) => {
+        return this.opt.filter(nodeOrArray, range, match, index);
+      }, (elemOrRange, range, rangeInfo) => {
+        totalMarks++;
+        this.opt.each(elemOrRange, range, rangeInfo);
+      }, (totalRanges, logs) => {
+        this.report(logs);
+        this.registerHighlight();
+        this.opt.done(totalMarks, totalRanges);
+      });
+    } else {
+      this.report([{ text: 'markRanges() accept an array of objects: ', obj: ranges, level: 'error' }]);
+      this.opt.done(0, 0);
+    }
+  }
+  unmark(opt) {
+    this.opt = opt;
+    const registry = CSS.highlights,
+      exclude = this.opt.exclude && this.opt.exclude.length;
+    if (registry) {
+      let names = this.opt.highlightName,
+        highlight;
+      if (typeof names === 'string') names = [names];
+      names.forEach((name) => {
+        if ((highlight = registry.get(name)) && highlight.size) {
+          registry.delete(name);
+          if (exclude) {
+            highlight.forEach((range) => {
+              let node = range.startContainer;
+              if (node.nodeType === 3) node = node.parentNode;
+              if ( !this.excluded(node)) highlight.delete(range);
+            });
+          } else {
+            highlight.clear();
+          }
+          if (highlight.size) registry.set(name, highlight);
+        }
+      });
+    }
+    if (this.opt.highlight) {
+      this.opt.done();
+      return;
+    }
+    let selector = this.opt.element + '[data-markjs]';
+    if (this.opt.className) {
+      selector += `.${this.opt.className}`;
+    }
+    this.log(`Removal selector "${selector}"`);
+    this.iterator.forEachNode(this.filter.SHOW_ELEMENT, node => {
+      this.unwrapMatches(node);
+    }, node => {
+      return DOMIterator.matches(node, selector) && !(exclude && this.excluded(node));
+    }, this.opt.done);
+  }
+  registerHighlight() {
+    const highlight = this.opt.highlight;
+    if (highlight) {
+      const name = this.opt.highlightName,
+        registry = CSS.highlights;
+      if (this.rangeArray.length) {
+        registry.delete(name);
+        if (highlight.size) {
+          highlight.forEach(range => {
+            this.rangeArray.push(range);
+          });
+          highlight.clear();
+        }
+        this.rangeArray.sort((a, b) => a.absoluteOffset - b.absoluteOffset);
+        this.rangeArray.forEach(range => {
+          highlight.add(range);
+        });
+        this.rangeArray = [];
+      }
+      if (highlight.size) registry.set(name, highlight);
+    }
+  }
+}
+
+function Mark(ctx) {
+  const instance = new Mark$1(ctx);
+  this.mark = (sv, opt) => {
+    instance.mark(sv, opt);
+    return this;
+  };
+  this.markRegExp = (sv, opt) => {
+    instance.markRegExp(sv, opt);
+    return this;
+  };
+  this.markRanges = (sv, opt) => {
+    instance.markRanges(sv, opt);
+    return this;
+  };
+  this.unmark = (opt) => {
+    instance.unmark(opt);
+    return this;
+  };
+  this.getVersion = () => {
+    return '3.0.0';
+  };
+  return this;
+}
+
+export { Mark as default };