openc3-cosmos-tool-admin 5.6.0 → 5.7.0

data/tools/admin/js/661.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"js/661.js","mappings":"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","sources":["webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/constants.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/dom/ensureElement.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/dom/query.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/helpers/debounce.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/helpers/merge.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/helpers/normalizeContent.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/helpers/throttle.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/index.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/createArrow.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/getCurve.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/getEditorHeight.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/getLine.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/getMode.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/src/visuals/getTheme.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/internals/base64-map.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/internals/dom-exception-constants.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/internals/error-to-string.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/internals/try-node-require.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/es.array.find-index.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/es.regexp.constructor.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/es.regexp.dot-all.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/es.regexp.sticky.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/web.atob.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/web.dom-exception.constructor.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/web.dom-exception.stack.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/core-js/modules/web.dom-exception.to-string-tag.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff-dark.min.css","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff.min.css","webpack://@openc3/cosmos-tool-admin/../../node_modules/diff-match-patch/index.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff-dark.min.css?f649","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff.min.css?97cb","webpack://@openc3/cosmos-tool-admin/../../node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js"],"sourcesContent":["module.exports = {\n  DIFF_EQUAL: 0,\n  DIFF_DELETE: -1,\n  DIFF_INSERT: 1,\n  EDITOR_RIGHT: 'right',\n  EDITOR_LEFT: 'left',\n  RTL: 'rtl',\n  LTR: 'ltr',\n  SVG_NS: 'http://www.w3.org/2000/svg',\n  DIFF_GRANULARITY_SPECIFIC: 'specific',\n  DIFF_GRANULARITY_BROAD: 'broad',\n};\n","/**\n * Search for element in parent and create it if it can't be found\n * @param {*HTMLElement} parent\n * @param {string} elClass Element class\n *\n * Returns ID of the element\n */\nmodule.exports = function ensureElement(parent, elClass) {\n  const guid = Math.random().toString(36).substr(2, 5);\n  const newId = `js-${elClass}-${guid}`;\n\n  const currentEl = parent.querySelector(`.${elClass}`);\n  if (currentEl) {\n    currentEl.id = currentEl.id || newId;\n    return currentEl.id;\n  }\n\n  const el = document.createElement('div');\n  parent.appendChild(el);\n  el.className = elClass;\n  el.id = newId;\n  return el.id;\n};\n","function on(elSelector, eventName, selector, fn) {\n  const element = (elSelector === 'document') ? document : document.querySelector(elSelector);\n\n  element.addEventListener(eventName, (event) => {\n    const possibleTargets = element.querySelectorAll(selector);\n    const { target } = event;\n\n    for (let i = 0, l = possibleTargets.length; i < l; i += 1) {\n      let el = target;\n      const p = possibleTargets[i];\n\n      while (el && el !== element) {\n        if (el === p) {\n          fn.call(p, event);\n        }\n        el = el.parentNode;\n      }\n    }\n  });\n}\n\nmodule.exports = {\n  on,\n};\n","module.exports = function debounce(callback, wait) {\n  let timeout;\n  return (...args) => {\n    const context = this;\n    clearTimeout(timeout);\n    timeout = setTimeout(() => callback.apply(context, args), wait);\n  };\n};\n","/**\n * Simple is object check.\n * @param item\n * @returns {boolean}\n */\nfunction isObject(item) {\n  return (item && typeof item === 'object' && !Array.isArray(item) && item !== null);\n}\n\n\n/**\n* Deep merge two objects.\n* @param target\n* @param source\n*/\nmodule.exports = function merge(target, source) {\n  if (isObject(target) && isObject(source)) {\n    Object.keys(source).forEach((key) => {\n      if (isObject(source[key])) {\n        if (!target[key] || !isObject(target[key])) {\n          target[key] = source[key];\n        }\n        merge(target[key], source[key]);\n      } else {\n        Object.assign(target, { [key]: source[key] });\n      }\n    });\n  }\n  return target;\n};\n","module.exports = function normalizeContent(value = '') {\n  const normalized = value.replace(/\\r\\n/g, '\\n');\n  return normalized;\n};\n","module.exports = function throttle(callback, wait, immediate = false) {\n  let timeout = null;\n  let initialCall = true;\n\n  return (...args) => {\n    const callNow = immediate && initialCall;\n    const next = () => {\n      callback.apply(this, args);\n      timeout = null;\n    };\n\n    if (callNow) {\n      initialCall = false;\n      next();\n    }\n\n    if (!timeout) {\n      timeout = setTimeout(next, wait);\n    }\n  };\n};\n","/* eslint-disable no-use-before-define */\n/* eslint-disable no-console */\n/* eslint-disable max-len */\n\n// Diffing library\nconst DiffMatchPatch = require('diff-match-patch');\n\nconst merge = require('./helpers/merge');\nconst throttle = require('./helpers/throttle');\nconst debounce = require('./helpers/debounce');\nconst normalizeContent = require('./helpers/normalizeContent');\n\nconst getCurve = require('./visuals/getCurve');\nconst getMode = require('./visuals/getMode');\nconst getTheme = require('./visuals/getTheme');\nconst getLine = require('./visuals/getLine');\nconst getEditorHeight = require('./visuals/getEditorHeight');\nconst createArrow = require('./visuals/createArrow');\n\nconst ensureElement = require('./dom/ensureElement');\nconst query = require('./dom/query');\nconst C = require('./constants');\n\n// Range module placeholder\nlet Range;\n\nfunction getRangeModule(ace) {\n  if (ace.Range) {\n    return ace.Range;\n  }\n\n  const requireFunc = (ace.acequire || ace.require);\n  if (requireFunc) {\n    return requireFunc('ace/range');\n  }\n\n  return false;\n}\n\n// our constructor\nfunction AceDiff(options = {}) {\n  // Ensure instance is a constructor with `new`\n  if (!(this instanceof AceDiff)) {\n    return new AceDiff(options);\n  }\n\n  // Current instance we pass around to other functions\n  const acediff = this;\n  const getDefaultAce = () => (window ? window.ace : undefined);\n\n  acediff.options = merge({\n    ace: getDefaultAce(),\n    mode: null,\n    theme: null,\n    element: null,\n    diffGranularity: C.DIFF_GRANULARITY_BROAD,\n    lockScrolling: false, // not implemented yet\n    showDiffs: true,\n    showConnectors: true,\n    maxDiffs: 5000,\n    left: {\n      id: null,\n      content: null,\n      mode: null,\n      theme: null,\n      editable: true,\n      copyLinkEnabled: true,\n    },\n    right: {\n      id: null,\n      content: null,\n      mode: null,\n      theme: null,\n      editable: true,\n      copyLinkEnabled: true,\n    },\n    classes: {\n      gutterID: 'acediff__gutter',\n      diff: 'acediff__diffLine',\n      connector: 'acediff__connector',\n      newCodeConnectorLink: 'acediff__newCodeConnector',\n      newCodeConnectorLinkContent: '&#8594;',\n      deletedCodeConnectorLink: 'acediff__deletedCodeConnector',\n      deletedCodeConnectorLinkContent: '&#8592;',\n      copyRightContainer: 'acediff__copy--right',\n      copyLeftContainer: 'acediff__copy--left',\n    },\n    connectorYOffset: 0,\n  }, options);\n\n  const { ace } = acediff.options;\n\n  if (!ace) {\n    const errMessage = 'No ace editor found nor supplied - `options.ace` or `window.ace` is missing';\n    console.error(errMessage);\n    return new Error(errMessage);\n  }\n\n  Range = getRangeModule(ace);\n  if (!Range) {\n    const errMessage = 'Could not require Range module for Ace. Depends on your bundling strategy, but it usually comes with Ace itself. See https://ace.c9.io/api/range.html, open an issue on GitHub ace-diff/ace-diff';\n    console.error(errMessage);\n    return new Error(errMessage);\n  }\n\n  if (acediff.options.element === null) {\n    const errMessage = 'You need to specify an element for Ace-diff - `options.element` is missing';\n    console.error(errMessage);\n    return new Error(errMessage);\n  }\n\n  if (acediff.options.element instanceof HTMLElement) {\n    acediff.el = acediff.options.element;\n  } else {\n    acediff.el = document.body.querySelector(acediff.options.element);\n  }\n\n  if (!acediff.el) {\n    const errMessage = `Can't find the specified element ${acediff.options.element}`;\n    console.error(errMessage);\n    return new Error(errMessage);\n  }\n\n  acediff.options.left.id = ensureElement(acediff.el, 'acediff__left');\n  acediff.options.classes.gutterID = ensureElement(acediff.el, 'acediff__gutter');\n  acediff.options.right.id = ensureElement(acediff.el, 'acediff__right');\n\n  acediff.el.innerHTML = `<div class=\"acediff__wrap\">${acediff.el.innerHTML}</div>`;\n\n  // instantiate the editors in an internal data structure\n  // that will store a little info about the diffs and\n  // editor content\n  acediff.editors = {\n    left: {\n      ace: ace.edit(acediff.options.left.id),\n      markers: [],\n      lineLengths: [],\n    },\n    right: {\n      ace: ace.edit(acediff.options.right.id),\n      markers: [],\n      lineLengths: [],\n    },\n    editorHeight: null,\n  };\n\n\n  // set up the editors\n  acediff.editors.left.ace.getSession().setMode(getMode(acediff, C.EDITOR_LEFT));\n  acediff.editors.right.ace.getSession().setMode(getMode(acediff, C.EDITOR_RIGHT));\n  acediff.editors.left.ace.setReadOnly(!acediff.options.left.editable);\n  acediff.editors.right.ace.setReadOnly(!acediff.options.right.editable);\n  acediff.editors.left.ace.setTheme(getTheme(acediff, C.EDITOR_LEFT));\n  acediff.editors.right.ace.setTheme(getTheme(acediff, C.EDITOR_RIGHT));\n\n  acediff.editors.left.ace.setValue(normalizeContent(acediff.options.left.content), -1);\n  acediff.editors.right.ace.setValue(normalizeContent(acediff.options.right.content), -1);\n\n  // store the visible height of the editors (assumed the same)\n  acediff.editors.editorHeight = getEditorHeight(acediff);\n\n  // The lineHeight is set to 0 initially and we need to wait for another tick to get it\n  // Thus moving the diff() with it\n  setTimeout(() => {\n    // assumption: both editors have same line heights\n    acediff.lineHeight = acediff.editors.left.ace.renderer.lineHeight;\n\n    addEventHandlers(acediff);\n    createCopyContainers(acediff);\n    createGutter(acediff);\n    acediff.diff();\n  }, 1);\n}\n\n\n// our public API\nAceDiff.prototype = {\n\n  // allows on-the-fly changes to the AceDiff instance settings\n  setOptions(options) {\n    merge(this.options, options);\n    this.diff();\n  },\n\n  getNumDiffs() {\n    return this.diffs.length;\n  },\n\n  // exposes the Ace editors in case the dev needs it\n  getEditors() {\n    return {\n      left: this.editors.left.ace,\n      right: this.editors.right.ace,\n    };\n  },\n\n  // our main diffing function. I actually don't think this needs to exposed: it's called automatically,\n  // but just to be safe, it's included\n  diff() {\n    const dmp = new DiffMatchPatch();\n    const val1 = this.editors.left.ace.getSession().getValue();\n    const val2 = this.editors.right.ace.getSession().getValue();\n    const diff = dmp.diff_main(val2, val1);\n    dmp.diff_cleanupSemantic(diff);\n\n    this.editors.left.lineLengths = getLineLengths(this.editors.left);\n    this.editors.right.lineLengths = getLineLengths(this.editors.right);\n\n    // parse the raw diff into something a little more palatable\n    const diffs = [];\n    const offset = {\n      left: 0,\n      right: 0,\n    };\n\n    diff.forEach((chunk, index, array) => {\n      const chunkType = chunk[0];\n      let text = chunk[1];\n\n      // Fix for #28 https://github.com/ace-diff/ace-diff/issues/28\n      if (array[index + 1] && text.endsWith('\\n') && array[index + 1][1].startsWith('\\n')) {\n        text += '\\n';\n        diff[index][1] = text;\n        diff[index + 1][1] = diff[index + 1][1].replace(/^\\n/, '');\n      }\n\n      // oddly, occasionally the algorithm returns a diff with no changes made\n      if (text.length === 0) {\n        return;\n      }\n      if (chunkType === C.DIFF_EQUAL) {\n        offset.left += text.length;\n        offset.right += text.length;\n      } else if (chunkType === C.DIFF_DELETE) {\n        diffs.push(computeDiff(this, C.DIFF_DELETE, offset.left, offset.right, text));\n        offset.right += text.length;\n      } else if (chunkType === C.DIFF_INSERT) {\n        diffs.push(computeDiff(this, C.DIFF_INSERT, offset.left, offset.right, text));\n        offset.left += text.length;\n      }\n    }, this);\n\n    // simplify our computed diffs; this groups together multiple diffs on subsequent lines\n    this.diffs = simplifyDiffs(this, diffs);\n\n    // if we're dealing with too many diffs, fail silently\n    if (this.diffs.length > this.options.maxDiffs) {\n      return;\n    }\n\n    clearDiffs(this);\n    decorate(this);\n  },\n\n  destroy() {\n    // destroy the two editors\n    const leftValue = this.editors.left.ace.getValue();\n    this.editors.left.ace.destroy();\n    let oldDiv = this.editors.left.ace.container;\n    let newDiv = oldDiv.cloneNode(false);\n    newDiv.textContent = leftValue;\n    oldDiv.parentNode.replaceChild(newDiv, oldDiv);\n\n    const rightValue = this.editors.right.ace.getValue();\n    this.editors.right.ace.destroy();\n    oldDiv = this.editors.right.ace.container;\n    newDiv = oldDiv.cloneNode(false);\n    newDiv.textContent = rightValue;\n    oldDiv.parentNode.replaceChild(newDiv, oldDiv);\n\n    document.getElementById(this.options.classes.gutterID).innerHTML = '';\n    removeEventHandlers();\n  },\n};\n\nlet removeEventHandlers = () => { };\n\nfunction addEventHandlers(acediff) {\n  acediff.editors.left.ace.getSession().on('changeScrollTop', throttle(() => { updateGap(acediff); }, 16));\n  acediff.editors.right.ace.getSession().on('changeScrollTop', throttle(() => { updateGap(acediff); }, 16));\n\n  const diff = acediff.diff.bind(acediff);\n  acediff.editors.left.ace.on('change', diff);\n  acediff.editors.right.ace.on('change', diff);\n\n  if (acediff.options.left.copyLinkEnabled) {\n    query.on(`#${acediff.options.classes.gutterID}`, 'click', `.${acediff.options.classes.newCodeConnectorLink}`, (e) => {\n      copy(acediff, e, C.LTR);\n    });\n  }\n  if (acediff.options.right.copyLinkEnabled) {\n    query.on(`#${acediff.options.classes.gutterID}`, 'click', `.${acediff.options.classes.deletedCodeConnectorLink}`, (e) => {\n      copy(acediff, e, C.RTL);\n    });\n  }\n\n  const onResize = debounce(() => {\n    acediff.editors.availableHeight = document.getElementById(acediff.options.left.id).offsetHeight;\n\n    // TODO this should re-init gutter\n    acediff.diff();\n  }, 250);\n\n  window.addEventListener('resize', onResize);\n  removeEventHandlers = () => {\n    window.removeEventListener('resize', onResize);\n  };\n}\n\n\nfunction copy(acediff, e, dir) {\n  const diffIndex = parseInt(e.target.getAttribute('data-diff-index'), 10);\n  const diff = acediff.diffs[diffIndex];\n  let sourceEditor;\n  let targetEditor;\n\n  let startLine;\n  let endLine;\n  let targetStartLine;\n  let targetEndLine;\n  if (dir === C.LTR) {\n    sourceEditor = acediff.editors.left;\n    targetEditor = acediff.editors.right;\n    startLine = diff.leftStartLine;\n    endLine = diff.leftEndLine;\n    targetStartLine = diff.rightStartLine;\n    targetEndLine = diff.rightEndLine;\n  } else {\n    sourceEditor = acediff.editors.right;\n    targetEditor = acediff.editors.left;\n    startLine = diff.rightStartLine;\n    endLine = diff.rightEndLine;\n    targetStartLine = diff.leftStartLine;\n    targetEndLine = diff.leftEndLine;\n  }\n\n  let contentToInsert = '';\n  for (let i = startLine; i < endLine; i += 1) {\n    contentToInsert += `${getLine(sourceEditor, i)}\\n`;\n  }\n\n  // keep track of the scroll height\n  const h = targetEditor.ace.getSession().getScrollTop();\n  targetEditor.ace.getSession().replace(new Range(targetStartLine, 0, targetEndLine, 0), contentToInsert);\n  targetEditor.ace.getSession().setScrollTop(parseInt(h, 10));\n\n  acediff.diff();\n}\n\n\nfunction getLineLengths(editor) {\n  const lines = editor.ace.getSession().doc.getAllLines();\n  const lineLengths = [];\n  lines.forEach((line) => {\n    lineLengths.push(line.length + 1); // +1 for the newline char\n  });\n  return lineLengths;\n}\n\n\n// shows a diff in one of the two editors.\nfunction showDiff(acediff, editor, startLine, endLine, className) {\n  const editorInstance = acediff.editors[editor];\n\n  if (endLine < startLine) { // can this occur? Just in case.\n    endLine = startLine;\n  }\n\n  const classNames = `${className} ${(endLine > startLine) ? 'lines' : 'targetOnly'}`;\n\n  // to get Ace to highlight the full row we just set the start and end chars to 0 and 1\n  editorInstance.markers.push(\n    editorInstance.ace.session.addMarker(\n      new Range(\n        startLine,\n        0,\n        endLine - 1 /* because endLine is always + 1 */,\n        1,\n      ), classNames, 'fullLine',\n    ),\n  );\n}\n\n\n// called onscroll. Updates the gap to ensure the connectors are all lining up\nfunction updateGap(acediff) {\n  clearDiffs(acediff);\n  decorate(acediff);\n\n  // reposition the copy containers containing all the arrows\n  positionCopyContainers(acediff);\n}\n\n\nfunction clearDiffs(acediff) {\n  acediff.editors.left.markers.forEach((marker) => {\n    acediff.editors.left.ace.getSession().removeMarker(marker);\n  }, acediff);\n  acediff.editors.right.markers.forEach((marker) => {\n    acediff.editors.right.ace.getSession().removeMarker(marker);\n  }, acediff);\n}\n\n\nfunction addConnector(acediff, leftStartLine, leftEndLine, rightStartLine, rightEndLine) {\n  const leftScrollTop = acediff.editors.left.ace.getSession().getScrollTop();\n  const rightScrollTop = acediff.editors.right.ace.getSession().getScrollTop();\n\n  // All connectors, regardless of ltr or rtl\n  // have the same point system, even if p1 === p3 or p2 === p4\n  //  p1   p2\n  //\n  //  p3   p4\n\n  acediff.connectorYOffset = 1;\n\n  const p1_x = -1;\n  const p1_y = (leftStartLine * acediff.lineHeight) - leftScrollTop + 0.5;\n  const p2_x = acediff.gutterWidth + 1;\n  const p2_y = rightStartLine * acediff.lineHeight - rightScrollTop + 0.5;\n  const p3_x = -1;\n  const p3_y = (leftEndLine * acediff.lineHeight) - leftScrollTop + acediff.connectorYOffset + 0.5;\n  const p4_x = acediff.gutterWidth + 1;\n  const p4_y = (rightEndLine * acediff.lineHeight) - rightScrollTop + acediff.connectorYOffset + 0.5;\n  const curve1 = getCurve(p1_x, p1_y, p2_x, p2_y);\n  const curve2 = getCurve(p4_x, p4_y, p3_x, p3_y);\n\n  const verticalLine1 = `L${p2_x},${p2_y} ${p4_x},${p4_y}`;\n  const verticalLine2 = `L${p3_x},${p3_y} ${p1_x},${p1_y}`;\n  const d = `${curve1} ${verticalLine1} ${curve2} ${verticalLine2}`;\n\n  const el = document.createElementNS(C.SVG_NS, 'path');\n  el.setAttribute('d', d);\n  el.setAttribute('class', acediff.options.classes.connector);\n  acediff.gutterSVG.appendChild(el);\n}\n\n\nfunction addCopyArrows(acediff, info, diffIndex) {\n  if (info.leftEndLine > info.leftStartLine && acediff.options.left.copyLinkEnabled) {\n    const arrow = createArrow({\n      className: acediff.options.classes.newCodeConnectorLink,\n      topOffset: info.leftStartLine * acediff.lineHeight,\n      tooltip: 'Copy to right',\n      diffIndex,\n      arrowContent: acediff.options.classes.newCodeConnectorLinkContent,\n    });\n    acediff.copyRightContainer.appendChild(arrow);\n  }\n\n  if (info.rightEndLine > info.rightStartLine && acediff.options.right.copyLinkEnabled) {\n    const arrow = createArrow({\n      className: acediff.options.classes.deletedCodeConnectorLink,\n      topOffset: info.rightStartLine * acediff.lineHeight,\n      tooltip: 'Copy to left',\n      diffIndex,\n      arrowContent: acediff.options.classes.deletedCodeConnectorLinkContent,\n    });\n    acediff.copyLeftContainer.appendChild(arrow);\n  }\n}\n\n\nfunction positionCopyContainers(acediff) {\n  const leftTopOffset = acediff.editors.left.ace.getSession().getScrollTop();\n  const rightTopOffset = acediff.editors.right.ace.getSession().getScrollTop();\n\n  acediff.copyRightContainer.style.cssText = `top: ${-leftTopOffset}px`;\n  acediff.copyLeftContainer.style.cssText = `top: ${-rightTopOffset}px`;\n}\n\n\n/**\n // eslint-disable-next-line max-len\n * This method takes the raw diffing info from the Google lib and returns a nice clean object of the following\n * form:\n * {\n *   leftStartLine:\n *   leftEndLine:\n *   rightStartLine:\n *   rightEndLine:\n * }\n *\n * Ultimately, that's all the info we need to highlight the appropriate lines in the left + right editor, add the\n * SVG connectors, and include the appropriate <<, >> arrows.\n *\n * Note: leftEndLine and rightEndLine are always the start of the NEXT line, so for a single line diff, there will\n * be 1 separating the startLine and endLine values. So if leftStartLine === leftEndLine or rightStartLine ===\n * rightEndLine, it means that new content from the other editor is being inserted and a single 1px line will be\n * drawn.\n */\nfunction computeDiff(acediff, diffType, offsetLeft, offsetRight, diffText) {\n  let lineInfo = {};\n\n  // this was added in to hack around an oddity with the Google lib. Sometimes it would include a newline\n  // as the first char for a diff, other times not - and it would change when you were typing on-the-fly. This\n  // is used to level things out so the diffs don't appear to shift around\n  let newContentStartsWithNewline = /^\\n/.test(diffText);\n\n  if (diffType === C.DIFF_INSERT) {\n    // pretty confident this returns the right stuff for the left editor: start & end line & char\n    var info = getSingleDiffInfo(acediff.editors.left, offsetLeft, diffText);\n\n    // this is the ACTUAL undoctored current line in the other editor. It's always right. Doesn't mean it's\n    // going to be used as the start line for the diff though.\n    var currentLineOtherEditor = getLineForCharPosition(acediff.editors.right, offsetRight);\n    var numCharsOnLineOtherEditor = getCharsOnLine(acediff.editors.right, currentLineOtherEditor);\n    const numCharsOnLeftEditorStartLine = getCharsOnLine(acediff.editors.left, info.startLine);\n    var numCharsOnLine = getCharsOnLine(acediff.editors.left, info.startLine);\n\n    // this is necessary because if a new diff starts on the FIRST char of the left editor, the diff can comes\n    // back from google as being on the last char of the previous line so we need to bump it up one\n    let rightStartLine = currentLineOtherEditor;\n    if (numCharsOnLine === 0 && newContentStartsWithNewline) {\n      newContentStartsWithNewline = false;\n    }\n    if (info.startChar === 0 && isLastChar(acediff.editors.right, offsetRight, newContentStartsWithNewline)) {\n      rightStartLine = currentLineOtherEditor + 1;\n    }\n\n    var sameLineInsert = info.startLine === info.endLine;\n\n    // whether or not this diff is a plain INSERT into the other editor, or overwrites a line take a little work to\n    // figure out. This feels like the hardest part of the entire script.\n    var numRows = 0;\n    if (\n\n      // dense, but this accommodates two scenarios:\n      // 1. where a completely fresh new line is being inserted in left editor, we want the line on right to stay a 1px line\n      // 2. where a new character is inserted at the start of a newline on the left but the line contains other stuff,\n      //    we DO want to make it a full line\n      (info.startChar > 0 || (sameLineInsert && diffText.length < numCharsOnLeftEditorStartLine))\n\n      // if the right editor line was empty, it's ALWAYS a single line insert [not an OR above?]\n      && numCharsOnLineOtherEditor > 0\n\n      // if the text being inserted starts mid-line\n      && (info.startChar < numCharsOnLeftEditorStartLine)) {\n      numRows++;\n    }\n\n    lineInfo = {\n      leftStartLine: info.startLine,\n      leftEndLine: info.endLine + 1,\n      rightStartLine,\n      rightEndLine: rightStartLine + numRows,\n    };\n  } else {\n    var info = getSingleDiffInfo(acediff.editors.right, offsetRight, diffText);\n\n    var currentLineOtherEditor = getLineForCharPosition(acediff.editors.left, offsetLeft);\n    var numCharsOnLineOtherEditor = getCharsOnLine(acediff.editors.left, currentLineOtherEditor);\n    const numCharsOnRightEditorStartLine = getCharsOnLine(acediff.editors.right, info.startLine);\n    var numCharsOnLine = getCharsOnLine(acediff.editors.right, info.startLine);\n\n    // this is necessary because if a new diff starts on the FIRST char of the left editor, the diff can comes\n    // back from google as being on the last char of the previous line so we need to bump it up one\n    let leftStartLine = currentLineOtherEditor;\n    if (numCharsOnLine === 0 && newContentStartsWithNewline) {\n      newContentStartsWithNewline = false;\n    }\n    if (info.startChar === 0 && isLastChar(acediff.editors.left, offsetLeft, newContentStartsWithNewline)) {\n      leftStartLine = currentLineOtherEditor + 1;\n    }\n\n    var sameLineInsert = info.startLine === info.endLine;\n    var numRows = 0;\n    if (\n\n      // dense, but this accommodates two scenarios:\n      // 1. where a completely fresh new line is being inserted in left editor, we want the line on right to stay a 1px line\n      // 2. where a new character is inserted at the start of a newline on the left but the line contains other stuff,\n      //    we DO want to make it a full line\n      (info.startChar > 0 || (sameLineInsert && diffText.length < numCharsOnRightEditorStartLine))\n\n      // if the right editor line was empty, it's ALWAYS a single line insert [not an OR above?]\n      && numCharsOnLineOtherEditor > 0\n\n      // if the text being inserted starts mid-line\n      && (info.startChar < numCharsOnRightEditorStartLine)) {\n      numRows++;\n    }\n\n    lineInfo = {\n      leftStartLine,\n      leftEndLine: leftStartLine + numRows,\n      rightStartLine: info.startLine,\n      rightEndLine: info.endLine + 1,\n    };\n  }\n\n  return lineInfo;\n}\n\n\n// helper to return the startline, endline, startChar and endChar for a diff in a particular editor. Pretty\n// fussy function\nfunction getSingleDiffInfo(editor, offset, diffString) {\n  const info = {\n    startLine: 0,\n    startChar: 0,\n    endLine: 0,\n    endChar: 0,\n  };\n  const endCharNum = offset + diffString.length;\n  let runningTotal = 0;\n  let startLineSet = false;\n  let endLineSet = false;\n\n  editor.lineLengths.forEach((lineLength, lineIndex) => {\n    runningTotal += lineLength;\n\n    if (!startLineSet && offset < runningTotal) {\n      info.startLine = lineIndex;\n      info.startChar = offset - runningTotal + lineLength;\n      startLineSet = true;\n    }\n\n    if (!endLineSet && endCharNum <= runningTotal) {\n      info.endLine = lineIndex;\n      info.endChar = endCharNum - runningTotal + lineLength;\n      endLineSet = true;\n    }\n  });\n\n  // if the start char is the final char on the line, it's a newline & we ignore it\n  if (info.startChar > 0 && getCharsOnLine(editor, info.startLine) === info.startChar) {\n    info.startLine++;\n    info.startChar = 0;\n  }\n\n  // if the end char is the first char on the line, we don't want to highlight that extra line\n  if (info.endChar === 0) {\n    info.endLine--;\n  }\n\n  const endsWithNewline = /\\n$/.test(diffString);\n  if (info.startChar > 0 && endsWithNewline) {\n    info.endLine++;\n  }\n\n  return info;\n}\n\n\n// note that this and everything else in this script uses 0-indexed row numbers\nfunction getCharsOnLine(editor, line) {\n  return getLine(editor, line).length;\n}\n\n\nfunction getLineForCharPosition(editor, offsetChars) {\n  const lines = editor.ace.getSession().doc.getAllLines();\n  let foundLine = 0;\n  let runningTotal = 0;\n\n  for (let i = 0; i < lines.length; i += 1) {\n    runningTotal += lines[i].length + 1; // +1 needed for newline char\n    if (offsetChars <= runningTotal) {\n      foundLine = i;\n      break;\n    }\n  }\n  return foundLine;\n}\n\n\nfunction isLastChar(editor, char, startsWithNewline) {\n  const lines = editor.ace.getSession().doc.getAllLines();\n  let runningTotal = 0;\n\n  for (let i = 0; i < lines.length; i += 1) {\n    runningTotal += lines[i].length + 1; // +1 needed for newline char\n    let comparison = runningTotal;\n    if (startsWithNewline) {\n      comparison -= 1;\n    }\n\n    if (char === comparison) {\n      break;\n    }\n  }\n  return isLastChar;\n}\n\nfunction createGutter(acediff) {\n  acediff.gutterHeight = document.getElementById(acediff.options.classes.gutterID).clientHeight;\n  acediff.gutterWidth = document.getElementById(acediff.options.classes.gutterID).clientWidth;\n\n  const leftHeight = getTotalHeight(acediff, C.EDITOR_LEFT);\n  const rightHeight = getTotalHeight(acediff, C.EDITOR_RIGHT);\n  const height = Math.max(leftHeight, rightHeight, acediff.gutterHeight);\n\n  acediff.gutterSVG = document.createElementNS(C.SVG_NS, 'svg');\n  acediff.gutterSVG.setAttribute('width', acediff.gutterWidth);\n  acediff.gutterSVG.setAttribute('height', height);\n\n  document.getElementById(acediff.options.classes.gutterID).appendChild(acediff.gutterSVG);\n}\n\n// acediff.editors.left.ace.getSession().getLength() * acediff.lineHeight\nfunction getTotalHeight(acediff, editor) {\n  const ed = (editor === C.EDITOR_LEFT) ? acediff.editors.left : acediff.editors.right;\n  return ed.ace.getSession().getLength() * acediff.lineHeight;\n}\n\n// creates two contains for positioning the copy left + copy right arrows\nfunction createCopyContainers(acediff) {\n  acediff.copyRightContainer = document.createElement('div');\n  acediff.copyRightContainer.setAttribute('class', acediff.options.classes.copyRightContainer);\n  acediff.copyLeftContainer = document.createElement('div');\n  acediff.copyLeftContainer.setAttribute('class', acediff.options.classes.copyLeftContainer);\n\n  document.getElementById(acediff.options.classes.gutterID).appendChild(acediff.copyRightContainer);\n  document.getElementById(acediff.options.classes.gutterID).appendChild(acediff.copyLeftContainer);\n}\n\n\nfunction clearGutter(acediff) {\n  // gutter.innerHTML = '';\n\n  const gutterEl = document.getElementById(acediff.options.classes.gutterID);\n  gutterEl.removeChild(acediff.gutterSVG);\n\n  createGutter(acediff);\n}\n\n\nfunction clearArrows(acediff) {\n  acediff.copyLeftContainer.innerHTML = '';\n  acediff.copyRightContainer.innerHTML = '';\n}\n\n\n/*\n  * This combines multiple rows where, say, line 1 => line 1, line 2 => line 2, line 3-4 => line 3. That could be\n  * reduced to a single connector line 1=4 => line 1-3\n  */\nfunction simplifyDiffs(acediff, diffs) {\n  const groupedDiffs = [];\n\n  function compare(val) {\n    return (acediff.options.diffGranularity === C.DIFF_GRANULARITY_SPECIFIC) ? val < 1 : val <= 1;\n  }\n\n  diffs.forEach((diff, index) => {\n    if (index === 0) {\n      groupedDiffs.push(diff);\n      return;\n    }\n\n    // loop through all grouped diffs. If this new diff lies between an existing one, we'll just add to it, rather\n    // than create a new one\n    let isGrouped = false;\n    for (let i = 0; i < groupedDiffs.length; i += 1) {\n      if (compare(Math.abs(diff.leftStartLine - groupedDiffs[i].leftEndLine))\n        && compare(Math.abs(diff.rightStartLine - groupedDiffs[i].rightEndLine))) {\n        // update the existing grouped diff to expand its horizons to include this new diff start + end lines\n        groupedDiffs[i].leftStartLine = Math.min(diff.leftStartLine, groupedDiffs[i].leftStartLine);\n        groupedDiffs[i].rightStartLine = Math.min(diff.rightStartLine, groupedDiffs[i].rightStartLine);\n        groupedDiffs[i].leftEndLine = Math.max(diff.leftEndLine, groupedDiffs[i].leftEndLine);\n        groupedDiffs[i].rightEndLine = Math.max(diff.rightEndLine, groupedDiffs[i].rightEndLine);\n        isGrouped = true;\n        break;\n      }\n    }\n\n    if (!isGrouped) {\n      groupedDiffs.push(diff);\n    }\n  });\n\n  // clear out any single line diffs (i.e. single line on both editors)\n  const fullDiffs = [];\n  groupedDiffs.forEach((diff) => {\n    if (diff.leftStartLine === diff.leftEndLine && diff.rightStartLine === diff.rightEndLine) {\n      return;\n    }\n    fullDiffs.push(diff);\n  });\n\n  return fullDiffs;\n}\n\n\nfunction decorate(acediff) {\n  clearGutter(acediff);\n  clearArrows(acediff);\n\n  acediff.diffs.forEach((info, diffIndex) => {\n    if (acediff.options.showDiffs) {\n      showDiff(acediff, C.EDITOR_LEFT, info.leftStartLine, info.leftEndLine, acediff.options.classes.diff);\n      showDiff(acediff, C.EDITOR_RIGHT, info.rightStartLine, info.rightEndLine, acediff.options.classes.diff);\n\n      if (acediff.options.showConnectors) {\n        addConnector(acediff, info.leftStartLine, info.leftEndLine, info.rightStartLine, info.rightEndLine);\n      }\n      addCopyArrows(acediff, info, diffIndex);\n    }\n  }, acediff);\n}\n\nmodule.exports = AceDiff;\n","module.exports = function createArrow(info) {\n  const el = document.createElement('div');\n  const props = {\n    class: info.className,\n    style: `top:${info.topOffset}px`,\n    title: info.tooltip,\n    'data-diff-index': info.diffIndex,\n  };\n  for (const key in props) {\n    el.setAttribute(key, props[key]);\n  }\n  el.innerHTML = info.arrowContent;\n  return el;\n};\n","// generates a Bezier curve in SVG format\nmodule.exports = function getCurve(startX, startY, endX, endY) {\n  const w = endX - startX;\n  const halfWidth = startX + w / 2;\n\n  // now create the curve\n  // position it at the initial x,y coords\n  // This is of the form \"C M,N O,P Q,R\" where C is a directive for SVG (\"curveto\"),\n  // M,N are the first curve control point, O,P the second control point\n  // and Q,R are the final coords\n\n  return `M ${startX} ${startY} C ${halfWidth},${startY} ${halfWidth},${endY} ${endX},${endY}`;\n};\n","module.exports = function getEditorHeight(acediff) {\n  // editorHeight: document.getElementById(acediff.options.left.id).clientHeight\n  return document.getElementById(acediff.options.left.id).offsetHeight;\n};\n","module.exports = function getLine(editor, line) {\n  return editor.ace.getSession().doc.getLine(line);\n};\n","const C = require('../constants');\n\nmodule.exports = function getMode(acediff, editor) {\n  let { mode } = acediff.options;\n  if (editor === C.EDITOR_LEFT && acediff.options.left.mode !== null) {\n    mode = acediff.options.left.mode;\n  }\n  if (editor === C.EDITOR_RIGHT && acediff.options.right.mode !== null) {\n    mode = acediff.options.right.mode;\n  }\n  return mode;\n};\n","const C = require('../constants');\n\nmodule.exports = function getTheme(acediff, editor) {\n  let { theme } = acediff.options;\n  if (editor === C.EDITOR_LEFT && acediff.options.left.theme !== null) {\n    theme = acediff.options.left.theme;\n  }\n  if (editor === C.EDITOR_RIGHT && acediff.options.right.theme !== null) {\n    theme = acediff.options.right.theme;\n  }\n  return theme;\n};\n","var itoc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\nvar ctoi = {};\n\nfor (var index = 0; index < 66; index++) ctoi[itoc.charAt(index)] = index;\n\nmodule.exports = {\n  itoc: itoc,\n  ctoi: ctoi\n};\n","module.exports = {\n  IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },\n  DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },\n  HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },\n  WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },\n  InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },\n  NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },\n  NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },\n  NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },\n  NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },\n  InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },\n  InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },\n  SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },\n  InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },\n  NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },\n  InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },\n  ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },\n  TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },\n  SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },\n  NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },\n  AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },\n  URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },\n  QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },\n  TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },\n  InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },\n  DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar anObject = require('../internals/an-object');\nvar create = require('../internals/object-create');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\n\nvar nativeErrorToString = Error.prototype.toString;\n\nvar INCORRECT_TO_STRING = fails(function () {\n  if (DESCRIPTORS) {\n    // Chrome 32- incorrectly call accessor\n    // eslint-disable-next-line es/no-object-defineproperty -- safe\n    var object = create(Object.defineProperty({}, 'name', { get: function () {\n      return this === object;\n    } }));\n    if (nativeErrorToString.call(object) !== 'true') return true;\n  }\n  // FF10- does not properly handle non-strings\n  return nativeErrorToString.call({ message: 1, name: 2 }) !== '2: 1'\n    // IE8 does not properly handle defaults\n    || nativeErrorToString.call({}) !== 'Error';\n});\n\nmodule.exports = INCORRECT_TO_STRING ? function toString() {\n  var O = anObject(this);\n  var name = normalizeStringArgument(O.name, 'Error');\n  var message = normalizeStringArgument(O.message);\n  return !name ? message : !message ? name : name + ': ' + message;\n} : nativeErrorToString;\n","var IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = function (name) {\n  try {\n    // eslint-disable-next-line no-new-func -- safe\n    if (IS_NODE) return Function('return require(\"' + name + '\")')();\n  } catch (error) { /* empty */ }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $findIndex = require('../internals/array-iteration').findIndex;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\nvar FIND_INDEX = 'findIndex';\nvar SKIPS_HOLES = true;\n\n// Shouldn't skip holes\n// eslint-disable-next-line es/no-array-prototype-findindex -- testing\nif (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.findIndex` method\n// https://tc39.es/ecma262/#sec-array.prototype.findindex\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {\n  findIndex: function findIndex(callbackfn /* , that = undefined */) {\n    return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND_INDEX);\n","var DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar isRegExp = require('../internals/is-regexp');\nvar toString = require('../internals/to-string');\nvar getRegExpFlags = require('../internals/regexp-get-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar proxyAccessor = require('../internals/proxy-accessor');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar fails = require('../internals/fails');\nvar hasOwn = require('../internals/has-own-property');\nvar enforceInternalState = require('../internals/internal-state').enforce;\nvar setSpecies = require('../internals/set-species');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');\n\nvar MATCH = wellKnownSymbol('match');\nvar NativeRegExp = global.RegExp;\nvar RegExpPrototype = NativeRegExp.prototype;\nvar SyntaxError = global.SyntaxError;\nvar exec = uncurryThis(RegExpPrototype.exec);\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n// TODO: Use only proper RegExpIdentifierName\nvar IS_NCG = /^\\?<[^\\s\\d!#%&*+<=>@^][^\\s!#%&*+<=>@^]*>/;\nvar re1 = /a/g;\nvar re2 = /a/g;\n\n// \"new\" should create a new object, old webkit bug\nvar CORRECT_NEW = new NativeRegExp(re1) !== re1;\n\nvar MISSED_STICKY = stickyHelpers.MISSED_STICKY;\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;\n\nvar BASE_FORCED = DESCRIPTORS &&\n  (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails(function () {\n    re2[MATCH] = false;\n    // RegExp constructor can alter flags and IsRegExp works correct with @@match\n    return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';\n  }));\n\nvar handleDotAll = function (string) {\n  var length = string.length;\n  var index = 0;\n  var result = '';\n  var brackets = false;\n  var chr;\n  for (; index <= length; index++) {\n    chr = charAt(string, index);\n    if (chr === '\\\\') {\n      result += chr + charAt(string, ++index);\n      continue;\n    }\n    if (!brackets && chr === '.') {\n      result += '[\\\\s\\\\S]';\n    } else {\n      if (chr === '[') {\n        brackets = true;\n      } else if (chr === ']') {\n        brackets = false;\n      } result += chr;\n    }\n  } return result;\n};\n\nvar handleNCG = function (string) {\n  var length = string.length;\n  var index = 0;\n  var result = '';\n  var named = [];\n  var names = {};\n  var brackets = false;\n  var ncg = false;\n  var groupid = 0;\n  var groupname = '';\n  var chr;\n  for (; index <= length; index++) {\n    chr = charAt(string, index);\n    if (chr === '\\\\') {\n      chr = chr + charAt(string, ++index);\n    } else if (chr === ']') {\n      brackets = false;\n    } else if (!brackets) switch (true) {\n      case chr === '[':\n        brackets = true;\n        break;\n      case chr === '(':\n        if (exec(IS_NCG, stringSlice(string, index + 1))) {\n          index += 2;\n          ncg = true;\n        }\n        result += chr;\n        groupid++;\n        continue;\n      case chr === '>' && ncg:\n        if (groupname === '' || hasOwn(names, groupname)) {\n          throw new SyntaxError('Invalid capture group name');\n        }\n        names[groupname] = true;\n        named[named.length] = [groupname, groupid];\n        ncg = false;\n        groupname = '';\n        continue;\n    }\n    if (ncg) groupname += chr;\n    else result += chr;\n  } return [result, named];\n};\n\n// `RegExp` constructor\n// https://tc39.es/ecma262/#sec-regexp-constructor\nif (isForced('RegExp', BASE_FORCED)) {\n  var RegExpWrapper = function RegExp(pattern, flags) {\n    var thisIsRegExp = isPrototypeOf(RegExpPrototype, this);\n    var patternIsRegExp = isRegExp(pattern);\n    var flagsAreUndefined = flags === undefined;\n    var groups = [];\n    var rawPattern = pattern;\n    var rawFlags, dotAll, sticky, handled, result, state;\n\n    if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {\n      return pattern;\n    }\n\n    if (patternIsRegExp || isPrototypeOf(RegExpPrototype, pattern)) {\n      pattern = pattern.source;\n      if (flagsAreUndefined) flags = getRegExpFlags(rawPattern);\n    }\n\n    pattern = pattern === undefined ? '' : toString(pattern);\n    flags = flags === undefined ? '' : toString(flags);\n    rawPattern = pattern;\n\n    if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {\n      dotAll = !!flags && stringIndexOf(flags, 's') > -1;\n      if (dotAll) flags = replace(flags, /s/g, '');\n    }\n\n    rawFlags = flags;\n\n    if (MISSED_STICKY && 'sticky' in re1) {\n      sticky = !!flags && stringIndexOf(flags, 'y') > -1;\n      if (sticky && UNSUPPORTED_Y) flags = replace(flags, /y/g, '');\n    }\n\n    if (UNSUPPORTED_NCG) {\n      handled = handleNCG(pattern);\n      pattern = handled[0];\n      groups = handled[1];\n    }\n\n    result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper);\n\n    if (dotAll || sticky || groups.length) {\n      state = enforceInternalState(result);\n      if (dotAll) {\n        state.dotAll = true;\n        state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);\n      }\n      if (sticky) state.sticky = true;\n      if (groups.length) state.groups = groups;\n    }\n\n    if (pattern !== rawPattern) try {\n      // fails in old engines, but we have no alternatives for unsupported regex syntax\n      createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);\n    } catch (error) { /* empty */ }\n\n    return result;\n  };\n\n  for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {\n    proxyAccessor(RegExpWrapper, NativeRegExp, keys[index++]);\n  }\n\n  RegExpPrototype.constructor = RegExpWrapper;\n  RegExpWrapper.prototype = RegExpPrototype;\n  defineBuiltIn(global, 'RegExp', RegExpWrapper, { constructor: true });\n}\n\n// https://tc39.es/ecma262/#sec-get-regexp-@@species\nsetSpecies('RegExp');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar classof = require('../internals/classof-raw');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar getInternalState = require('../internals/internal-state').get;\n\nvar RegExpPrototype = RegExp.prototype;\nvar $TypeError = TypeError;\n\n// `RegExp.prototype.dotAll` getter\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall\nif (DESCRIPTORS && UNSUPPORTED_DOT_ALL) {\n  defineBuiltInAccessor(RegExpPrototype, 'dotAll', {\n    configurable: true,\n    get: function dotAll() {\n      if (this === RegExpPrototype) return undefined;\n      // We can't use InternalStateModule.getterFor because\n      // we don't add metadata for regexps created by a literal.\n      if (classof(this) === 'RegExp') {\n        return !!getInternalState(this).dotAll;\n      }\n      throw $TypeError('Incompatible receiver, RegExp required');\n    }\n  });\n}\n","var DESCRIPTORS = require('../internals/descriptors');\nvar MISSED_STICKY = require('../internals/regexp-sticky-helpers').MISSED_STICKY;\nvar classof = require('../internals/classof-raw');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar getInternalState = require('../internals/internal-state').get;\n\nvar RegExpPrototype = RegExp.prototype;\nvar $TypeError = TypeError;\n\n// `RegExp.prototype.sticky` getter\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.sticky\nif (DESCRIPTORS && MISSED_STICKY) {\n  defineBuiltInAccessor(RegExpPrototype, 'sticky', {\n    configurable: true,\n    get: function sticky() {\n      if (this === RegExpPrototype) return;\n      // We can't use InternalStateModule.getterFor because\n      // we don't add metadata for regexps created by a literal.\n      if (classof(this) === 'RegExp') {\n        return !!getInternalState(this).sticky;\n      }\n      throw $TypeError('Incompatible receiver, RegExp required');\n    }\n  });\n}\n","var $ = require('../internals/export');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar toString = require('../internals/to-string');\nvar hasOwn = require('../internals/has-own-property');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar ctoi = require('../internals/base64-map').ctoi;\n\nvar disallowed = /[^\\d+/a-z]/i;\nvar whitespaces = /[\\t\\n\\f\\r ]+/g;\nvar finalEq = /[=]{1,2}$/;\n\nvar $atob = getBuiltIn('atob');\nvar fromCharCode = String.fromCharCode;\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar exec = uncurryThis(disallowed.exec);\n\nvar NO_SPACES_IGNORE = fails(function () {\n  return $atob(' ') !== '';\n});\n\nvar NO_ENCODING_CHECK = !fails(function () {\n  $atob('a');\n});\n\nvar NO_ARG_RECEIVING_CHECK = !NO_SPACES_IGNORE && !NO_ENCODING_CHECK && !fails(function () {\n  $atob();\n});\n\nvar WRONG_ARITY = !NO_SPACES_IGNORE && !NO_ENCODING_CHECK && $atob.length !== 1;\n\n// `atob` method\n// https://html.spec.whatwg.org/multipage/webappapis.html#dom-atob\n$({ global: true, bind: true, enumerable: true, forced: NO_SPACES_IGNORE || NO_ENCODING_CHECK || NO_ARG_RECEIVING_CHECK || WRONG_ARITY }, {\n  atob: function atob(data) {\n    validateArgumentsLength(arguments.length, 1);\n    // `webpack` dev server bug on IE global methods - use call(fn, global, ...)\n    if (NO_ARG_RECEIVING_CHECK || WRONG_ARITY) return call($atob, global, data);\n    var string = replace(toString(data), whitespaces, '');\n    var output = '';\n    var position = 0;\n    var bc = 0;\n    var chr, bs;\n    if (string.length % 4 == 0) {\n      string = replace(string, finalEq, '');\n    }\n    if (string.length % 4 == 1 || exec(disallowed, string)) {\n      throw new (getBuiltIn('DOMException'))('The string is not correctly encoded', 'InvalidCharacterError');\n    }\n    while (chr = charAt(string, position++)) {\n      if (hasOwn(ctoi, chr)) {\n        bs = bc % 4 ? bs * 64 + ctoi[chr] : ctoi[chr];\n        if (bc++ % 4) output += fromCharCode(255 & bs >> (-2 * bc & 6));\n      }\n    } return output;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar tryNodeRequire = require('../internals/try-node-require');\nvar getBuiltIn = require('../internals/get-built-in');\nvar fails = require('../internals/fails');\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar hasOwn = require('../internals/has-own-property');\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar errorToString = require('../internals/error-to-string');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar DOMExceptionConstants = require('../internals/dom-exception-constants');\nvar clearErrorStack = require('../internals/error-stack-clear');\nvar InternalStateModule = require('../internals/internal-state');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IS_PURE = require('../internals/is-pure');\n\nvar DOM_EXCEPTION = 'DOMException';\nvar DATA_CLONE_ERR = 'DATA_CLONE_ERR';\nvar Error = getBuiltIn('Error');\n// NodeJS < 17.0 does not expose `DOMException` to global\nvar NativeDOMException = getBuiltIn(DOM_EXCEPTION) || (function () {\n  try {\n    // NodeJS < 15.0 does not expose `MessageChannel` to global\n    var MessageChannel = getBuiltIn('MessageChannel') || tryNodeRequire('worker_threads').MessageChannel;\n    // eslint-disable-next-line es/no-weak-map, unicorn/require-post-message-target-origin -- safe\n    new MessageChannel().port1.postMessage(new WeakMap());\n  } catch (error) {\n    if (error.name == DATA_CLONE_ERR && error.code == 25) return error.constructor;\n  }\n})();\nvar NativeDOMExceptionPrototype = NativeDOMException && NativeDOMException.prototype;\nvar ErrorPrototype = Error.prototype;\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(DOM_EXCEPTION);\nvar HAS_STACK = 'stack' in Error(DOM_EXCEPTION);\n\nvar codeFor = function (name) {\n  return hasOwn(DOMExceptionConstants, name) && DOMExceptionConstants[name].m ? DOMExceptionConstants[name].c : 0;\n};\n\nvar $DOMException = function DOMException() {\n  anInstance(this, DOMExceptionPrototype);\n  var argumentsLength = arguments.length;\n  var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);\n  var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');\n  var code = codeFor(name);\n  setInternalState(this, {\n    type: DOM_EXCEPTION,\n    name: name,\n    message: message,\n    code: code\n  });\n  if (!DESCRIPTORS) {\n    this.name = name;\n    this.message = message;\n    this.code = code;\n  }\n  if (HAS_STACK) {\n    var error = Error(message);\n    error.name = DOM_EXCEPTION;\n    defineProperty(this, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));\n  }\n};\n\nvar DOMExceptionPrototype = $DOMException.prototype = create(ErrorPrototype);\n\nvar createGetterDescriptor = function (get) {\n  return { enumerable: true, configurable: true, get: get };\n};\n\nvar getterFor = function (key) {\n  return createGetterDescriptor(function () {\n    return getInternalState(this)[key];\n  });\n};\n\nif (DESCRIPTORS) {\n  // `DOMException.prototype.code` getter\n  defineBuiltInAccessor(DOMExceptionPrototype, 'code', getterFor('code'));\n  // `DOMException.prototype.message` getter\n  defineBuiltInAccessor(DOMExceptionPrototype, 'message', getterFor('message'));\n  // `DOMException.prototype.name` getter\n  defineBuiltInAccessor(DOMExceptionPrototype, 'name', getterFor('name'));\n}\n\ndefineProperty(DOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, $DOMException));\n\n// FF36- DOMException is a function, but can't be constructed\nvar INCORRECT_CONSTRUCTOR = fails(function () {\n  return !(new NativeDOMException() instanceof Error);\n});\n\n// Safari 10.1 / Chrome 32- / IE8- DOMException.prototype.toString bugs\nvar INCORRECT_TO_STRING = INCORRECT_CONSTRUCTOR || fails(function () {\n  return ErrorPrototype.toString !== errorToString || String(new NativeDOMException(1, 2)) !== '2: 1';\n});\n\n// Deno 1.6.3- DOMException.prototype.code just missed\nvar INCORRECT_CODE = INCORRECT_CONSTRUCTOR || fails(function () {\n  return new NativeDOMException(1, 'DataCloneError').code !== 25;\n});\n\n// Deno 1.6.3- DOMException constants just missed\nvar MISSED_CONSTANTS = INCORRECT_CONSTRUCTOR\n  || NativeDOMException[DATA_CLONE_ERR] !== 25\n  || NativeDOMExceptionPrototype[DATA_CLONE_ERR] !== 25;\n\nvar FORCED_CONSTRUCTOR = IS_PURE ? INCORRECT_TO_STRING || INCORRECT_CODE || MISSED_CONSTANTS : INCORRECT_CONSTRUCTOR;\n\n// `DOMException` constructor\n// https://webidl.spec.whatwg.org/#idl-DOMException\n$({ global: true, constructor: true, forced: FORCED_CONSTRUCTOR }, {\n  DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException\n});\n\nvar PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);\nvar PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;\n\nif (INCORRECT_TO_STRING && (IS_PURE || NativeDOMException === PolyfilledDOMException)) {\n  defineBuiltIn(PolyfilledDOMExceptionPrototype, 'toString', errorToString);\n}\n\nif (INCORRECT_CODE && DESCRIPTORS && NativeDOMException === PolyfilledDOMException) {\n  defineBuiltInAccessor(PolyfilledDOMExceptionPrototype, 'code', createGetterDescriptor(function () {\n    return codeFor(anObject(this).name);\n  }));\n}\n\n// `DOMException` constants\nfor (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {\n  var constant = DOMExceptionConstants[key];\n  var constantName = constant.s;\n  var descriptor = createPropertyDescriptor(6, constant.c);\n  if (!hasOwn(PolyfilledDOMException, constantName)) {\n    defineProperty(PolyfilledDOMException, constantName, descriptor);\n  }\n  if (!hasOwn(PolyfilledDOMExceptionPrototype, constantName)) {\n    defineProperty(PolyfilledDOMExceptionPrototype, constantName, descriptor);\n  }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar anInstance = require('../internals/an-instance');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar DOMExceptionConstants = require('../internals/dom-exception-constants');\nvar clearErrorStack = require('../internals/error-stack-clear');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IS_PURE = require('../internals/is-pure');\n\nvar DOM_EXCEPTION = 'DOMException';\nvar Error = getBuiltIn('Error');\nvar NativeDOMException = getBuiltIn(DOM_EXCEPTION);\n\nvar $DOMException = function DOMException() {\n  anInstance(this, DOMExceptionPrototype);\n  var argumentsLength = arguments.length;\n  var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);\n  var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');\n  var that = new NativeDOMException(message, name);\n  var error = Error(message);\n  error.name = DOM_EXCEPTION;\n  defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));\n  inheritIfRequired(that, this, $DOMException);\n  return that;\n};\n\nvar DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;\n\nvar ERROR_HAS_STACK = 'stack' in Error(DOM_EXCEPTION);\nvar DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(global, DOM_EXCEPTION);\n\n// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it\n// https://github.com/Jarred-Sumner/bun/issues/399\nvar BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable);\n\nvar FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;\n\n// `DOMException` constructor patch for `.stack` where it's required\n// https://webidl.spec.whatwg.org/#es-DOMException-specialness\n$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic\n  DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException\n});\n\nvar PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);\nvar PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;\n\nif (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {\n  if (!IS_PURE) {\n    defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));\n  }\n\n  for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {\n    var constant = DOMExceptionConstants[key];\n    var constantName = constant.s;\n    if (!hasOwn(PolyfilledDOMException, constantName)) {\n      defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));\n    }\n  }\n}\n","var getBuiltIn = require('../internals/get-built-in');\nvar setToStringTag = require('../internals/set-to-string-tag');\n\nvar DOM_EXCEPTION = 'DOMException';\n\n// `DOMException.prototype[@@toStringTag]` property\nsetToStringTag(getBuiltIn(DOM_EXCEPTION), DOM_EXCEPTION);\n","// Imports\nimport ___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___ from \"../../css-loader/dist/runtime/noSourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, \".acediff__wrap{display:flex;flex-direction:row;position:absolute;bottom:0;top:0;left:0;height:100%;width:100%;overflow:auto}.acediff__gutter{flex:0 0 60px;border-left:1px solid #000;border-right:1px solid #000;overflow:hidden}.acediff__gutter,.acediff__gutter svg{background-color:#272727}.acediff__left,.acediff__right{height:100%;flex:1}.acediff__diffLine{background-color:#004d7a;border-top:1px solid #003554;border-bottom:1px solid #003554;position:absolute;z-index:4}.acediff__diffLine.targetOnly{height:0!important;border-top:1px solid #003554;border-bottom:0;position:absolute}.acediff__connector{fill:#004d7a;stroke:#003554}.acediff__copy--left,.acediff__copy--right{position:relative}.acediff__copy--left div,.acediff__copy--right div{color:#fff;text-shadow:1px 1px rgba(0,0,0,.7);position:absolute;margin:2px 3px;cursor:pointer}.acediff__copy--right div:hover{color:#61a2e7}.acediff__copy--left{float:right}.acediff__copy--left div{right:0}.acediff__copy--left div:hover{color:#f7b742}\", \"\"]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// Imports\nimport ___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___ from \"../../css-loader/dist/runtime/noSourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, \".acediff__wrap{display:flex;flex-direction:row;position:absolute;bottom:0;top:0;left:0;height:100%;width:100%;overflow:auto}.acediff__gutter{flex:0 0 60px;border-left:1px solid #bcbcbc;border-right:1px solid #bcbcbc;overflow:hidden}.acediff__gutter,.acediff__gutter svg{background-color:#efefef}.acediff__left,.acediff__right{height:100%;flex:1}.acediff__diffLine{background-color:#d8f2ff;border-top:1px solid #a2d7f2;border-bottom:1px solid #a2d7f2;position:absolute;z-index:4}.acediff__diffLine.targetOnly{height:0!important;border-top:1px solid #a2d7f2;border-bottom:0;position:absolute}.acediff__connector{fill:#d8f2ff;stroke:#a2d7f2}.acediff__copy--left,.acediff__copy--right{position:relative}.acediff__copy--left div,.acediff__copy--right div{color:#000;text-shadow:1px 1px hsla(0,0%,100%,.7);position:absolute;margin:2px 3px;cursor:pointer}.acediff__copy--right div:hover{color:#004ea0}.acediff__copy--left{float:right}.acediff__copy--left div{right:0}.acediff__copy--left div:hover{color:#c98100}\", \"\"]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","/**\n * Diff Match and Patch\n * Copyright 2018 The diff-match-patch Authors.\n * https://github.com/google/diff-match-patch\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Computes the difference between two texts to create a patch.\n * Applies the patch onto another text, allowing for errors.\n * @author fraser@google.com (Neil Fraser)\n */\n\n/**\n * Class containing the diff, match and patch methods.\n * @constructor\n */\nvar diff_match_patch = function() {\n\n  // Defaults.\n  // Redefine these in your program to override the defaults.\n\n  // Number of seconds to map a diff before giving up (0 for infinity).\n  this.Diff_Timeout = 1.0;\n  // Cost of an empty edit operation in terms of edit characters.\n  this.Diff_EditCost = 4;\n  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).\n  this.Match_Threshold = 0.5;\n  // How far to search for a match (0 = exact location, 1000+ = broad match).\n  // A match this many characters away from the expected location will add\n  // 1.0 to the score (0.0 is a perfect match).\n  this.Match_Distance = 1000;\n  // When deleting a large block of text (over ~64 characters), how close do\n  // the contents have to be to match the expected contents. (0.0 = perfection,\n  // 1.0 = very loose).  Note that Match_Threshold controls how closely the\n  // end points of a delete need to match.\n  this.Patch_DeleteThreshold = 0.5;\n  // Chunk size for context length.\n  this.Patch_Margin = 4;\n\n  // The number of bits in an int.\n  this.Match_MaxBits = 32;\n};\n\n\n//  DIFF FUNCTIONS\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n/**\n * Class representing one diff tuple.\n * ~Attempts to look like a two-element array (which is what this used to be).~\n * Constructor returns an actual two-element array, to allow destructing @JackuB\n * See https://github.com/JackuB/diff-match-patch/issues/14 for details\n * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.\n * @param {string} text Text to be deleted, inserted, or retained.\n * @constructor\n */\ndiff_match_patch.Diff = function(op, text) {\n  return [op, text];\n};\n\n/**\n * Find the differences between two texts.  Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean=} opt_checklines Optional speedup flag. If present and false,\n *     then don't run a line-level diff first to identify the changed areas.\n *     Defaults to true, which does a faster, slightly less optimal diff.\n * @param {number=} opt_deadline Optional time when the diff should be complete\n *     by.  Used internally for recursive calls.  Users should set DiffTimeout\n *     instead.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,\n    opt_deadline) {\n  // Set a deadline by which time the diff must be complete.\n  if (typeof opt_deadline == 'undefined') {\n    if (this.Diff_Timeout <= 0) {\n      opt_deadline = Number.MAX_VALUE;\n    } else {\n      opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;\n    }\n  }\n  var deadline = opt_deadline;\n\n  // Check for null inputs.\n  if (text1 == null || text2 == null) {\n    throw new Error('Null input. (diff_main)');\n  }\n\n  // Check for equality (speedup).\n  if (text1 == text2) {\n    if (text1) {\n      return [new diff_match_patch.Diff(DIFF_EQUAL, text1)];\n    }\n    return [];\n  }\n\n  if (typeof opt_checklines == 'undefined') {\n    opt_checklines = true;\n  }\n  var checklines = opt_checklines;\n\n  // Trim off common prefix (speedup).\n  var commonlength = this.diff_commonPrefix(text1, text2);\n  var commonprefix = text1.substring(0, commonlength);\n  text1 = text1.substring(commonlength);\n  text2 = text2.substring(commonlength);\n\n  // Trim off common suffix (speedup).\n  commonlength = this.diff_commonSuffix(text1, text2);\n  var commonsuffix = text1.substring(text1.length - commonlength);\n  text1 = text1.substring(0, text1.length - commonlength);\n  text2 = text2.substring(0, text2.length - commonlength);\n\n  // Compute the diff on the middle block.\n  var diffs = this.diff_compute_(text1, text2, checklines, deadline);\n\n  // Restore the prefix and suffix.\n  if (commonprefix) {\n    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix));\n  }\n  if (commonsuffix) {\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix));\n  }\n  this.diff_cleanupMerge(diffs);\n  return diffs;\n};\n\n\n/**\n * Find the differences between two texts.  Assumes that the texts do not\n * have any common prefix or suffix.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean} checklines Speedup flag.  If false, then don't run a\n *     line-level diff first to identify the changed areas.\n *     If true, then run a faster, slightly less optimal diff.\n * @param {number} deadline Time when the diff should be complete by.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,\n    deadline) {\n  var diffs;\n\n  if (!text1) {\n    // Just add some text (speedup).\n    return [new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [new diff_match_patch.Diff(DIFF_DELETE, text1)];\n  }\n\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  var i = longtext.indexOf(shorttext);\n  if (i != -1) {\n    // Shorter text is inside the longer text (speedup).\n    diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)),\n             new diff_match_patch.Diff(DIFF_EQUAL, shorttext),\n             new diff_match_patch.Diff(DIFF_INSERT,\n                 longtext.substring(i + shorttext.length))];\n    // Swap insertions for deletions if diff is reversed.\n    if (text1.length > text2.length) {\n      diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n    }\n    return diffs;\n  }\n\n  if (shorttext.length == 1) {\n    // Single character string.\n    // After the previous speedup, the character can't be an equality.\n    return [new diff_match_patch.Diff(DIFF_DELETE, text1),\n            new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\n\n  // Check to see if the problem can be split in two.\n  var hm = this.diff_halfMatch_(text1, text2);\n  if (hm) {\n    // A half-match was found, sort out the return data.\n    var text1_a = hm[0];\n    var text1_b = hm[1];\n    var text2_a = hm[2];\n    var text2_b = hm[3];\n    var mid_common = hm[4];\n    // Send both pairs off for separate processing.\n    var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);\n    var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);\n    // Merge the results.\n    return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)],\n                          diffs_b);\n  }\n\n  if (checklines && text1.length > 100 && text2.length > 100) {\n    return this.diff_lineMode_(text1, text2, deadline);\n  }\n\n  return this.diff_bisect_(text1, text2, deadline);\n};\n\n\n/**\n * Do a quick line-level diff on both strings, then rediff the parts for\n * greater accuracy.\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time when the diff should be complete by.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {\n  // Scan the text on a line-by-line basis first.\n  var a = this.diff_linesToChars_(text1, text2);\n  text1 = a.chars1;\n  text2 = a.chars2;\n  var linearray = a.lineArray;\n\n  var diffs = this.diff_main(text1, text2, false, deadline);\n\n  // Convert the diff back to original text.\n  this.diff_charsToLines_(diffs, linearray);\n  // Eliminate freak matches (e.g. blank lines)\n  this.diff_cleanupSemantic(diffs);\n\n  // Rediff any replacement blocks, this time character-by-character.\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  while (pointer < diffs.length) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        break;\n      case DIFF_EQUAL:\n        // Upon reaching an equality, check for prior redundancies.\n        if (count_delete >= 1 && count_insert >= 1) {\n          // Delete the offending records and add the merged ones.\n          diffs.splice(pointer - count_delete - count_insert,\n                       count_delete + count_insert);\n          pointer = pointer - count_delete - count_insert;\n          var subDiff =\n              this.diff_main(text_delete, text_insert, false, deadline);\n          for (var j = subDiff.length - 1; j >= 0; j--) {\n            diffs.splice(pointer, 0, subDiff[j]);\n          }\n          pointer = pointer + subDiff.length;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n    pointer++;\n  }\n  diffs.pop();  // Remove the dummy entry at the end.\n\n  return diffs;\n};\n\n\n/**\n * Find the 'middle snake' of a diff, split the problem in two\n * and return the recursively constructed diff.\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  var max_d = Math.ceil((text1_length + text2_length) / 2);\n  var v_offset = max_d;\n  var v_length = 2 * max_d;\n  var v1 = new Array(v_length);\n  var v2 = new Array(v_length);\n  // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n  // integers and undefined.\n  for (var x = 0; x < v_length; x++) {\n    v1[x] = -1;\n    v2[x] = -1;\n  }\n  v1[v_offset + 1] = 0;\n  v2[v_offset + 1] = 0;\n  var delta = text1_length - text2_length;\n  // If the total number of characters is odd, then the front path will collide\n  // with the reverse path.\n  var front = (delta % 2 != 0);\n  // Offsets for start and end of k loop.\n  // Prevents mapping of space beyond the grid.\n  var k1start = 0;\n  var k1end = 0;\n  var k2start = 0;\n  var k2end = 0;\n  for (var d = 0; d < max_d; d++) {\n    // Bail out if deadline is reached.\n    if ((new Date()).getTime() > deadline) {\n      break;\n    }\n\n    // Walk the front path one step.\n    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n      var k1_offset = v_offset + k1;\n      var x1;\n      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\n        x1 = v1[k1_offset + 1];\n      } else {\n        x1 = v1[k1_offset - 1] + 1;\n      }\n      var y1 = x1 - k1;\n      while (x1 < text1_length && y1 < text2_length &&\n             text1.charAt(x1) == text2.charAt(y1)) {\n        x1++;\n        y1++;\n      }\n      v1[k1_offset] = x1;\n      if (x1 > text1_length) {\n        // Ran off the right of the graph.\n        k1end += 2;\n      } else if (y1 > text2_length) {\n        // Ran off the bottom of the graph.\n        k1start += 2;\n      } else if (front) {\n        var k2_offset = v_offset + delta - k1;\n        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {\n          // Mirror x2 onto top-left coordinate system.\n          var x2 = text1_length - v2[k2_offset];\n          if (x1 >= x2) {\n            // Overlap detected.\n            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\n          }\n        }\n      }\n    }\n\n    // Walk the reverse path one step.\n    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n      var k2_offset = v_offset + k2;\n      var x2;\n      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\n        x2 = v2[k2_offset + 1];\n      } else {\n        x2 = v2[k2_offset - 1] + 1;\n      }\n      var y2 = x2 - k2;\n      while (x2 < text1_length && y2 < text2_length &&\n             text1.charAt(text1_length - x2 - 1) ==\n             text2.charAt(text2_length - y2 - 1)) {\n        x2++;\n        y2++;\n      }\n      v2[k2_offset] = x2;\n      if (x2 > text1_length) {\n        // Ran off the left of the graph.\n        k2end += 2;\n      } else if (y2 > text2_length) {\n        // Ran off the top of the graph.\n        k2start += 2;\n      } else if (!front) {\n        var k1_offset = v_offset + delta - k2;\n        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {\n          var x1 = v1[k1_offset];\n          var y1 = v_offset + x1 - k1_offset;\n          // Mirror x2 onto top-left coordinate system.\n          x2 = text1_length - x2;\n          if (x1 >= x2) {\n            // Overlap detected.\n            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\n          }\n        }\n      }\n    }\n  }\n  // Diff took too long and hit the deadline or\n  // number of diffs equals number of characters, no commonality at all.\n  return [new diff_match_patch.Diff(DIFF_DELETE, text1),\n          new diff_match_patch.Diff(DIFF_INSERT, text2)];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,\n    deadline) {\n  var text1a = text1.substring(0, x);\n  var text2a = text2.substring(0, y);\n  var text1b = text1.substring(x);\n  var text2b = text2.substring(y);\n\n  // Compute both diffs serially.\n  var diffs = this.diff_main(text1a, text2a, false, deadline);\n  var diffsb = this.diff_main(text1b, text2b, false, deadline);\n\n  return diffs.concat(diffsb);\n};\n\n\n/**\n * Split two texts into an array of strings.  Reduce the texts to a string of\n * hashes where each Unicode character represents one line.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}\n *     An object containing the encoded text1, the encoded text2 and\n *     the array of unique strings.\n *     The zeroth element of the array of unique strings is intentionally blank.\n * @private\n */\ndiff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {\n  var lineArray = [];  // e.g. lineArray[4] == 'Hello\\n'\n  var lineHash = {};   // e.g. lineHash['Hello\\n'] == 4\n\n  // '\\x00' is a valid character, but various debuggers don't like it.\n  // So we'll insert a junk entry to avoid generating a null character.\n  lineArray[0] = '';\n\n  /**\n   * Split a text into an array of strings.  Reduce the texts to a string of\n   * hashes where each Unicode character represents one line.\n   * Modifies linearray and linehash through being a closure.\n   * @param {string} text String to encode.\n   * @return {string} Encoded string.\n   * @private\n   */\n  function diff_linesToCharsMunge_(text) {\n    var chars = '';\n    // Walk the text, pulling out a substring for each line.\n    // text.split('\\n') would would temporarily double our memory footprint.\n    // Modifying text would create many large strings to garbage collect.\n    var lineStart = 0;\n    var lineEnd = -1;\n    // Keeping our own length variable is faster than looking it up.\n    var lineArrayLength = lineArray.length;\n    while (lineEnd < text.length - 1) {\n      lineEnd = text.indexOf('\\n', lineStart);\n      if (lineEnd == -1) {\n        lineEnd = text.length - 1;\n      }\n      var line = text.substring(lineStart, lineEnd + 1);\n\n      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :\n          (lineHash[line] !== undefined)) {\n        chars += String.fromCharCode(lineHash[line]);\n      } else {\n        if (lineArrayLength == maxLines) {\n          // Bail out at 65535 because\n          // String.fromCharCode(65536) == String.fromCharCode(0)\n          line = text.substring(lineStart);\n          lineEnd = text.length;\n        }\n        chars += String.fromCharCode(lineArrayLength);\n        lineHash[line] = lineArrayLength;\n        lineArray[lineArrayLength++] = line;\n      }\n      lineStart = lineEnd + 1;\n    }\n    return chars;\n  }\n  // Allocate 2/3rds of the space for text1, the rest for text2.\n  var maxLines = 40000;\n  var chars1 = diff_linesToCharsMunge_(text1);\n  maxLines = 65535;\n  var chars2 = diff_linesToCharsMunge_(text2);\n  return {chars1: chars1, chars2: chars2, lineArray: lineArray};\n};\n\n\n/**\n * Rehydrate the text in a diff from a string of line hashes to real lines of\n * text.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @param {!Array.<string>} lineArray Array of unique strings.\n * @private\n */\ndiff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {\n  for (var i = 0; i < diffs.length; i++) {\n    var chars = diffs[i][1];\n    var text = [];\n    for (var j = 0; j < chars.length; j++) {\n      text[j] = lineArray[chars.charCodeAt(j)];\n    }\n    diffs[i][1] = text.join('');\n  }\n};\n\n\n/**\n * Determine the common prefix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n *     string.\n */\ndiff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: https://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerstart = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(pointerstart, pointermid) ==\n        text2.substring(pointerstart, pointermid)) {\n      pointermin = pointermid;\n      pointerstart = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Determine the common suffix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\ndiff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 ||\n      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: https://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerend = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n        text2.substring(text2.length - pointermid, text2.length - pointerend)) {\n      pointermin = pointermid;\n      pointerend = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Determine if the suffix of one string is the prefix of another.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of the first\n *     string and the start of the second string.\n * @private\n */\ndiff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  // Eliminate the null case.\n  if (text1_length == 0 || text2_length == 0) {\n    return 0;\n  }\n  // Truncate the longer string.\n  if (text1_length > text2_length) {\n    text1 = text1.substring(text1_length - text2_length);\n  } else if (text1_length < text2_length) {\n    text2 = text2.substring(0, text1_length);\n  }\n  var text_length = Math.min(text1_length, text2_length);\n  // Quick check for the worst case.\n  if (text1 == text2) {\n    return text_length;\n  }\n\n  // Start by looking for a single character match\n  // and increase length until no match is found.\n  // Performance analysis: https://neil.fraser.name/news/2010/11/04/\n  var best = 0;\n  var length = 1;\n  while (true) {\n    var pattern = text1.substring(text_length - length);\n    var found = text2.indexOf(pattern);\n    if (found == -1) {\n      return best;\n    }\n    length += found;\n    if (found == 0 || text1.substring(text_length - length) ==\n        text2.substring(0, length)) {\n      best = length;\n      length++;\n    }\n  }\n};\n\n\n/**\n * Do the two texts share a substring which is at least half the length of the\n * longer text?\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.<string>} Five element Array, containing the prefix of\n *     text1, the suffix of text1, the prefix of text2, the suffix of\n *     text2 and the common middle.  Or null if there was no match.\n * @private\n */\ndiff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {\n  if (this.Diff_Timeout <= 0) {\n    // Don't risk returning a non-optimal diff if we have unlimited time.\n    return null;\n  }\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n    return null;  // Pointless.\n  }\n  var dmp = this;  // 'this' becomes 'window' in a closure.\n\n  /**\n   * Does a substring of shorttext exist within longtext such that the substring\n   * is at least half the length of longtext?\n   * Closure, but does not reference any external variables.\n   * @param {string} longtext Longer string.\n   * @param {string} shorttext Shorter string.\n   * @param {number} i Start index of quarter length substring within longtext.\n   * @return {Array.<string>} Five element Array, containing the prefix of\n   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\n   *     of shorttext and the common middle.  Or null if there was no match.\n   * @private\n   */\n  function diff_halfMatchI_(longtext, shorttext, i) {\n    // Start with a 1/4 length substring at position i as a seed.\n    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n    var j = -1;\n    var best_common = '';\n    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\n      var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),\n                                               shorttext.substring(j));\n      var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),\n                                               shorttext.substring(0, j));\n      if (best_common.length < suffixLength + prefixLength) {\n        best_common = shorttext.substring(j - suffixLength, j) +\n            shorttext.substring(j, j + prefixLength);\n        best_longtext_a = longtext.substring(0, i - suffixLength);\n        best_longtext_b = longtext.substring(i + prefixLength);\n        best_shorttext_a = shorttext.substring(0, j - suffixLength);\n        best_shorttext_b = shorttext.substring(j + prefixLength);\n      }\n    }\n    if (best_common.length * 2 >= longtext.length) {\n      return [best_longtext_a, best_longtext_b,\n              best_shorttext_a, best_shorttext_b, best_common];\n    } else {\n      return null;\n    }\n  }\n\n  // First check if the second quarter is the seed for a half-match.\n  var hm1 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 4));\n  // Check again based on the third quarter.\n  var hm2 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 2));\n  var hm;\n  if (!hm1 && !hm2) {\n    return null;\n  } else if (!hm2) {\n    hm = hm1;\n  } else if (!hm1) {\n    hm = hm2;\n  } else {\n    // Both matched.  Select the longest.\n    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n  }\n\n  // A half-match was found, sort out the return data.\n  var text1_a, text1_b, text2_a, text2_b;\n  if (text1.length > text2.length) {\n    text1_a = hm[0];\n    text1_b = hm[1];\n    text2_a = hm[2];\n    text2_b = hm[3];\n  } else {\n    text2_a = hm[0];\n    text2_b = hm[1];\n    text1_a = hm[2];\n    text1_b = hm[3];\n  }\n  var mid_common = hm[4];\n  return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {\n  var changes = false;\n  var equalities = [];  // Stack of indices where equalities are found.\n  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\n  /** @type {?string} */\n  var lastEquality = null;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0;  // Index of current position.\n  // Number of characters that changed prior to the equality.\n  var length_insertions1 = 0;\n  var length_deletions1 = 0;\n  // Number of characters that changed after the equality.\n  var length_insertions2 = 0;\n  var length_deletions2 = 0;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\n      equalities[equalitiesLength++] = pointer;\n      length_insertions1 = length_insertions2;\n      length_deletions1 = length_deletions2;\n      length_insertions2 = 0;\n      length_deletions2 = 0;\n      lastEquality = diffs[pointer][1];\n    } else {  // An insertion or deletion.\n      if (diffs[pointer][0] == DIFF_INSERT) {\n        length_insertions2 += diffs[pointer][1].length;\n      } else {\n        length_deletions2 += diffs[pointer][1].length;\n      }\n      // Eliminate an equality that is smaller or equal to the edits on both\n      // sides of it.\n      if (lastEquality && (lastEquality.length <=\n          Math.max(length_insertions1, length_deletions1)) &&\n          (lastEquality.length <= Math.max(length_insertions2,\n                                           length_deletions2))) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0,\n                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\n        // Change second copy to insert.\n        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n        // Throw away the equality we just deleted.\n        equalitiesLength--;\n        // Throw away the previous equality (it needs to be reevaluated).\n        equalitiesLength--;\n        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n        length_insertions1 = 0;  // Reset the counters.\n        length_deletions1 = 0;\n        length_insertions2 = 0;\n        length_deletions2 = 0;\n        lastEquality = null;\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  // Normalize the diff.\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n  this.diff_cleanupSemanticLossless(diffs);\n\n  // Find any overlaps between deletions and insertions.\n  // e.g: <del>abcxxx</del><ins>xxxdef</ins>\n  //   -> <del>abc</del>xxx<ins>def</ins>\n  // e.g: <del>xxxabc</del><ins>defxxx</ins>\n  //   -> <ins>def</ins>xxx<del>abc</del>\n  // Only extract an overlap if it is as big as the edit ahead or behind it.\n  pointer = 1;\n  while (pointer < diffs.length) {\n    if (diffs[pointer - 1][0] == DIFF_DELETE &&\n        diffs[pointer][0] == DIFF_INSERT) {\n      var deletion = diffs[pointer - 1][1];\n      var insertion = diffs[pointer][1];\n      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);\n      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);\n      if (overlap_length1 >= overlap_length2) {\n        if (overlap_length1 >= deletion.length / 2 ||\n            overlap_length1 >= insertion.length / 2) {\n          // Overlap found.  Insert an equality and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              insertion.substring(0, overlap_length1)));\n          diffs[pointer - 1][1] =\n              deletion.substring(0, deletion.length - overlap_length1);\n          diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n          pointer++;\n        }\n      } else {\n        if (overlap_length2 >= deletion.length / 2 ||\n            overlap_length2 >= insertion.length / 2) {\n          // Reverse overlap found.\n          // Insert an equality and swap and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              deletion.substring(0, overlap_length2)));\n          diffs[pointer - 1][0] = DIFF_INSERT;\n          diffs[pointer - 1][1] =\n              insertion.substring(0, insertion.length - overlap_length2);\n          diffs[pointer + 1][0] = DIFF_DELETE;\n          diffs[pointer + 1][1] =\n              deletion.substring(overlap_length2);\n          pointer++;\n        }\n      }\n      pointer++;\n    }\n    pointer++;\n  }\n};\n\n\n/**\n * Look for single edits surrounded on both sides by equalities\n * which can be shifted sideways to align the edit to a word boundary.\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {\n  /**\n   * Given two strings, compute a score representing whether the internal\n   * boundary falls on logical boundaries.\n   * Scores range from 6 (best) to 0 (worst).\n   * Closure, but does not reference any external variables.\n   * @param {string} one First string.\n   * @param {string} two Second string.\n   * @return {number} The score.\n   * @private\n   */\n  function diff_cleanupSemanticScore_(one, two) {\n    if (!one || !two) {\n      // Edges are the best.\n      return 6;\n    }\n\n    // Each port of this function behaves slightly differently due to\n    // subtle differences in each language's definition of things like\n    // 'whitespace'.  Since this function's purpose is largely cosmetic,\n    // the choice has been made to use each language's native features\n    // rather than force total conformity.\n    var char1 = one.charAt(one.length - 1);\n    var char2 = two.charAt(0);\n    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);\n    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);\n    var whitespace1 = nonAlphaNumeric1 &&\n        char1.match(diff_match_patch.whitespaceRegex_);\n    var whitespace2 = nonAlphaNumeric2 &&\n        char2.match(diff_match_patch.whitespaceRegex_);\n    var lineBreak1 = whitespace1 &&\n        char1.match(diff_match_patch.linebreakRegex_);\n    var lineBreak2 = whitespace2 &&\n        char2.match(diff_match_patch.linebreakRegex_);\n    var blankLine1 = lineBreak1 &&\n        one.match(diff_match_patch.blanklineEndRegex_);\n    var blankLine2 = lineBreak2 &&\n        two.match(diff_match_patch.blanklineStartRegex_);\n\n    if (blankLine1 || blankLine2) {\n      // Five points for blank lines.\n      return 5;\n    } else if (lineBreak1 || lineBreak2) {\n      // Four points for line breaks.\n      return 4;\n    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n      // Three points for end of sentences.\n      return 3;\n    } else if (whitespace1 || whitespace2) {\n      // Two points for whitespace.\n      return 2;\n    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n      // One point for non-alphanumeric.\n      return 1;\n    }\n    return 0;\n  }\n\n  var pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      var equality1 = diffs[pointer - 1][1];\n      var edit = diffs[pointer][1];\n      var equality2 = diffs[pointer + 1][1];\n\n      // First, shift the edit as far left as possible.\n      var commonOffset = this.diff_commonSuffix(equality1, edit);\n      if (commonOffset) {\n        var commonString = edit.substring(edit.length - commonOffset);\n        equality1 = equality1.substring(0, equality1.length - commonOffset);\n        edit = commonString + edit.substring(0, edit.length - commonOffset);\n        equality2 = commonString + equality2;\n      }\n\n      // Second, step character by character right, looking for the best fit.\n      var bestEquality1 = equality1;\n      var bestEdit = edit;\n      var bestEquality2 = equality2;\n      var bestScore = diff_cleanupSemanticScore_(equality1, edit) +\n          diff_cleanupSemanticScore_(edit, equality2);\n      while (edit.charAt(0) === equality2.charAt(0)) {\n        equality1 += edit.charAt(0);\n        edit = edit.substring(1) + equality2.charAt(0);\n        equality2 = equality2.substring(1);\n        var score = diff_cleanupSemanticScore_(equality1, edit) +\n            diff_cleanupSemanticScore_(edit, equality2);\n        // The >= encourages trailing rather than leading whitespace on edits.\n        if (score >= bestScore) {\n          bestScore = score;\n          bestEquality1 = equality1;\n          bestEdit = edit;\n          bestEquality2 = equality2;\n        }\n      }\n\n      if (diffs[pointer - 1][1] != bestEquality1) {\n        // We have an improvement, save it back to the diff.\n        if (bestEquality1) {\n          diffs[pointer - 1][1] = bestEquality1;\n        } else {\n          diffs.splice(pointer - 1, 1);\n          pointer--;\n        }\n        diffs[pointer][1] = bestEdit;\n        if (bestEquality2) {\n          diffs[pointer + 1][1] = bestEquality2;\n        } else {\n          diffs.splice(pointer + 1, 1);\n          pointer--;\n        }\n      }\n    }\n    pointer++;\n  }\n};\n\n// Define some regex patterns for matching boundaries.\ndiff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\ndiff_match_patch.whitespaceRegex_ = /\\s/;\ndiff_match_patch.linebreakRegex_ = /[\\r\\n]/;\ndiff_match_patch.blanklineEndRegex_ = /\\n\\r?\\n$/;\ndiff_match_patch.blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n\n/**\n * Reduce the number of edits by eliminating operationally trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {\n  var changes = false;\n  var equalities = [];  // Stack of indices where equalities are found.\n  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\n  /** @type {?string} */\n  var lastEquality = null;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0;  // Index of current position.\n  // Is there an insertion operation before the last equality.\n  var pre_ins = false;\n  // Is there a deletion operation before the last equality.\n  var pre_del = false;\n  // Is there an insertion operation after the last equality.\n  var post_ins = false;\n  // Is there a deletion operation after the last equality.\n  var post_del = false;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\n      if (diffs[pointer][1].length < this.Diff_EditCost &&\n          (post_ins || post_del)) {\n        // Candidate found.\n        equalities[equalitiesLength++] = pointer;\n        pre_ins = post_ins;\n        pre_del = post_del;\n        lastEquality = diffs[pointer][1];\n      } else {\n        // Not a candidate, and can never become one.\n        equalitiesLength = 0;\n        lastEquality = null;\n      }\n      post_ins = post_del = false;\n    } else {  // An insertion or deletion.\n      if (diffs[pointer][0] == DIFF_DELETE) {\n        post_del = true;\n      } else {\n        post_ins = true;\n      }\n      /*\n       * Five types to be split:\n       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>\n       * <ins>A</ins>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<ins>C</ins>\n       * <ins>A</del>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<del>C</del>\n       */\n      if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) ||\n                           ((lastEquality.length < this.Diff_EditCost / 2) &&\n                            (pre_ins + pre_del + post_ins + post_del) == 3))) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0,\n                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\n        // Change second copy to insert.\n        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n        equalitiesLength--;  // Throw away the equality we just deleted;\n        lastEquality = null;\n        if (pre_ins && pre_del) {\n          // No changes made which could affect previous entry, keep going.\n          post_ins = post_del = true;\n          equalitiesLength = 0;\n        } else {\n          equalitiesLength--;  // Throw away the previous equality.\n          pointer = equalitiesLength > 0 ?\n              equalities[equalitiesLength - 1] : -1;\n          post_ins = post_del = false;\n        }\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n};\n\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupMerge = function(diffs) {\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  var commonlength;\n  while (pointer < diffs.length) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_EQUAL:\n        // Upon reaching an equality, check for prior redundancies.\n        if (count_delete + count_insert > 1) {\n          if (count_delete !== 0 && count_insert !== 0) {\n            // Factor out any common prefixies.\n            commonlength = this.diff_commonPrefix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              if ((pointer - count_delete - count_insert) > 0 &&\n                  diffs[pointer - count_delete - count_insert - 1][0] ==\n                  DIFF_EQUAL) {\n                diffs[pointer - count_delete - count_insert - 1][1] +=\n                    text_insert.substring(0, commonlength);\n              } else {\n                diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n                    text_insert.substring(0, commonlength)));\n                pointer++;\n              }\n              text_insert = text_insert.substring(commonlength);\n              text_delete = text_delete.substring(commonlength);\n            }\n            // Factor out any common suffixies.\n            commonlength = this.diff_commonSuffix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              diffs[pointer][1] = text_insert.substring(text_insert.length -\n                  commonlength) + diffs[pointer][1];\n              text_insert = text_insert.substring(0, text_insert.length -\n                  commonlength);\n              text_delete = text_delete.substring(0, text_delete.length -\n                  commonlength);\n            }\n          }\n          // Delete the offending records and add the merged ones.\n          pointer -= count_delete + count_insert;\n          diffs.splice(pointer, count_delete + count_insert);\n          if (text_delete.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_DELETE, text_delete));\n            pointer++;\n          }\n          if (text_insert.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_INSERT, text_insert));\n            pointer++;\n          }\n          pointer++;\n        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {\n          // Merge this equality with the previous one.\n          diffs[pointer - 1][1] += diffs[pointer][1];\n          diffs.splice(pointer, 1);\n        } else {\n          pointer++;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n  }\n  if (diffs[diffs.length - 1][1] === '') {\n    diffs.pop();  // Remove the dummy entry at the end.\n  }\n\n  // Second pass: look for single edits surrounded on both sides by equalities\n  // which can be shifted sideways to eliminate an equality.\n  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      if (diffs[pointer][1].substring(diffs[pointer][1].length -\n          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] = diffs[pointer - 1][1] +\n            diffs[pointer][1].substring(0, diffs[pointer][1].length -\n                                        diffs[pointer - 1][1].length);\n        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n        diffs.splice(pointer - 1, 1);\n        changes = true;\n      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n          diffs[pointer + 1][1]) {\n        // Shift the edit over the next equality.\n        diffs[pointer - 1][1] += diffs[pointer + 1][1];\n        diffs[pointer][1] =\n            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n            diffs[pointer + 1][1];\n        diffs.splice(pointer + 1, 1);\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n  // If shifts were made, the diff needs reordering and another shift sweep.\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n};\n\n\n/**\n * loc is a location in text1, compute and return the equivalent location in\n * text2.\n * e.g. 'The cat' vs 'The big cat', 1->1, 5->8\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @param {number} loc Location within text1.\n * @return {number} Location within text2.\n */\ndiff_match_patch.prototype.diff_xIndex = function(diffs, loc) {\n  var chars1 = 0;\n  var chars2 = 0;\n  var last_chars1 = 0;\n  var last_chars2 = 0;\n  var x;\n  for (x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.\n      chars1 += diffs[x][1].length;\n    }\n    if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.\n      chars2 += diffs[x][1].length;\n    }\n    if (chars1 > loc) {  // Overshot the location.\n      break;\n    }\n    last_chars1 = chars1;\n    last_chars2 = chars2;\n  }\n  // Was the location was deleted?\n  if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {\n    return last_chars2;\n  }\n  // Add the remaining character length.\n  return last_chars2 + (loc - last_chars1);\n};\n\n\n/**\n * Convert a diff array into a pretty HTML report.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} HTML representation.\n */\ndiff_match_patch.prototype.diff_prettyHtml = function(diffs) {\n  var html = [];\n  var pattern_amp = /&/g;\n  var pattern_lt = /</g;\n  var pattern_gt = />/g;\n  var pattern_para = /\\n/g;\n  for (var x = 0; x < diffs.length; x++) {\n    var op = diffs[x][0];    // Operation (insert, delete, equal)\n    var data = diffs[x][1];  // Text of change.\n    var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')\n        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');\n    switch (op) {\n      case DIFF_INSERT:\n        html[x] = '<ins style=\"background:#e6ffe6;\">' + text + '</ins>';\n        break;\n      case DIFF_DELETE:\n        html[x] = '<del style=\"background:#ffe6e6;\">' + text + '</del>';\n        break;\n      case DIFF_EQUAL:\n        html[x] = '<span>' + text + '</span>';\n        break;\n    }\n  }\n  return html.join('');\n};\n\n\n/**\n * Compute and return the source text (all equalities and deletions).\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Source text.\n */\ndiff_match_patch.prototype.diff_text1 = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_INSERT) {\n      text[x] = diffs[x][1];\n    }\n  }\n  return text.join('');\n};\n\n\n/**\n * Compute and return the destination text (all equalities and insertions).\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Destination text.\n */\ndiff_match_patch.prototype.diff_text2 = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_DELETE) {\n      text[x] = diffs[x][1];\n    }\n  }\n  return text.join('');\n};\n\n\n/**\n * Compute the Levenshtein distance; the number of inserted, deleted or\n * substituted characters.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {number} Number of changes.\n */\ndiff_match_patch.prototype.diff_levenshtein = function(diffs) {\n  var levenshtein = 0;\n  var insertions = 0;\n  var deletions = 0;\n  for (var x = 0; x < diffs.length; x++) {\n    var op = diffs[x][0];\n    var data = diffs[x][1];\n    switch (op) {\n      case DIFF_INSERT:\n        insertions += data.length;\n        break;\n      case DIFF_DELETE:\n        deletions += data.length;\n        break;\n      case DIFF_EQUAL:\n        // A deletion and an insertion is one substitution.\n        levenshtein += Math.max(insertions, deletions);\n        insertions = 0;\n        deletions = 0;\n        break;\n    }\n  }\n  levenshtein += Math.max(insertions, deletions);\n  return levenshtein;\n};\n\n\n/**\n * Crush the diff into an encoded string which describes the operations\n * required to transform text1 into text2.\n * E.g. =3\\t-2\\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.\n * Operations are tab-separated.  Inserted text is escaped using %xx notation.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Delta text.\n */\ndiff_match_patch.prototype.diff_toDelta = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    switch (diffs[x][0]) {\n      case DIFF_INSERT:\n        text[x] = '+' + encodeURI(diffs[x][1]);\n        break;\n      case DIFF_DELETE:\n        text[x] = '-' + diffs[x][1].length;\n        break;\n      case DIFF_EQUAL:\n        text[x] = '=' + diffs[x][1].length;\n        break;\n    }\n  }\n  return text.join('\\t').replace(/%20/g, ' ');\n};\n\n\n/**\n * Given the original text1, and an encoded string which describes the\n * operations required to transform text1 into text2, compute the full diff.\n * @param {string} text1 Source string for the diff.\n * @param {string} delta Delta text.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.diff_fromDelta = function(text1, delta) {\n  var diffs = [];\n  var diffsLength = 0;  // Keeping our own length var is faster in JS.\n  var pointer = 0;  // Cursor in text1\n  var tokens = delta.split(/\\t/g);\n  for (var x = 0; x < tokens.length; x++) {\n    // Each token begins with a one character parameter which specifies the\n    // operation of this token (delete, insert, equality).\n    var param = tokens[x].substring(1);\n    switch (tokens[x].charAt(0)) {\n      case '+':\n        try {\n          diffs[diffsLength++] =\n              new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param));\n        } catch (ex) {\n          // Malformed URI sequence.\n          throw new Error('Illegal escape in diff_fromDelta: ' + param);\n        }\n        break;\n      case '-':\n        // Fall through.\n      case '=':\n        var n = parseInt(param, 10);\n        if (isNaN(n) || n < 0) {\n          throw new Error('Invalid number in diff_fromDelta: ' + param);\n        }\n        var text = text1.substring(pointer, pointer += n);\n        if (tokens[x].charAt(0) == '=') {\n          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text);\n        } else {\n          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text);\n        }\n        break;\n      default:\n        // Blank tokens are ok (from a trailing \\t).\n        // Anything else is an error.\n        if (tokens[x]) {\n          throw new Error('Invalid diff operation in diff_fromDelta: ' +\n                          tokens[x]);\n        }\n    }\n  }\n  if (pointer != text1.length) {\n    throw new Error('Delta length (' + pointer +\n        ') does not equal source text length (' + text1.length + ').');\n  }\n  return diffs;\n};\n\n\n//  MATCH FUNCTIONS\n\n\n/**\n * Locate the best instance of 'pattern' in 'text' near 'loc'.\n * @param {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n */\ndiff_match_patch.prototype.match_main = function(text, pattern, loc) {\n  // Check for null inputs.\n  if (text == null || pattern == null || loc == null) {\n    throw new Error('Null input. (match_main)');\n  }\n\n  loc = Math.max(0, Math.min(loc, text.length));\n  if (text == pattern) {\n    // Shortcut (potentially not guaranteed by the algorithm)\n    return 0;\n  } else if (!text.length) {\n    // Nothing to match.\n    return -1;\n  } else if (text.substring(loc, loc + pattern.length) == pattern) {\n    // Perfect match at the perfect spot!  (Includes case of null pattern)\n    return loc;\n  } else {\n    // Do a fuzzy compare.\n    return this.match_bitap_(text, pattern, loc);\n  }\n};\n\n\n/**\n * Locate the best instance of 'pattern' in 'text' near 'loc' using the\n * Bitap algorithm.\n * @param {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n * @private\n */\ndiff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {\n  if (pattern.length > this.Match_MaxBits) {\n    throw new Error('Pattern too long for this browser.');\n  }\n\n  // Initialise the alphabet.\n  var s = this.match_alphabet_(pattern);\n\n  var dmp = this;  // 'this' becomes 'window' in a closure.\n\n  /**\n   * Compute and return the score for a match with e errors and x location.\n   * Accesses loc and pattern through being a closure.\n   * @param {number} e Number of errors in match.\n   * @param {number} x Location of match.\n   * @return {number} Overall score for match (0.0 = good, 1.0 = bad).\n   * @private\n   */\n  function match_bitapScore_(e, x) {\n    var accuracy = e / pattern.length;\n    var proximity = Math.abs(loc - x);\n    if (!dmp.Match_Distance) {\n      // Dodge divide by zero error.\n      return proximity ? 1.0 : accuracy;\n    }\n    return accuracy + (proximity / dmp.Match_Distance);\n  }\n\n  // Highest score beyond which we give up.\n  var score_threshold = this.Match_Threshold;\n  // Is there a nearby exact match? (speedup)\n  var best_loc = text.indexOf(pattern, loc);\n  if (best_loc != -1) {\n    score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);\n    // What about in the other direction? (speedup)\n    best_loc = text.lastIndexOf(pattern, loc + pattern.length);\n    if (best_loc != -1) {\n      score_threshold =\n          Math.min(match_bitapScore_(0, best_loc), score_threshold);\n    }\n  }\n\n  // Initialise the bit arrays.\n  var matchmask = 1 << (pattern.length - 1);\n  best_loc = -1;\n\n  var bin_min, bin_mid;\n  var bin_max = pattern.length + text.length;\n  var last_rd;\n  for (var d = 0; d < pattern.length; d++) {\n    // Scan for the best match; each iteration allows for one more error.\n    // Run a binary search to determine how far from 'loc' we can stray at this\n    // error level.\n    bin_min = 0;\n    bin_mid = bin_max;\n    while (bin_min < bin_mid) {\n      if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {\n        bin_min = bin_mid;\n      } else {\n        bin_max = bin_mid;\n      }\n      bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);\n    }\n    // Use the result from this iteration as the maximum for the next.\n    bin_max = bin_mid;\n    var start = Math.max(1, loc - bin_mid + 1);\n    var finish = Math.min(loc + bin_mid, text.length) + pattern.length;\n\n    var rd = Array(finish + 2);\n    rd[finish + 1] = (1 << d) - 1;\n    for (var j = finish; j >= start; j--) {\n      // The alphabet (s) is a sparse hash, so the following line generates\n      // warnings.\n      var charMatch = s[text.charAt(j - 1)];\n      if (d === 0) {  // First pass: exact match.\n        rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;\n      } else {  // Subsequent passes: fuzzy match.\n        rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |\n                (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |\n                last_rd[j + 1];\n      }\n      if (rd[j] & matchmask) {\n        var score = match_bitapScore_(d, j - 1);\n        // This match will almost certainly be better than any existing match.\n        // But check anyway.\n        if (score <= score_threshold) {\n          // Told you so.\n          score_threshold = score;\n          best_loc = j - 1;\n          if (best_loc > loc) {\n            // When passing loc, don't exceed our current distance from loc.\n            start = Math.max(1, 2 * loc - best_loc);\n          } else {\n            // Already passed loc, downhill from here on in.\n            break;\n          }\n        }\n      }\n    }\n    // No hope for a (better) match at greater error levels.\n    if (match_bitapScore_(d + 1, loc) > score_threshold) {\n      break;\n    }\n    last_rd = rd;\n  }\n  return best_loc;\n};\n\n\n/**\n * Initialise the alphabet for the Bitap algorithm.\n * @param {string} pattern The text to encode.\n * @return {!Object} Hash of character locations.\n * @private\n */\ndiff_match_patch.prototype.match_alphabet_ = function(pattern) {\n  var s = {};\n  for (var i = 0; i < pattern.length; i++) {\n    s[pattern.charAt(i)] = 0;\n  }\n  for (var i = 0; i < pattern.length; i++) {\n    s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);\n  }\n  return s;\n};\n\n\n//  PATCH FUNCTIONS\n\n\n/**\n * Increase the context until it is unique,\n * but don't let the pattern expand beyond Match_MaxBits.\n * @param {!diff_match_patch.patch_obj} patch The patch to grow.\n * @param {string} text Source text.\n * @private\n */\ndiff_match_patch.prototype.patch_addContext_ = function(patch, text) {\n  if (text.length == 0) {\n    return;\n  }\n  if (patch.start2 === null) {\n    throw Error('patch not initialized');\n  }\n  var pattern = text.substring(patch.start2, patch.start2 + patch.length1);\n  var padding = 0;\n\n  // Look for the first and last matches of pattern in text.  If two different\n  // matches are found, increase the pattern length.\n  while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&\n         pattern.length < this.Match_MaxBits - this.Patch_Margin -\n         this.Patch_Margin) {\n    padding += this.Patch_Margin;\n    pattern = text.substring(patch.start2 - padding,\n                             patch.start2 + patch.length1 + padding);\n  }\n  // Add one chunk for good luck.\n  padding += this.Patch_Margin;\n\n  // Add the prefix.\n  var prefix = text.substring(patch.start2 - padding, patch.start2);\n  if (prefix) {\n    patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix));\n  }\n  // Add the suffix.\n  var suffix = text.substring(patch.start2 + patch.length1,\n                              patch.start2 + patch.length1 + padding);\n  if (suffix) {\n    patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix));\n  }\n\n  // Roll back the start points.\n  patch.start1 -= prefix.length;\n  patch.start2 -= prefix.length;\n  // Extend the lengths.\n  patch.length1 += prefix.length + suffix.length;\n  patch.length2 += prefix.length + suffix.length;\n};\n\n\n/**\n * Compute a list of patches to turn text1 into text2.\n * Use diffs if provided, otherwise compute it ourselves.\n * There are four ways to call this function, depending on what data is\n * available to the caller:\n * Method 1:\n * a = text1, b = text2\n * Method 2:\n * a = diffs\n * Method 3 (optimal):\n * a = text1, b = diffs\n * Method 4 (deprecated, use method 3):\n * a = text1, b = text2, c = diffs\n *\n * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or\n * Array of diff tuples for text1 to text2 (method 2).\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_b text2 (methods 1,4) or\n * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_c Array of diff tuples\n * for text1 to text2 (method 4) or undefined (methods 1,2,3).\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {\n  var text1, diffs;\n  if (typeof a == 'string' && typeof opt_b == 'string' &&\n      typeof opt_c == 'undefined') {\n    // Method 1: text1, text2\n    // Compute diffs from text1 and text2.\n    text1 = /** @type {string} */(a);\n    diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);\n    if (diffs.length > 2) {\n      this.diff_cleanupSemantic(diffs);\n      this.diff_cleanupEfficiency(diffs);\n    }\n  } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&\n      typeof opt_c == 'undefined') {\n    // Method 2: diffs\n    // Compute text1 from diffs.\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);\n    text1 = this.diff_text1(diffs);\n  } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&\n      typeof opt_c == 'undefined') {\n    // Method 3: text1, diffs\n    text1 = /** @type {string} */(a);\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);\n  } else if (typeof a == 'string' && typeof opt_b == 'string' &&\n      opt_c && typeof opt_c == 'object') {\n    // Method 4: text1, text2, diffs\n    // text2 is not used.\n    text1 = /** @type {string} */(a);\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);\n  } else {\n    throw new Error('Unknown call format to patch_make.');\n  }\n\n  if (diffs.length === 0) {\n    return [];  // Get rid of the null case.\n  }\n  var patches = [];\n  var patch = new diff_match_patch.patch_obj();\n  var patchDiffLength = 0;  // Keeping our own length var is faster in JS.\n  var char_count1 = 0;  // Number of characters into the text1 string.\n  var char_count2 = 0;  // Number of characters into the text2 string.\n  // Start with text1 (prepatch_text) and apply the diffs until we arrive at\n  // text2 (postpatch_text).  We recreate the patches one by one to determine\n  // context info.\n  var prepatch_text = text1;\n  var postpatch_text = text1;\n  for (var x = 0; x < diffs.length; x++) {\n    var diff_type = diffs[x][0];\n    var diff_text = diffs[x][1];\n\n    if (!patchDiffLength && diff_type !== DIFF_EQUAL) {\n      // A new patch starts here.\n      patch.start1 = char_count1;\n      patch.start2 = char_count2;\n    }\n\n    switch (diff_type) {\n      case DIFF_INSERT:\n        patch.diffs[patchDiffLength++] = diffs[x];\n        patch.length2 += diff_text.length;\n        postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +\n                         postpatch_text.substring(char_count2);\n        break;\n      case DIFF_DELETE:\n        patch.length1 += diff_text.length;\n        patch.diffs[patchDiffLength++] = diffs[x];\n        postpatch_text = postpatch_text.substring(0, char_count2) +\n                         postpatch_text.substring(char_count2 +\n                             diff_text.length);\n        break;\n      case DIFF_EQUAL:\n        if (diff_text.length <= 2 * this.Patch_Margin &&\n            patchDiffLength && diffs.length != x + 1) {\n          // Small equality inside a patch.\n          patch.diffs[patchDiffLength++] = diffs[x];\n          patch.length1 += diff_text.length;\n          patch.length2 += diff_text.length;\n        } else if (diff_text.length >= 2 * this.Patch_Margin) {\n          // Time for a new patch.\n          if (patchDiffLength) {\n            this.patch_addContext_(patch, prepatch_text);\n            patches.push(patch);\n            patch = new diff_match_patch.patch_obj();\n            patchDiffLength = 0;\n            // Unlike Unidiff, our patch lists have a rolling context.\n            // https://github.com/google/diff-match-patch/wiki/Unidiff\n            // Update prepatch text & pos to reflect the application of the\n            // just completed patch.\n            prepatch_text = postpatch_text;\n            char_count1 = char_count2;\n          }\n        }\n        break;\n    }\n\n    // Update the current character count.\n    if (diff_type !== DIFF_INSERT) {\n      char_count1 += diff_text.length;\n    }\n    if (diff_type !== DIFF_DELETE) {\n      char_count2 += diff_text.length;\n    }\n  }\n  // Pick up the leftover patch if not empty.\n  if (patchDiffLength) {\n    this.patch_addContext_(patch, prepatch_text);\n    patches.push(patch);\n  }\n\n  return patches;\n};\n\n\n/**\n * Given an array of patches, return another array that is identical.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_deepCopy = function(patches) {\n  // Making deep copies is hard in JavaScript.\n  var patchesCopy = [];\n  for (var x = 0; x < patches.length; x++) {\n    var patch = patches[x];\n    var patchCopy = new diff_match_patch.patch_obj();\n    patchCopy.diffs = [];\n    for (var y = 0; y < patch.diffs.length; y++) {\n      patchCopy.diffs[y] =\n          new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);\n    }\n    patchCopy.start1 = patch.start1;\n    patchCopy.start2 = patch.start2;\n    patchCopy.length1 = patch.length1;\n    patchCopy.length2 = patch.length2;\n    patchesCopy[x] = patchCopy;\n  }\n  return patchesCopy;\n};\n\n\n/**\n * Merge a set of patches onto the text.  Return a patched text, as well\n * as a list of true/false values indicating which patches were applied.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @param {string} text Old text.\n * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the\n *      new text and an array of boolean values.\n */\ndiff_match_patch.prototype.patch_apply = function(patches, text) {\n  if (patches.length == 0) {\n    return [text, []];\n  }\n\n  // Deep copy the patches so that no changes are made to originals.\n  patches = this.patch_deepCopy(patches);\n\n  var nullPadding = this.patch_addPadding(patches);\n  text = nullPadding + text + nullPadding;\n\n  this.patch_splitMax(patches);\n  // delta keeps track of the offset between the expected and actual location\n  // of the previous patch.  If there are patches expected at positions 10 and\n  // 20, but the first patch was found at 12, delta is 2 and the second patch\n  // has an effective expected position of 22.\n  var delta = 0;\n  var results = [];\n  for (var x = 0; x < patches.length; x++) {\n    var expected_loc = patches[x].start2 + delta;\n    var text1 = this.diff_text1(patches[x].diffs);\n    var start_loc;\n    var end_loc = -1;\n    if (text1.length > this.Match_MaxBits) {\n      // patch_splitMax will only provide an oversized pattern in the case of\n      // a monster delete.\n      start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),\n                                  expected_loc);\n      if (start_loc != -1) {\n        end_loc = this.match_main(text,\n            text1.substring(text1.length - this.Match_MaxBits),\n            expected_loc + text1.length - this.Match_MaxBits);\n        if (end_loc == -1 || start_loc >= end_loc) {\n          // Can't find valid trailing context.  Drop this patch.\n          start_loc = -1;\n        }\n      }\n    } else {\n      start_loc = this.match_main(text, text1, expected_loc);\n    }\n    if (start_loc == -1) {\n      // No match found.  :(\n      results[x] = false;\n      // Subtract the delta for this failed patch from subsequent patches.\n      delta -= patches[x].length2 - patches[x].length1;\n    } else {\n      // Found a match.  :)\n      results[x] = true;\n      delta = start_loc - expected_loc;\n      var text2;\n      if (end_loc == -1) {\n        text2 = text.substring(start_loc, start_loc + text1.length);\n      } else {\n        text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);\n      }\n      if (text1 == text2) {\n        // Perfect match, just shove the replacement text in.\n        text = text.substring(0, start_loc) +\n               this.diff_text2(patches[x].diffs) +\n               text.substring(start_loc + text1.length);\n      } else {\n        // Imperfect match.  Run a diff to get a framework of equivalent\n        // indices.\n        var diffs = this.diff_main(text1, text2, false);\n        if (text1.length > this.Match_MaxBits &&\n            this.diff_levenshtein(diffs) / text1.length >\n            this.Patch_DeleteThreshold) {\n          // The end points match, but the content is unacceptably bad.\n          results[x] = false;\n        } else {\n          this.diff_cleanupSemanticLossless(diffs);\n          var index1 = 0;\n          var index2;\n          for (var y = 0; y < patches[x].diffs.length; y++) {\n            var mod = patches[x].diffs[y];\n            if (mod[0] !== DIFF_EQUAL) {\n              index2 = this.diff_xIndex(diffs, index1);\n            }\n            if (mod[0] === DIFF_INSERT) {  // Insertion\n              text = text.substring(0, start_loc + index2) + mod[1] +\n                     text.substring(start_loc + index2);\n            } else if (mod[0] === DIFF_DELETE) {  // Deletion\n              text = text.substring(0, start_loc + index2) +\n                     text.substring(start_loc + this.diff_xIndex(diffs,\n                         index1 + mod[1].length));\n            }\n            if (mod[0] !== DIFF_DELETE) {\n              index1 += mod[1].length;\n            }\n          }\n        }\n      }\n    }\n  }\n  // Strip the padding off.\n  text = text.substring(nullPadding.length, text.length - nullPadding.length);\n  return [text, results];\n};\n\n\n/**\n * Add some padding on text start and end so that edges can match something.\n * Intended to be called only from within patch_apply.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {string} The padding string added to each side.\n */\ndiff_match_patch.prototype.patch_addPadding = function(patches) {\n  var paddingLength = this.Patch_Margin;\n  var nullPadding = '';\n  for (var x = 1; x <= paddingLength; x++) {\n    nullPadding += String.fromCharCode(x);\n  }\n\n  // Bump all the patches forward.\n  for (var x = 0; x < patches.length; x++) {\n    patches[x].start1 += paddingLength;\n    patches[x].start2 += paddingLength;\n  }\n\n  // Add some padding on start of first diff.\n  var patch = patches[0];\n  var diffs = patch.diffs;\n  if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {\n    // Add nullPadding equality.\n    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\n    patch.start1 -= paddingLength;  // Should be 0.\n    patch.start2 -= paddingLength;  // Should be 0.\n    patch.length1 += paddingLength;\n    patch.length2 += paddingLength;\n  } else if (paddingLength > diffs[0][1].length) {\n    // Grow first equality.\n    var extraLength = paddingLength - diffs[0][1].length;\n    diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];\n    patch.start1 -= extraLength;\n    patch.start2 -= extraLength;\n    patch.length1 += extraLength;\n    patch.length2 += extraLength;\n  }\n\n  // Add some padding on end of last diff.\n  patch = patches[patches.length - 1];\n  diffs = patch.diffs;\n  if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {\n    // Add nullPadding equality.\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\n    patch.length1 += paddingLength;\n    patch.length2 += paddingLength;\n  } else if (paddingLength > diffs[diffs.length - 1][1].length) {\n    // Grow last equality.\n    var extraLength = paddingLength - diffs[diffs.length - 1][1].length;\n    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);\n    patch.length1 += extraLength;\n    patch.length2 += extraLength;\n  }\n\n  return nullPadding;\n};\n\n\n/**\n * Look through the patches and break up any which are longer than the maximum\n * limit of the match algorithm.\n * Intended to be called only from within patch_apply.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_splitMax = function(patches) {\n  var patch_size = this.Match_MaxBits;\n  for (var x = 0; x < patches.length; x++) {\n    if (patches[x].length1 <= patch_size) {\n      continue;\n    }\n    var bigpatch = patches[x];\n    // Remove the big old patch.\n    patches.splice(x--, 1);\n    var start1 = bigpatch.start1;\n    var start2 = bigpatch.start2;\n    var precontext = '';\n    while (bigpatch.diffs.length !== 0) {\n      // Create one of several smaller patches.\n      var patch = new diff_match_patch.patch_obj();\n      var empty = true;\n      patch.start1 = start1 - precontext.length;\n      patch.start2 = start2 - precontext.length;\n      if (precontext !== '') {\n        patch.length1 = patch.length2 = precontext.length;\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext));\n      }\n      while (bigpatch.diffs.length !== 0 &&\n             patch.length1 < patch_size - this.Patch_Margin) {\n        var diff_type = bigpatch.diffs[0][0];\n        var diff_text = bigpatch.diffs[0][1];\n        if (diff_type === DIFF_INSERT) {\n          // Insertions are harmless.\n          patch.length2 += diff_text.length;\n          start2 += diff_text.length;\n          patch.diffs.push(bigpatch.diffs.shift());\n          empty = false;\n        } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&\n                   patch.diffs[0][0] == DIFF_EQUAL &&\n                   diff_text.length > 2 * patch_size) {\n          // This is a large deletion.  Let it pass in one chunk.\n          patch.length1 += diff_text.length;\n          start1 += diff_text.length;\n          empty = false;\n          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\n          bigpatch.diffs.shift();\n        } else {\n          // Deletion or equality.  Only take as much as we can stomach.\n          diff_text = diff_text.substring(0,\n              patch_size - patch.length1 - this.Patch_Margin);\n          patch.length1 += diff_text.length;\n          start1 += diff_text.length;\n          if (diff_type === DIFF_EQUAL) {\n            patch.length2 += diff_text.length;\n            start2 += diff_text.length;\n          } else {\n            empty = false;\n          }\n          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\n          if (diff_text == bigpatch.diffs[0][1]) {\n            bigpatch.diffs.shift();\n          } else {\n            bigpatch.diffs[0][1] =\n                bigpatch.diffs[0][1].substring(diff_text.length);\n          }\n        }\n      }\n      // Compute the head context for the next patch.\n      precontext = this.diff_text2(patch.diffs);\n      precontext =\n          precontext.substring(precontext.length - this.Patch_Margin);\n      // Append the end context for this patch.\n      var postcontext = this.diff_text1(bigpatch.diffs)\n                            .substring(0, this.Patch_Margin);\n      if (postcontext !== '') {\n        patch.length1 += postcontext.length;\n        patch.length2 += postcontext.length;\n        if (patch.diffs.length !== 0 &&\n            patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {\n          patch.diffs[patch.diffs.length - 1][1] += postcontext;\n        } else {\n          patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext));\n        }\n      }\n      if (!empty) {\n        patches.splice(++x, 0, patch);\n      }\n    }\n  }\n};\n\n\n/**\n * Take a list of patches and return a textual representation.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {string} Text representation of patches.\n */\ndiff_match_patch.prototype.patch_toText = function(patches) {\n  var text = [];\n  for (var x = 0; x < patches.length; x++) {\n    text[x] = patches[x];\n  }\n  return text.join('');\n};\n\n\n/**\n * Parse a textual representation of patches and return a list of Patch objects.\n * @param {string} textline Text representation of patches.\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.patch_fromText = function(textline) {\n  var patches = [];\n  if (!textline) {\n    return patches;\n  }\n  var text = textline.split('\\n');\n  var textPointer = 0;\n  var patchHeader = /^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$/;\n  while (textPointer < text.length) {\n    var m = text[textPointer].match(patchHeader);\n    if (!m) {\n      throw new Error('Invalid patch string: ' + text[textPointer]);\n    }\n    var patch = new diff_match_patch.patch_obj();\n    patches.push(patch);\n    patch.start1 = parseInt(m[1], 10);\n    if (m[2] === '') {\n      patch.start1--;\n      patch.length1 = 1;\n    } else if (m[2] == '0') {\n      patch.length1 = 0;\n    } else {\n      patch.start1--;\n      patch.length1 = parseInt(m[2], 10);\n    }\n\n    patch.start2 = parseInt(m[3], 10);\n    if (m[4] === '') {\n      patch.start2--;\n      patch.length2 = 1;\n    } else if (m[4] == '0') {\n      patch.length2 = 0;\n    } else {\n      patch.start2--;\n      patch.length2 = parseInt(m[4], 10);\n    }\n    textPointer++;\n\n    while (textPointer < text.length) {\n      var sign = text[textPointer].charAt(0);\n      try {\n        var line = decodeURI(text[textPointer].substring(1));\n      } catch (ex) {\n        // Malformed URI sequence.\n        throw new Error('Illegal escape in patch_fromText: ' + line);\n      }\n      if (sign == '-') {\n        // Deletion.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line));\n      } else if (sign == '+') {\n        // Insertion.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line));\n      } else if (sign == ' ') {\n        // Minor equality.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line));\n      } else if (sign == '@') {\n        // Start of next patch.\n        break;\n      } else if (sign === '') {\n        // Blank line?  Whatever.\n      } else {\n        // WTF?\n        throw new Error('Invalid patch mode \"' + sign + '\" in: ' + line);\n      }\n      textPointer++;\n    }\n  }\n  return patches;\n};\n\n\n/**\n * Class representing one patch operation.\n * @constructor\n */\ndiff_match_patch.patch_obj = function() {\n  /** @type {!Array.<!diff_match_patch.Diff>} */\n  this.diffs = [];\n  /** @type {?number} */\n  this.start1 = null;\n  /** @type {?number} */\n  this.start2 = null;\n  /** @type {number} */\n  this.length1 = 0;\n  /** @type {number} */\n  this.length2 = 0;\n};\n\n\n/**\n * Emulate GNU diff's format.\n * Header: @@ -382,8 +481,9 @@\n * Indices are printed as 1-based, not 0-based.\n * @return {string} The GNU diff string.\n */\ndiff_match_patch.patch_obj.prototype.toString = function() {\n  var coords1, coords2;\n  if (this.length1 === 0) {\n    coords1 = this.start1 + ',0';\n  } else if (this.length1 == 1) {\n    coords1 = this.start1 + 1;\n  } else {\n    coords1 = (this.start1 + 1) + ',' + this.length1;\n  }\n  if (this.length2 === 0) {\n    coords2 = this.start2 + ',0';\n  } else if (this.length2 == 1) {\n    coords2 = this.start2 + 1;\n  } else {\n    coords2 = (this.start2 + 1) + ',' + this.length2;\n  }\n  var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\\n'];\n  var op;\n  // Escape the body of the patch with %xx notation.\n  for (var x = 0; x < this.diffs.length; x++) {\n    switch (this.diffs[x][0]) {\n      case DIFF_INSERT:\n        op = '+';\n        break;\n      case DIFF_DELETE:\n        op = '-';\n        break;\n      case DIFF_EQUAL:\n        op = ' ';\n        break;\n    }\n    text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\\n';\n  }\n  return text.join('').replace(/%20/g, ' ');\n};\n\n\n// The following export code was added by @ForbesLindesay\nmodule.exports = diff_match_patch;\nmodule.exports['diff_match_patch'] = diff_match_patch;\nmodule.exports['DIFF_DELETE'] = DIFF_DELETE;\nmodule.exports['DIFF_INSERT'] = DIFF_INSERT;\nmodule.exports['DIFF_EQUAL'] = DIFF_EQUAL;","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../css-loader/dist/cjs.js??clonedRuleSet-14.use[1]!../../postcss-loader/dist/cjs.js??clonedRuleSet-14.use[2]!../../postcss-loader/dist/cjs.js??clonedRuleSet-14.use[3]!./ace-diff-dark.min.css\");\nif(content.__esModule) content = content.default;\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar add = require(\"!../../vue-style-loader/lib/addStylesClient.js\").default\nvar update = add(\"d4f0f0e8\", content, true, {\"sourceMap\":false,\"shadowMode\":false});","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../css-loader/dist/cjs.js??clonedRuleSet-14.use[1]!../../postcss-loader/dist/cjs.js??clonedRuleSet-14.use[2]!../../postcss-loader/dist/cjs.js??clonedRuleSet-14.use[3]!./ace-diff.min.css\");\nif(content.__esModule) content = content.default;\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar add = require(\"!../../vue-style-loader/lib/addStylesClient.js\").default\nvar update = add(\"e0a225b0\", content, true, {\"sourceMap\":false,\"shadowMode\":false});","import unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      var F = function F() {};\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n  var normalCompletion = true,\n    didErr = false,\n    err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}"],"names":["module","exports","DIFF_EQUAL","DIFF_DELETE","DIFF_INSERT","EDITOR_RIGHT","EDITOR_LEFT","RTL","LTR","SVG_NS","DIFF_GRANULARITY_SPECIFIC","DIFF_GRANULARITY_BROAD","parent","elClass","guid","Math","random","toString","substr","newId","currentEl","querySelector","id","el","document","createElement","appendChild","className","on","elSelector","eventName","selector","fn","element","addEventListener","event","possibleTargets","querySelectorAll","target","i","l","length","p","call","parentNode","callback","wait","timeout","args","context","this","clearTimeout","setTimeout","apply","isObject","item","Array","isArray","merge","source","Object","keys","forEach","key","assign","value","normalized","replace","immediate","initialCall","callNow","next","DiffMatchPatch","throttle","debounce","normalizeContent","getCurve","getMode","getTheme","getLine","getEditorHeight","createArrow","ensureElement","query","C","Range","getRangeModule","ace","requireFunc","acequire","require","AceDiff","options","acediff","getDefaultAce","window","undefined","mode","theme","diffGranularity","lockScrolling","showDiffs","showConnectors","maxDiffs","left","content","editable","copyLinkEnabled","right","classes","gutterID","diff","connector","newCodeConnectorLink","newCodeConnectorLinkContent","deletedCodeConnectorLink","deletedCodeConnectorLinkContent","copyRightContainer","copyLeftContainer","connectorYOffset","errMessage","console","error","Error","HTMLElement","body","innerHTML","editors","edit","markers","lineLengths","editorHeight","getSession","setMode","setReadOnly","setTheme","setValue","lineHeight","renderer","addEventHandlers","createCopyContainers","createGutter","prototype","setOptions","getNumDiffs","diffs","getEditors","dmp","val1","getValue","val2","diff_main","diff_cleanupSemantic","getLineLengths","offset","chunk","index","array","chunkType","text","endsWith","startsWith","push","computeDiff","simplifyDiffs","clearDiffs","decorate","destroy","leftValue","oldDiv","container","newDiv","cloneNode","textContent","replaceChild","rightValue","getElementById","removeEventHandlers","updateGap","bind","e","copy","onResize","availableHeight","offsetHeight","removeEventListener","dir","diffIndex","parseInt","getAttribute","sourceEditor","targetEditor","startLine","endLine","targetStartLine","targetEndLine","leftStartLine","leftEndLine","rightStartLine","rightEndLine","contentToInsert","h","getScrollTop","setScrollTop","editor","lines","doc","getAllLines","line","showDiff","editorInstance","classNames","session","addMarker","positionCopyContainers","marker","removeMarker","addConnector","leftScrollTop","rightScrollTop","p1_x","p1_y","p2_x","gutterWidth","p2_y","p3_x","p3_y","p4_x","p4_y","curve1","curve2","verticalLine1","verticalLine2","d","createElementNS","setAttribute","gutterSVG","addCopyArrows","info","arrow","topOffset","tooltip","arrowContent","leftTopOffset","rightTopOffset","style","cssText","diffType","offsetLeft","offsetRight","diffText","lineInfo","newContentStartsWithNewline","test","getSingleDiffInfo","currentLineOtherEditor","getLineForCharPosition","numCharsOnLineOtherEditor","getCharsOnLine","numCharsOnLeftEditorStartLine","numCharsOnLine","startChar","isLastChar","sameLineInsert","numRows","numCharsOnRightEditorStartLine","diffString","endChar","endCharNum","runningTotal","startLineSet","endLineSet","lineLength","lineIndex","endsWithNewline","offsetChars","foundLine","char","startsWithNewline","comparison","gutterHeight","clientHeight","clientWidth","leftHeight","getTotalHeight","rightHeight","height","max","ed","getLength","clearGutter","gutterEl","removeChild","clearArrows","groupedDiffs","compare","val","isGrouped","abs","min","fullDiffs","props","class","title","startX","startY","endX","endY","w","halfWidth","itoc","ctoi","charAt","IndexSizeError","s","c","m","DOMStringSizeError","HierarchyRequestError","WrongDocumentError","InvalidCharacterError","NoDataAllowedError","NoModificationAllowedError","NotFoundError","NotSupportedError","InUseAttributeError","InvalidStateError","SyntaxError","InvalidModificationError","NamespaceError","InvalidAccessError","ValidationError","TypeMismatchError","SecurityError","NetworkError","AbortError","URLMismatchError","QuotaExceededError","TimeoutError","InvalidNodeTypeError","DataCloneError","DESCRIPTORS","fails","anObject","create","normalizeStringArgument","nativeErrorToString","INCORRECT_TO_STRING","object","defineProperty","get","message","name","O","IS_NODE","Function","$","$findIndex","addToUnscopables","FIND_INDEX","SKIPS_HOLES","proto","forced","findIndex","callbackfn","arguments","global","uncurryThis","isForced","inheritIfRequired","createNonEnumerableProperty","getOwnPropertyNames","isPrototypeOf","isRegExp","getRegExpFlags","stickyHelpers","proxyAccessor","defineBuiltIn","hasOwn","enforceInternalState","setSpecies","wellKnownSymbol","UNSUPPORTED_DOT_ALL","UNSUPPORTED_NCG","MATCH","NativeRegExp","RegExp","RegExpPrototype","exec","stringIndexOf","indexOf","stringSlice","slice","IS_NCG","re1","re2","CORRECT_NEW","MISSED_STICKY","UNSUPPORTED_Y","BASE_FORCED","handleDotAll","string","chr","result","brackets","handleNCG","named","names","ncg","groupid","groupname","RegExpWrapper","pattern","flags","rawFlags","dotAll","sticky","handled","state","thisIsRegExp","patternIsRegExp","flagsAreUndefined","groups","rawPattern","constructor","raw","classof","defineBuiltInAccessor","getInternalState","$TypeError","TypeError","configurable","getBuiltIn","validateArgumentsLength","disallowed","whitespaces","finalEq","$atob","fromCharCode","String","NO_SPACES_IGNORE","NO_ENCODING_CHECK","NO_ARG_RECEIVING_CHECK","WRONG_ARITY","enumerable","atob","data","bs","output","position","bc","tryNodeRequire","createPropertyDescriptor","anInstance","errorToString","DOMExceptionConstants","clearErrorStack","InternalStateModule","IS_PURE","DOM_EXCEPTION","DATA_CLONE_ERR","NativeDOMException","MessageChannel","port1","postMessage","WeakMap","code","NativeDOMExceptionPrototype","ErrorPrototype","setInternalState","set","getterFor","HAS_STACK","codeFor","$DOMException","DOMExceptionPrototype","argumentsLength","type","stack","createGetterDescriptor","INCORRECT_CONSTRUCTOR","INCORRECT_CODE","MISSED_CONSTANTS","FORCED_CONSTRUCTOR","DOMException","PolyfilledDOMException","PolyfilledDOMExceptionPrototype","constant","constantName","descriptor","that","ERROR_HAS_STACK","DOM_EXCEPTION_HAS_STACK","getOwnPropertyDescriptor","BUGGY_DESCRIPTOR","writable","setToStringTag","___CSS_LOADER_EXPORT___","diff_match_patch","Diff_Timeout","Diff_EditCost","Match_Threshold","Match_Distance","Patch_DeleteThreshold","Patch_Margin","Match_MaxBits","Diff","op","text1","text2","opt_checklines","opt_deadline","Number","MAX_VALUE","Date","getTime","deadline","checklines","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diff_compute_","unshift","diff_cleanupMerge","longtext","shorttext","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","concat","diff_lineMode_","diff_bisect_","a","diff_linesToChars_","chars1","chars2","linearray","lineArray","diff_charsToLines_","pointer","count_delete","count_insert","text_delete","text_insert","splice","subDiff","j","pop","text1_length","text2_length","max_d","ceil","v_offset","v_length","v1","v2","x","delta","front","k1start","k1end","k2start","k2end","k1","k1_offset","x1","y1","k2_offset","x2","diff_bisectSplit_","k2","y2","y","text1a","text2a","text1b","text2b","diffsb","lineHash","diff_linesToCharsMunge_","chars","lineStart","lineEnd","lineArrayLength","hasOwnProperty","maxLines","charCodeAt","join","pointermin","pointermax","pointermid","pointerstart","floor","pointerend","diff_commonOverlap_","text_length","best","found","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","prefixLength","suffixLength","hm1","hm2","changes","equalities","equalitiesLength","lastEquality","length_insertions1","length_deletions1","length_insertions2","length_deletions2","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","overlap_length2","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","match","nonAlphaNumericRegex_","nonAlphaNumeric2","whitespace1","whitespaceRegex_","whitespace2","lineBreak1","linebreakRegex_","lineBreak2","blankLine1","blanklineEndRegex_","blankLine2","blanklineStartRegex_","equality1","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","diff_cleanupEfficiency","pre_ins","pre_del","post_ins","post_del","diff_xIndex","loc","last_chars1","last_chars2","diff_prettyHtml","html","pattern_amp","pattern_lt","pattern_gt","pattern_para","diff_text1","diff_text2","diff_levenshtein","levenshtein","insertions","deletions","diff_toDelta","encodeURI","diff_fromDelta","diffsLength","tokens","split","param","decodeURI","ex","n","isNaN","match_main","match_bitap_","match_alphabet_","match_bitapScore_","accuracy","proximity","score_threshold","best_loc","lastIndexOf","bin_min","bin_mid","matchmask","last_rd","bin_max","start","finish","rd","charMatch","patch_addContext_","patch","start2","length1","padding","prefix","suffix","start1","length2","patch_make","opt_b","opt_c","patches","patch_obj","patchDiffLength","char_count1","char_count2","prepatch_text","postpatch_text","diff_type","diff_text","patch_deepCopy","patchesCopy","patchCopy","patch_apply","nullPadding","patch_addPadding","patch_splitMax","results","start_loc","expected_loc","end_loc","index2","index1","mod","paddingLength","extraLength","patch_size","bigpatch","precontext","empty","shift","postcontext","patch_toText","patch_fromText","textline","textPointer","patchHeader","sign","coords1","coords2","__esModule","default","locals","add","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","unsupportedIterableToArray","F","done","_e","f","err","normalCompletion","didErr","step","_e2"],"sourceRoot":""}