openc3-cosmos-tool-admin 5.6.0 → 5.7.0

data/tools/admin/js/324.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js/324.js","mappings":"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","sources":["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/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/diff-match-patch/index.js","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff-dark.min.css?c7cd","webpack://@openc3/cosmos-tool-admin/../../node_modules/ace-diff/dist/ace-diff.min.css?6750","webpack://@openc3/cosmos-tool-admin/../../node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js"],"sourcesContent":["// Imports\nimport ___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___ from \"../../@vue/cli-service/node_modules/css-loader/dist/runtime/noSourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../@vue/cli-service/node_modules/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 \"../../@vue/cli-service/node_modules/css-loader/dist/runtime/noSourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../@vue/cli-service/node_modules/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","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","/**\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(\"!!../../@vue/cli-service/node_modules/css-loader/dist/cjs.js??clonedRuleSet-14.use[1]!../../@vue/cli-service/node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-14.use[2]!../../@vue/cli-service/node_modules/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(\"1d7f178b\", 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(\"!!../../@vue/cli-service/node_modules/css-loader/dist/cjs.js??clonedRuleSet-14.use[1]!../../@vue/cli-service/node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-14.use[2]!../../@vue/cli-service/node_modules/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(\"c888c032\", 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":["___CSS_LOADER_EXPORT___","push","module","id","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","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","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","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":""}