diff --git a/imac.202c52ff.jpeg b/imac.202c52ff.jpeg new file mode 100644 index 0000000000..c282f7c494 Binary files /dev/null and b/imac.202c52ff.jpeg differ diff --git a/index.25f883ac.css b/index.25f883ac.css new file mode 100644 index 0000000000..46a33874bb --- /dev/null +++ b/index.25f883ac.css @@ -0,0 +1,2 @@ +.page{color:#060b35;font-family:Roboto,sans-serif;font-weight:400}.body{margin:0}.body__card{box-sizing:border-box;background-image:url(imac.202c52ff.jpeg);background-position:19px 32px;background-repeat:no-repeat;background-size:160px 134px;border:1px solid #f3f3f3;border-radius:5px;width:200px;height:406px;position:relative}.card__text{text-align:left;padding-inline:16px;font-family:Roboto;font-size:12px;font-weight:500;line-height:18px;position:absolute;top:206px}.card__product-code{color:#616070;text-align:left;padding-inline:16px;font-family:Roboto;font-size:10px;font-weight:400;line-height:14px;position:absolute;top:246px}.card__price{justify-content:space-between;width:166px;padding-inline:16px;display:flex;position:absolute;top:316px}.card__price-text{color:#616070;font-family:Roboto;font-size:12px;font-weight:400;line-height:18px}.card__price-price{font-family:Roboto;font-size:16px;font-weight:700;line-height:18px}.card__button{padding-inline:16px;display:flex}.card__buy{color:#fff;text-align:center;text-transform:uppercase;background-color:#00acdc;border-radius:5px;align-content:center;width:166px;height:40px;font-family:Roboto;font-size:14px;font-weight:700;line-height:16px;position:absolute;top:350px}.card__buy:hover{cursor:pointer;box-sizing:border-box;color:#00acdc;background-color:#fff;border:1px solid #00acdc;border-radius:5px}.stars{justify-content:space-between;width:166px;padding-inline:16px;display:flex;position:absolute;top:276px}.stars__stars-box{width:96px;display:flex}.stars__star{background-image:url(star.822d561e.svg);background-position:50%;background-repeat:no-repeat;width:16px;height:16px;margin-left:4px}.stars__star:first-child{margin-left:0}.stars__star:nth-child(-n+4){background-image:url(star-active.edda4c43.svg)}.stars__reviews{font-family:Roboto;font-size:10px;font-weight:400;line-height:14px} +/*# sourceMappingURL=index.25f883ac.css.map */ diff --git a/index.25f883ac.css.map b/index.25f883ac.css.map new file mode 100644 index 0000000000..d212e366ce --- /dev/null +++ b/index.25f883ac.css.map @@ -0,0 +1 @@ +{"mappings":"ACAA,kECAA,eAGE,wQCFA,+IAYA,qKAYA,oHASA,mGAQA,sFAOA,+CAKA,wPAiBE,qICvEJ,8GAQE,0CAKA,iKASA,uCAIA,6FAIA","sources":["index.25f883ac.css","src/styles/blocks/page.scss","src/styles/blocks/body.scss","src/styles/blocks/card.scss","src/styles/blocks/stars.scss"],"sourcesContent":[".page {\n color: #060b35;\n font-family: Roboto, sans-serif;\n font-weight: 400;\n}\n\n.body {\n margin: 0;\n}\n\n.body__card {\n box-sizing: border-box;\n background-image: url(\"imac.202c52ff.jpeg\");\n background-position: 19px 32px;\n background-repeat: no-repeat;\n background-size: 160px 134px;\n border: 1px solid #f3f3f3;\n border-radius: 5px;\n width: 200px;\n height: 406px;\n position: relative;\n}\n\n.card__text {\n text-align: left;\n padding-inline: 16px;\n font-family: Roboto;\n font-size: 12px;\n font-weight: 500;\n line-height: 18px;\n position: absolute;\n top: 206px;\n}\n\n.card__product-code {\n color: #616070;\n text-align: left;\n padding-inline: 16px;\n font-family: Roboto;\n font-size: 10px;\n font-weight: 400;\n line-height: 14px;\n position: absolute;\n top: 246px;\n}\n\n.card__price {\n justify-content: space-between;\n width: 166px;\n padding-inline: 16px;\n display: flex;\n position: absolute;\n top: 316px;\n}\n\n.card__price-text {\n color: #616070;\n font-family: Roboto;\n font-size: 12px;\n font-weight: 400;\n line-height: 18px;\n}\n\n.card__price-price {\n font-family: Roboto;\n font-size: 16px;\n font-weight: 700;\n line-height: 18px;\n}\n\n.card__button {\n padding-inline: 16px;\n display: flex;\n}\n\n.card__buy {\n color: #fff;\n text-align: center;\n text-transform: uppercase;\n background-color: #00acdc;\n border-radius: 5px;\n align-content: center;\n width: 166px;\n height: 40px;\n font-family: Roboto;\n font-size: 14px;\n font-weight: 700;\n line-height: 16px;\n position: absolute;\n top: 350px;\n}\n\n.card__buy:hover {\n cursor: pointer;\n box-sizing: border-box;\n color: #00acdc;\n background-color: #fff;\n border: 1px solid #00acdc;\n border-radius: 5px;\n}\n\n.stars {\n justify-content: space-between;\n width: 166px;\n padding-inline: 16px;\n display: flex;\n position: absolute;\n top: 276px;\n}\n\n.stars__stars-box {\n width: 96px;\n display: flex;\n}\n\n.stars__star {\n background-image: url(\"star.822d561e.svg\");\n background-position: center;\n background-repeat: no-repeat;\n width: 16px;\n height: 16px;\n margin-left: 4px;\n}\n\n.stars__star:first-child {\n margin-left: 0;\n}\n\n.stars__star:nth-child(-n+4) {\n background-image: url(\"star-active.edda4c43.svg\");\n}\n\n.stars__reviews {\n font-family: Roboto;\n font-size: 10px;\n font-weight: 400;\n line-height: 14px;\n}\n/*# sourceMappingURL=index.25f883ac.css.map */\n",".page {\n font-family: 'Roboto', sans-serif;\n font-weight: 400;\n color: #060b35;\n}\n",".body {\n margin: 0;\n\n &__card {\n box-sizing: border-box;\n width: 200px;\n height: 406px;\n border-radius: 5px;\n border: 1px solid #f3f3f3;\n position: relative;\n\n background-image: url(../images/imac.jpeg);\n background-size: 160px 134px;\n background-repeat: no-repeat;\n background-position-x: 19px;\n background-position-y: 32px;\n }\n}\n",".card {\n &__text {\n padding-inline: 16px;\n font-family: Roboto;\n font-size: 12px;\n font-weight: 500;\n line-height: 18px;\n text-align: left;\n\n position: absolute;\n top: 206px;\n }\n\n &__product-code {\n padding-inline: 16px;\n position: absolute;\n top: 246px;\n color: #616070;\n font-family: Roboto;\n font-size: 10px;\n font-weight: 400;\n line-height: 14px;\n text-align: left;\n }\n\n &__price {\n padding-inline: 16px;\n width: 166px;\n position: absolute;\n top: 316px;\n display: flex;\n justify-content: space-between;\n }\n\n &__price-text {\n font-family: Roboto;\n font-size: 12px;\n font-weight: 400;\n line-height: 18px;\n color: #616070;\n }\n\n &__price-price {\n font-family: Roboto;\n font-size: 16px;\n font-weight: 700;\n line-height: 18px;\n }\n\n &__button {\n padding-inline: 16px;\n display: flex;\n }\n\n &__buy {\n color: #fff;\n font-family: Roboto;\n font-size: 14px;\n font-weight: 700;\n line-height: 16px;\n text-align: center;\n\n position: absolute;\n top: 350px;\n text-transform: uppercase;\n background-color: #00acdc;\n width: 166px;\n height: 40px;\n border-radius: 5px;\n align-content: center;\n\n &:hover {\n cursor: pointer;\n box-sizing: border-box;\n border-radius: 5px;\n color: #00acdc;\n border: 1px solid #00acdc;\n background-color: #fff;\n }\n }\n}\n",".stars {\n padding-inline: 16px;\n display: flex;\n justify-content: space-between;\n position: absolute;\n top: 276px;\n width: 166px;\n\n &__stars-box {\n display: flex;\n width: 96px;\n }\n\n &__star {\n width: 16px;\n height: 16px;\n background-image: url(../images/star.svg);\n background-repeat: no-repeat;\n background-position: center;\n margin-left: 4px;\n }\n\n &__star:first-child {\n margin-left: 0;\n }\n\n &__star:nth-child(-n + 4) {\n background-image: url(../images/star-active.svg);\n }\n\n &__reviews {\n font-family: Roboto;\n font-size: 10px;\n font-weight: 400;\n line-height: 14px;\n }\n}\n"],"names":[],"version":3,"file":"index.25f883ac.css.map"} \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000000..6afb6b84d2 --- /dev/null +++ b/index.html @@ -0,0 +1 @@ +Product cards
APPLE A1419 iMac 27" Retina 5K Monoblock (MNED2UA/A)
Product code: 195434
Reviews: 5
Price:
$2,199
Buy
\ No newline at end of file diff --git a/report/bitmaps_reference/Card_with_data-qa_card.png b/report/bitmaps_reference/Card_with_data-qa_card.png new file mode 100644 index 0000000000..fd6ab58eca Binary files /dev/null and b/report/bitmaps_reference/Card_with_data-qa_card.png differ diff --git a/report/bitmaps_reference/Link_with_data-qa_hover.png b/report/bitmaps_reference/Link_with_data-qa_hover.png new file mode 100644 index 0000000000..958c84442f Binary files /dev/null and b/report/bitmaps_reference/Link_with_data-qa_hover.png differ diff --git a/report/bitmaps_test/20241202-194543/Card_with_data-qa_card.png b/report/bitmaps_test/20241202-194543/Card_with_data-qa_card.png new file mode 100644 index 0000000000..e866260bda Binary files /dev/null and b/report/bitmaps_test/20241202-194543/Card_with_data-qa_card.png differ diff --git a/report/bitmaps_test/20241202-194543/Link_with_data-qa_hover.png b/report/bitmaps_test/20241202-194543/Link_with_data-qa_hover.png new file mode 100644 index 0000000000..ae8df5e590 Binary files /dev/null and b/report/bitmaps_test/20241202-194543/Link_with_data-qa_hover.png differ diff --git a/report/bitmaps_test/20241202-194543/failed_diff_Card_with_data-qa_card.png b/report/bitmaps_test/20241202-194543/failed_diff_Card_with_data-qa_card.png new file mode 100644 index 0000000000..8efd29e859 Binary files /dev/null and b/report/bitmaps_test/20241202-194543/failed_diff_Card_with_data-qa_card.png differ diff --git a/report/bitmaps_test/20241202-194543/failed_diff_Link_with_data-qa_hover.png b/report/bitmaps_test/20241202-194543/failed_diff_Link_with_data-qa_hover.png new file mode 100644 index 0000000000..779e1b7452 Binary files /dev/null and b/report/bitmaps_test/20241202-194543/failed_diff_Link_with_data-qa_hover.png differ diff --git a/report/bitmaps_test/20241202-194543/report.json b/report/bitmaps_test/20241202-194543/report.json new file mode 100644 index 0000000000..b8cc249a1a --- /dev/null +++ b/report/bitmaps_test/20241202-194543/report.json @@ -0,0 +1,59 @@ +{ + "testSuite": "BackstopJS", + "tests": [ + { + "pair": { + "reference": "../bitmaps_reference/Card_with_data-qa_card.png", + "test": "../bitmaps_test/20241202-194543/Card_with_data-qa_card.png", + "selector": "[data-qa=\"card\"]", + "fileName": "Card_with_data-qa_card.png", + "label": "Card with data-qa_card", + "requireSameDimensions": false, + "misMatchThreshold": 1, + "url": "http://localhost:3001/index.html", + "referenceUrl": "https://mate-academy.github.io/layout_solutions/product-cards/", + "expect": 0, + "viewportLabel": "tablet_h", + "diff": { + "isSameDimensions": false, + "dimensionDifference": { + "width": 0, + "height": 2 + }, + "rawMisMatchPercentage": 3.713235294117647, + "misMatchPercentage": "3.71", + "analysisTime": 8 + }, + "diffImage": "../bitmaps_test/20241202-194543/failed_diff_Card_with_data-qa_card.png" + }, + "status": "fail" + }, + { + "pair": { + "reference": "../bitmaps_reference/Link_with_data-qa_hover.png", + "test": "../bitmaps_test/20241202-194543/Link_with_data-qa_hover.png", + "selector": "[data-qa=\"card\"]", + "fileName": "Link_with_data-qa_hover.png", + "label": "Link with data-qa_hover", + "requireSameDimensions": false, + "misMatchThreshold": 1, + "url": "http://localhost:3001/index.html", + "referenceUrl": "https://mate-academy.github.io/layout_solutions/product-cards/", + "expect": 0, + "viewportLabel": "tablet_h", + "diff": { + "isSameDimensions": false, + "dimensionDifference": { + "width": 0, + "height": 2 + }, + "rawMisMatchPercentage": 3.698529411764706, + "misMatchPercentage": "3.70", + "analysisTime": 8 + }, + "diffImage": "../bitmaps_test/20241202-194543/failed_diff_Link_with_data-qa_hover.png" + }, + "status": "fail" + } + ] +} \ No newline at end of file diff --git a/report/engine_scripts/cookies.json b/report/engine_scripts/cookies.json new file mode 100644 index 0000000000..b59400d7e6 --- /dev/null +++ b/report/engine_scripts/cookies.json @@ -0,0 +1,14 @@ +[ + { + "domain": ".www.yourdomain.com", + "path": "/", + "name": "yourCookieName", + "value": "yourCookieValue", + "expirationDate": 1798790400, + "hostOnly": false, + "httpOnly": false, + "secure": false, + "session": false, + "sameSite": "no_restriction" + } +] diff --git a/report/engine_scripts/puppet/clickAndHoverHelper.js b/report/engine_scripts/puppet/clickAndHoverHelper.js new file mode 100644 index 0000000000..6c1e1b8841 --- /dev/null +++ b/report/engine_scripts/puppet/clickAndHoverHelper.js @@ -0,0 +1,39 @@ +module.exports = async (page, scenario) => { + var hoverSelector = scenario.hoverSelectors || scenario.hoverSelector; + var clickSelector = scenario.clickSelectors || scenario.clickSelector; + var keyPressSelector = scenario.keyPressSelectors || scenario.keyPressSelector; + var scrollToSelector = scenario.scrollToSelector; + var postInteractionWait = scenario.postInteractionWait; // selector [str] | ms [int] + + if (keyPressSelector) { + for (const keyPressSelectorItem of [].concat(keyPressSelector)) { + await page.waitForSelector(keyPressSelectorItem.selector); + await page.type(keyPressSelectorItem.selector, keyPressSelectorItem.keyPress); + } + } + + if (hoverSelector) { + for (const hoverSelectorIndex of [].concat(hoverSelector)) { + await page.waitForSelector(hoverSelectorIndex); + await page.hover(hoverSelectorIndex); + } + } + + if (clickSelector) { + for (const clickSelectorIndex of [].concat(clickSelector)) { + await page.waitForSelector(clickSelectorIndex); + await page.click(clickSelectorIndex); + } + } + + if (postInteractionWait) { + await new Promise(resolve => setTimeout(resolve, postInteractionWait)); + } + + if (scrollToSelector) { + await page.waitForSelector(scrollToSelector); + await page.evaluate(scrollToSelector => { + document.querySelector(scrollToSelector).scrollIntoView(); + }, scrollToSelector); + } +}; diff --git a/report/engine_scripts/puppet/loadCookies.js b/report/engine_scripts/puppet/loadCookies.js new file mode 100644 index 0000000000..db848a7cc7 --- /dev/null +++ b/report/engine_scripts/puppet/loadCookies.js @@ -0,0 +1,29 @@ +var fs = require('fs'); + +module.exports = async (page, scenario) => { + var cookies = []; + var cookiePath = scenario.cookiePath; + + // READ COOKIES FROM FILE IF EXISTS + if (fs.existsSync(cookiePath)) { + cookies = JSON.parse(fs.readFileSync(cookiePath)); + } + + // MUNGE COOKIE DOMAIN + cookies = cookies.map(cookie => { + cookie.url = 'https://' + cookie.domain; + delete cookie.domain; + return cookie; + }); + + // SET COOKIES + const setCookies = async () => { + return Promise.all( + cookies.map(async (cookie) => { + await page.setCookie(cookie); + }) + ); + }; + await setCookies(); + console.log('Cookie state restored with:', JSON.stringify(cookies, null, 2)); +}; diff --git a/report/engine_scripts/puppet/onBefore.js b/report/engine_scripts/puppet/onBefore.js new file mode 100644 index 0000000000..a1c374c371 --- /dev/null +++ b/report/engine_scripts/puppet/onBefore.js @@ -0,0 +1,3 @@ +module.exports = async (page, scenario, vp) => { + await require('./loadCookies')(page, scenario); +}; diff --git a/report/engine_scripts/puppet/onReady.js b/report/engine_scripts/puppet/onReady.js new file mode 100644 index 0000000000..517c0e41b6 --- /dev/null +++ b/report/engine_scripts/puppet/onReady.js @@ -0,0 +1,6 @@ +module.exports = async (page, scenario, vp) => { + console.log('SCENARIO > ' + scenario.label); + await require('./clickAndHoverHelper')(page, scenario); + + // add more ready handlers here... +}; diff --git a/report/html_report/a96f14595379b7c348d66e115ec65a93.png b/report/html_report/a96f14595379b7c348d66e115ec65a93.png new file mode 100644 index 0000000000..3c5adc37b2 Binary files /dev/null and b/report/html_report/a96f14595379b7c348d66e115ec65a93.png differ diff --git a/report/html_report/assets/fonts/Lato-Bold.ttf b/report/html_report/assets/fonts/Lato-Bold.ttf new file mode 100755 index 0000000000..74343694e2 Binary files /dev/null and b/report/html_report/assets/fonts/Lato-Bold.ttf differ diff --git a/report/html_report/assets/fonts/Lato-Regular.ttf b/report/html_report/assets/fonts/Lato-Regular.ttf new file mode 100755 index 0000000000..04ea8efb13 Binary files /dev/null and b/report/html_report/assets/fonts/Lato-Regular.ttf differ diff --git a/report/html_report/assets/fonts/lato-bold-webfont.woff b/report/html_report/assets/fonts/lato-bold-webfont.woff new file mode 100755 index 0000000000..d02221df5b Binary files /dev/null and b/report/html_report/assets/fonts/lato-bold-webfont.woff differ diff --git a/report/html_report/assets/fonts/lato-bold-webfont.woff2 b/report/html_report/assets/fonts/lato-bold-webfont.woff2 new file mode 100755 index 0000000000..d330650bc3 Binary files /dev/null and b/report/html_report/assets/fonts/lato-bold-webfont.woff2 differ diff --git a/report/html_report/assets/fonts/lato-regular-webfont.woff b/report/html_report/assets/fonts/lato-regular-webfont.woff new file mode 100755 index 0000000000..af2064a175 Binary files /dev/null and b/report/html_report/assets/fonts/lato-regular-webfont.woff differ diff --git a/report/html_report/assets/fonts/lato-regular-webfont.woff2 b/report/html_report/assets/fonts/lato-regular-webfont.woff2 new file mode 100755 index 0000000000..0e58138a07 Binary files /dev/null and b/report/html_report/assets/fonts/lato-regular-webfont.woff2 differ diff --git a/report/html_report/b815e28b1e230cff6e9d7b749edcd562.png b/report/html_report/b815e28b1e230cff6e9d7b749edcd562.png new file mode 100644 index 0000000000..3c5adc37b2 Binary files /dev/null and b/report/html_report/b815e28b1e230cff6e9d7b749edcd562.png differ diff --git a/report/html_report/config.js b/report/html_report/config.js new file mode 100644 index 0000000000..2bc7f211c3 --- /dev/null +++ b/report/html_report/config.js @@ -0,0 +1,59 @@ +report({ + "testSuite": "BackstopJS", + "tests": [ + { + "pair": { + "reference": "../bitmaps_reference/Card_with_data-qa_card.png", + "test": "../bitmaps_test/20241202-194543/Card_with_data-qa_card.png", + "selector": "[data-qa=\"card\"]", + "fileName": "Card_with_data-qa_card.png", + "label": "Card with data-qa_card", + "requireSameDimensions": false, + "misMatchThreshold": 1, + "url": "http://localhost:3001/index.html", + "referenceUrl": "https://mate-academy.github.io/layout_solutions/product-cards/", + "expect": 0, + "viewportLabel": "tablet_h", + "diff": { + "isSameDimensions": false, + "dimensionDifference": { + "width": 0, + "height": 2 + }, + "rawMisMatchPercentage": 3.713235294117647, + "misMatchPercentage": "3.71", + "analysisTime": 8 + }, + "diffImage": "../bitmaps_test/20241202-194543/failed_diff_Card_with_data-qa_card.png" + }, + "status": "fail" + }, + { + "pair": { + "reference": "../bitmaps_reference/Link_with_data-qa_hover.png", + "test": "../bitmaps_test/20241202-194543/Link_with_data-qa_hover.png", + "selector": "[data-qa=\"card\"]", + "fileName": "Link_with_data-qa_hover.png", + "label": "Link with data-qa_hover", + "requireSameDimensions": false, + "misMatchThreshold": 1, + "url": "http://localhost:3001/index.html", + "referenceUrl": "https://mate-academy.github.io/layout_solutions/product-cards/", + "expect": 0, + "viewportLabel": "tablet_h", + "diff": { + "isSameDimensions": false, + "dimensionDifference": { + "width": 0, + "height": 2 + }, + "rawMisMatchPercentage": 3.698529411764706, + "misMatchPercentage": "3.70", + "analysisTime": 8 + }, + "diffImage": "../bitmaps_test/20241202-194543/failed_diff_Link_with_data-qa_hover.png" + }, + "status": "fail" + } + ] +}); \ No newline at end of file diff --git a/report/html_report/diff.js b/report/html_report/diff.js new file mode 100644 index 0000000000..0b824f1237 --- /dev/null +++ b/report/html_report/diff.js @@ -0,0 +1,1843 @@ +/*! + + diff v3.5.0 + +Software License Agreement (BSD License) + +Copyright (c) 2009-2015, Kevin Decker + +All rights reserved. + +Redistribution and use of this software in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of Kevin Decker nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@license +*/ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else if(typeof exports === 'object') + exports["JsDiff"] = factory(); + else + root["JsDiff"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.merge = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.diffArrays = exports.diffJson = exports.diffCss = exports.diffSentences = exports.diffTrimmedLines = exports.diffLines = exports.diffWordsWithSpace = exports.diffWords = exports.diffChars = exports.Diff = undefined; + + /*istanbul ignore end*/var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_character = __webpack_require__(2) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_word = __webpack_require__(3) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_sentence = __webpack_require__(6) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_css = __webpack_require__(7) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_json = __webpack_require__(8) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(9) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_apply = __webpack_require__(10) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_merge = __webpack_require__(13) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_dmp = __webpack_require__(16) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_xml = __webpack_require__(17) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /* See LICENSE file for terms of use */ + + /* + * Text diff implementation. + * + * This library supports the following APIS: + * JsDiff.diffChars: Character by character diff + * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace + * JsDiff.diffLines: Line based diff + * + * JsDiff.diffCss: Diff targeted at CSS content + * + * These methods are based on the implementation proposed in + * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986). + * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927 + */ + exports. /*istanbul ignore end*/Diff = _base2['default']; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffChars = _character.diffChars; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWords = _word.diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = _word.diffWordsWithSpace; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffLines = _line.diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = _line.diffTrimmedLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffSentences = _sentence.diffSentences; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffCss = _css.diffCss; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffJson = _json.diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffArrays = _array.diffArrays; + /*istanbul ignore start*/exports. /*istanbul ignore end*/structuredPatch = _create.structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = _create.createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = _create.createPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatch = _apply.applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = _apply.applyPatches; + /*istanbul ignore start*/exports. /*istanbul ignore end*/parsePatch = _parse.parsePatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = _merge.merge; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToDMP = _dmp.convertChangesToDMP; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToXML = _xml.convertChangesToXML; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = _json.canonicalize; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports['default'] = /*istanbul ignore end*/Diff; + function Diff() {} + + Diff.prototype = { + /*istanbul ignore start*/ /*istanbul ignore end*/diff: function diff(oldString, newString) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + var callback = options.callback; + if (typeof options === 'function') { + callback = options; + options = {}; + } + this.options = options; + + var self = this; + + function done(value) { + if (callback) { + setTimeout(function () { + callback(undefined, value); + }, 0); + return true; + } else { + return value; + } + } + + // Allow subclasses to massage the input prior to running + oldString = this.castInput(oldString); + newString = this.castInput(newString); + + oldString = this.removeEmpty(this.tokenize(oldString)); + newString = this.removeEmpty(this.tokenize(newString)); + + var newLen = newString.length, + oldLen = oldString.length; + var editLength = 1; + var maxEditLength = newLen + oldLen; + var bestPath = [{ newPos: -1, components: [] }]; + + // Seed editLength = 0, i.e. the content starts with the same values + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + // Identity per the equality and tokenizer + return done([{ value: this.join(newString), count: newString.length }]); + } + + // Main worker method. checks all permutations of a given edit length for acceptance. + function execEditLength() { + for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + var basePath = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + var addPath = bestPath[diagonalPath - 1], + removePath = bestPath[diagonalPath + 1], + _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + // No one else is going to attempt to use this value, clear it + bestPath[diagonalPath - 1] = undefined; + } + + var canAdd = addPath && addPath.newPos + 1 < newLen, + canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + if (!canAdd && !canRemove) { + // If this path is a terminal then prune + bestPath[diagonalPath] = undefined; + continue; + } + + // Select the diagonal that we want to branch from. We select the prior + // path whose position in the new string is the farthest from the origin + // and does not pass the bounds of the diff graph + if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { + basePath = clonePath(removePath); + self.pushComponent(basePath.components, undefined, true); + } else { + basePath = addPath; // No need to clone, we've pulled it from the list + basePath.newPos++; + self.pushComponent(basePath.components, true, undefined); + } + + _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); + + // If we have hit the end of both strings, then we are done + if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { + return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + } else { + // Otherwise track this path as a potential candidate and continue. + bestPath[diagonalPath] = basePath; + } + } + + editLength++; + } + + // Performs the length of edit iteration. Is a bit fugly as this has to support the + // sync and async mode which is never fun. Loops over execEditLength until a value + // is produced. + if (callback) { + (function exec() { + setTimeout(function () { + // This should not happen, but we want to be safe. + /* istanbul ignore next */ + if (editLength > maxEditLength) { + return callback(); + } + + if (!execEditLength()) { + exec(); + } + }, 0); + })(); + } else { + while (editLength <= maxEditLength) { + var ret = execEditLength(); + if (ret) { + return ret; + } + } + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/pushComponent: function pushComponent(components, added, removed) { + var last = components[components.length - 1]; + if (last && last.added === added && last.removed === removed) { + // We need to clone here as the component clone operation is just + // as shallow array clone + components[components.length - 1] = { count: last.count + 1, added: added, removed: removed }; + } else { + components.push({ count: 1, added: added, removed: removed }); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, + oldLen = oldString.length, + newPos = basePath.newPos, + oldPos = newPos - diagonalPath, + commonCount = 0; + while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { + newPos++; + oldPos++; + commonCount++; + } + + if (commonCount) { + basePath.components.push({ count: commonCount }); + } + + basePath.newPos = newPos; + return oldPos; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/equals: function equals(left, right) { + if (this.options.comparator) { + return this.options.comparator(left, right); + } else { + return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/removeEmpty: function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/castInput: function castInput(value) { + return value; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/tokenize: function tokenize(value) { + return value.split(''); + }, + /*istanbul ignore start*/ /*istanbul ignore end*/join: function join(chars) { + return chars.join(''); + } + }; + + function buildValues(diff, components, newString, oldString, useLongestToken) { + var componentPos = 0, + componentLen = components.length, + newPos = 0, + oldPos = 0; + + for (; componentPos < componentLen; componentPos++) { + var component = components[componentPos]; + if (!component.removed) { + if (!component.added && useLongestToken) { + var value = newString.slice(newPos, newPos + component.count); + value = value.map(function (value, i) { + var oldValue = oldString[oldPos + i]; + return oldValue.length > value.length ? oldValue : value; + }); + + component.value = diff.join(value); + } else { + component.value = diff.join(newString.slice(newPos, newPos + component.count)); + } + newPos += component.count; + + // Common case + if (!component.added) { + oldPos += component.count; + } + } else { + component.value = diff.join(oldString.slice(oldPos, oldPos + component.count)); + oldPos += component.count; + + // Reverse add and remove so removes are output first to match common convention + // The diffing algorithm is tied to add then remove output and this is the simplest + // route to get the desired output with minimal overhead. + if (componentPos && components[componentPos - 1].added) { + var tmp = components[componentPos - 1]; + components[componentPos - 1] = components[componentPos]; + components[componentPos] = tmp; + } + } + } + + // Special case handle for when one terminal is ignored (i.e. whitespace). + // For this case we merge the terminal into the prior string and drop the change. + // This is only available for string mode. + var lastComponent = components[componentLen - 1]; + if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { + components[componentLen - 2].value += lastComponent.value; + components.pop(); + } + + return components; + } + + function clonePath(path) { + return { newPos: path.newPos, components: path.components.slice(0) }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":["Diff","prototype","diff","oldString","newString","options","callback","self","done","value","setTimeout","undefined","castInput","removeEmpty","tokenize","newLen","length","oldLen","editLength","maxEditLength","bestPath","newPos","components","oldPos","extractCommon","join","count","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","clonePath","pushComponent","buildValues","useLongestToken","exec","ret","added","removed","last","push","commonCount","equals","left","right","comparator","ignoreCase","toLowerCase","array","i","split","chars","componentPos","componentLen","component","slice","map","oldValue","tmp","lastComponent","pop","path"],"mappings":"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","file":"base.js","sourcesContent":["export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    let bestPath = [{ newPos: -1, components: [] }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (let diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {\n        let basePath;\n        let addPath = bestPath[diagonalPath - 1],\n            removePath = bestPath[diagonalPath + 1],\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n        if (addPath) {\n          // No one else is going to attempt to use this value, clear it\n          bestPath[diagonalPath - 1] = undefined;\n        }\n\n        let canAdd = addPath && addPath.newPos + 1 < newLen,\n            canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\n        // Select the diagonal that we want to branch from. We select the prior\n        // path whose position in the new string is the farthest from the origin\n        // and does not pass the bounds of the diff graph\n        if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n          basePath = clonePath(removePath);\n          self.pushComponent(basePath.components, undefined, true);\n        } else {\n          basePath = addPath;   // No need to clone, we've pulled it from the list\n          basePath.newPos++;\n          self.pushComponent(basePath.components, true, undefined);\n        }\n\n        oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n        // If we have hit the end of both strings, then we are done\n        if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));\n        } else {\n          // Otherwise track this path as a potential candidate and continue.\n          bestPath[diagonalPath] = basePath;\n        }\n      }\n\n      editLength++;\n    }\n\n    // Performs the length of edit iteration. Is a bit fugly as this has to support the\n    // sync and async mode which is never fun. Loops over execEditLength until a value\n    // is produced.\n    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          // This should not happen, but we want to be safe.\n          /* istanbul ignore next */\n          if (editLength > maxEditLength) {\n            return callback();\n          }\n\n          if (!execEditLength()) {\n            exec();\n          }\n        }, 0);\n      }());\n    } else {\n      while (editLength <= maxEditLength) {\n        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  pushComponent(components, added, removed) {\n    let last = components[components.length - 1];\n    if (last && last.added === added && last.removed === removed) {\n      // We need to clone here as the component clone operation is just\n      // as shallow array clone\n      components[components.length - 1] = {count: last.count + 1, added: added, removed: removed };\n    } else {\n      components.push({count: 1, added: added, removed: removed });\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        newPos = basePath.newPos,\n        oldPos = newPos - diagonalPath,\n\n        commonCount = 0;\n    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {\n      newPos++;\n      oldPos++;\n      commonCount++;\n    }\n\n    if (commonCount) {\n      basePath.components.push({count: commonCount});\n    }\n\n    basePath.newPos = newPos;\n    return oldPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  join(chars) {\n    return chars.join('');\n  }\n};\n\nfunction buildValues(diff, components, newString, oldString, useLongestToken) {\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\n      if (!component.added) {\n        oldPos += component.count;\n      }\n    } else {\n      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));\n      oldPos += component.count;\n\n      // Reverse add and remove so removes are output first to match common convention\n      // The diffing algorithm is tied to add then remove output and this is the simplest\n      // route to get the desired output with minimal overhead.\n      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\n  }\n\n  // Special case handle for when one terminal is ignored (i.e. whitespace).\n  // For this case we merge the terminal into the prior string and drop the change.\n  // This is only available for string mode.\n  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof lastComponent.value === 'string'\n      && (lastComponent.added || lastComponent.removed)\n      && diff.equals('', lastComponent.value)) {\n    components[componentLen - 2].value += lastComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n\nfunction clonePath(path) {\n  return { newPos: path.newPos, components: path.components.slice(0) };\n}\n"]} + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.characterDiff = undefined; + exports. /*istanbul ignore end*/diffChars = diffChars; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var characterDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/characterDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + function diffChars(oldStr, newStr, options) { + return characterDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2NoYXJhY3Rlci5qcyJdLCJuYW1lcyI6WyJkaWZmQ2hhcnMiLCJjaGFyYWN0ZXJEaWZmIiwib2xkU3RyIiwibmV3U3RyIiwib3B0aW9ucyIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBR2dCQSxTLEdBQUFBLFM7O0FBSGhCOzs7Ozs7dUJBRU8sSUFBTUMseUZBQWdCLHdFQUF0QjtBQUNBLFNBQVNELFNBQVQsQ0FBbUJFLE1BQW5CLEVBQTJCQyxNQUEzQixFQUFtQ0MsT0FBbkMsRUFBNEM7QUFBRSxTQUFPSCxjQUFjSSxJQUFkLENBQW1CSCxNQUFuQixFQUEyQkMsTUFBM0IsRUFBbUNDLE9BQW5DLENBQVA7QUFBcUQiLCJmaWxlIjoiY2hhcmFjdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IERpZmYgZnJvbSAnLi9iYXNlJztcblxuZXhwb3J0IGNvbnN0IGNoYXJhY3RlckRpZmYgPSBuZXcgRGlmZigpO1xuZXhwb3J0IGZ1bmN0aW9uIGRpZmZDaGFycyhvbGRTdHIsIG5ld1N0ciwgb3B0aW9ucykgeyByZXR1cm4gY2hhcmFjdGVyRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBvcHRpb25zKTsgfVxuIl19 + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.wordDiff = undefined; + exports. /*istanbul ignore end*/diffWords = diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = diffWordsWithSpace; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/ // Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode + // + // Ranges and exceptions: + // Latin-1 Supplement, 0080–00FF + // - U+00D7 × Multiplication sign + // - U+00F7 ÷ Division sign + // Latin Extended-A, 0100–017F + // Latin Extended-B, 0180–024F + // IPA Extensions, 0250–02AF + // Spacing Modifier Letters, 02B0–02FF + // - U+02C7 ˇ ˇ Caron + // - U+02D8 ˘ ˘ Breve + // - U+02D9 ˙ ˙ Dot Above + // - U+02DA ˚ ˚ Ring Above + // - U+02DB ˛ ˛ Ogonek + // - U+02DC ˜ ˜ Small Tilde + // - U+02DD ˝ ˝ Double Acute Accent + // Latin Extended Additional, 1E00–1EFF + var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/; + + var reWhitespace = /\S/; + + var wordDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/wordDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + wordDiff.equals = function (left, right) { + if (this.options.ignoreCase) { + left = left.toLowerCase(); + right = right.toLowerCase(); + } + return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right); + }; + wordDiff.tokenize = function (value) { + var tokens = value.split(/(\s+|\b)/); + + // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set. + for (var i = 0; i < tokens.length - 1; i++) { + // If we have an empty string in the next field and we have only word chars before and after, merge + if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + + return tokens; + }; + + function diffWords(oldStr, newStr, options) { + options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(options, { ignoreWhitespace: true }); + return wordDiff.diff(oldStr, newStr, options); + } + + function diffWordsWithSpace(oldStr, newStr, options) { + return wordDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/generateOptions = generateOptions; + function generateOptions(options, defaults) { + if (typeof options === 'function') { + defaults.callback = options; + } else if (options) { + for (var name in options) { + /* istanbul ignore else */ + if (options.hasOwnProperty(name)) { + defaults[name] = options[name]; + } + } + } + return defaults; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3BhcmFtcy5qcyJdLCJuYW1lcyI6WyJnZW5lcmF0ZU9wdGlvbnMiLCJvcHRpb25zIiwiZGVmYXVsdHMiLCJjYWxsYmFjayIsIm5hbWUiLCJoYXNPd25Qcm9wZXJ0eSJdLCJtYXBwaW5ncyI6Ijs7O2dDQUFnQkEsZSxHQUFBQSxlO0FBQVQsU0FBU0EsZUFBVCxDQUF5QkMsT0FBekIsRUFBa0NDLFFBQWxDLEVBQTRDO0FBQ2pELE1BQUksT0FBT0QsT0FBUCxLQUFtQixVQUF2QixFQUFtQztBQUNqQ0MsYUFBU0MsUUFBVCxHQUFvQkYsT0FBcEI7QUFDRCxHQUZELE1BRU8sSUFBSUEsT0FBSixFQUFhO0FBQ2xCLFNBQUssSUFBSUcsSUFBVCxJQUFpQkgsT0FBakIsRUFBMEI7QUFDeEI7QUFDQSxVQUFJQSxRQUFRSSxjQUFSLENBQXVCRCxJQUF2QixDQUFKLEVBQWtDO0FBQ2hDRixpQkFBU0UsSUFBVCxJQUFpQkgsUUFBUUcsSUFBUixDQUFqQjtBQUNEO0FBQ0Y7QUFDRjtBQUNELFNBQU9GLFFBQVA7QUFDRCIsImZpbGUiOiJwYXJhbXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZ2VuZXJhdGVPcHRpb25zKG9wdGlvbnMsIGRlZmF1bHRzKSB7XG4gIGlmICh0eXBlb2Ygb3B0aW9ucyA9PT0gJ2Z1bmN0aW9uJykge1xuICAgIGRlZmF1bHRzLmNhbGxiYWNrID0gb3B0aW9ucztcbiAgfSBlbHNlIGlmIChvcHRpb25zKSB7XG4gICAgZm9yIChsZXQgbmFtZSBpbiBvcHRpb25zKSB7XG4gICAgICAvKiBpc3RhbmJ1bCBpZ25vcmUgZWxzZSAqL1xuICAgICAgaWYgKG9wdGlvbnMuaGFzT3duUHJvcGVydHkobmFtZSkpIHtcbiAgICAgICAgZGVmYXVsdHNbbmFtZV0gPSBvcHRpb25zW25hbWVdO1xuICAgICAgfVxuICAgIH1cbiAgfVxuICByZXR1cm4gZGVmYXVsdHM7XG59XG4iXX0= + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.lineDiff = undefined; + exports. /*istanbul ignore end*/diffLines = diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = diffTrimmedLines; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var lineDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/lineDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + lineDiff.tokenize = function (value) { + var retLines = [], + linesAndNewlines = value.split(/(\n|\r\n)/); + + // Ignore the final empty token that occurs if the string ends with a new line + if (!linesAndNewlines[linesAndNewlines.length - 1]) { + linesAndNewlines.pop(); + } + + // Merge the content and line separators into single tokens + for (var i = 0; i < linesAndNewlines.length; i++) { + var line = linesAndNewlines[i]; + + if (i % 2 && !this.options.newlineIsToken) { + retLines[retLines.length - 1] += line; + } else { + if (this.options.ignoreWhitespace) { + line = line.trim(); + } + retLines.push(line); + } + } + + return retLines; + }; + + function diffLines(oldStr, newStr, callback) { + return lineDiff.diff(oldStr, newStr, callback); + } + function diffTrimmedLines(oldStr, newStr, callback) { + var options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true }); + return lineDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.sentenceDiff = undefined; + exports. /*istanbul ignore end*/diffSentences = diffSentences; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var sentenceDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/sentenceDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + sentenceDiff.tokenize = function (value) { + return value.split(/(\S.+?[.!?])(?=\s+|$)/); + }; + + function diffSentences(oldStr, newStr, callback) { + return sentenceDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL3NlbnRlbmNlLmpzIl0sIm5hbWVzIjpbImRpZmZTZW50ZW5jZXMiLCJzZW50ZW5jZURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic3BsaXQiLCJvbGRTdHIiLCJuZXdTdHIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBUWdCQSxhLEdBQUFBLGE7O0FBUmhCOzs7Ozs7dUJBR08sSUFBTUMsdUZBQWUsd0VBQXJCO0FBQ1BBLGFBQWFDLFFBQWIsR0FBd0IsVUFBU0MsS0FBVCxFQUFnQjtBQUN0QyxTQUFPQSxNQUFNQyxLQUFOLENBQVksdUJBQVosQ0FBUDtBQUNELENBRkQ7O0FBSU8sU0FBU0osYUFBVCxDQUF1QkssTUFBdkIsRUFBK0JDLE1BQS9CLEVBQXVDQyxRQUF2QyxFQUFpRDtBQUFFLFNBQU9OLGFBQWFPLElBQWIsQ0FBa0JILE1BQWxCLEVBQTBCQyxNQUExQixFQUFrQ0MsUUFBbEMsQ0FBUDtBQUFxRCIsImZpbGUiOiJzZW50ZW5jZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cblxuZXhwb3J0IGNvbnN0IHNlbnRlbmNlRGlmZiA9IG5ldyBEaWZmKCk7XG5zZW50ZW5jZURpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhcXFMuKz9bLiE/XSkoPz1cXHMrfCQpLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZlNlbnRlbmNlcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIHNlbnRlbmNlRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.cssDiff = undefined; + exports. /*istanbul ignore end*/diffCss = diffCss; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var cssDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/cssDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + cssDiff.tokenize = function (value) { + return value.split(/([{}:;,]|\s+)/); + }; + + function diffCss(oldStr, newStr, callback) { + return cssDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2Nzcy5qcyJdLCJuYW1lcyI6WyJkaWZmQ3NzIiwiY3NzRGlmZiIsInRva2VuaXplIiwidmFsdWUiLCJzcGxpdCIsIm9sZFN0ciIsIm5ld1N0ciIsImNhbGxiYWNrIiwiZGlmZiJdLCJtYXBwaW5ncyI6Ijs7OztnQ0FPZ0JBLE8sR0FBQUEsTzs7QUFQaEI7Ozs7Ozt1QkFFTyxJQUFNQyw2RUFBVSx3RUFBaEI7QUFDUEEsUUFBUUMsUUFBUixHQUFtQixVQUFTQyxLQUFULEVBQWdCO0FBQ2pDLFNBQU9BLE1BQU1DLEtBQU4sQ0FBWSxlQUFaLENBQVA7QUFDRCxDQUZEOztBQUlPLFNBQVNKLE9BQVQsQ0FBaUJLLE1BQWpCLEVBQXlCQyxNQUF6QixFQUFpQ0MsUUFBakMsRUFBMkM7QUFBRSxTQUFPTixRQUFRTyxJQUFSLENBQWFILE1BQWIsRUFBcUJDLE1BQXJCLEVBQTZCQyxRQUE3QixDQUFQO0FBQWdEIiwiZmlsZSI6ImNzcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBjc3NEaWZmID0gbmV3IERpZmYoKTtcbmNzc0RpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhbe306OyxdfFxccyspLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkNzcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIGNzc0RpZmYuZGlmZihvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spOyB9XG4iXX0= + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.jsonDiff = undefined; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + exports. /*istanbul ignore end*/diffJson = diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = canonicalize; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var objectPrototypeToString = Object.prototype.toString; + + var jsonDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/jsonDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a + // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output: + jsonDiff.useLongestToken = true; + + jsonDiff.tokenize = /*istanbul ignore start*/_line.lineDiff /*istanbul ignore end*/.tokenize; + jsonDiff.castInput = function (value) { + /*istanbul ignore start*/var _options = /*istanbul ignore end*/this.options, + undefinedReplacement = _options.undefinedReplacement, + _options$stringifyRep = _options.stringifyReplacer, + stringifyReplacer = _options$stringifyRep === undefined ? function (k, v) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/typeof v === 'undefined' ? undefinedReplacement : v + ); + } : _options$stringifyRep; + + + return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' '); + }; + jsonDiff.equals = function (left, right) { + return (/*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')) + ); + }; + + function diffJson(oldObj, newObj, options) { + return jsonDiff.diff(oldObj, newObj, options); + } + + // This function handles the presence of circular references by bailing out when encountering an + // object that is already on the "stack" of items being processed. Accepts an optional replacer + function canonicalize(obj, stack, replacementStack, replacer, key) { + stack = stack || []; + replacementStack = replacementStack || []; + + if (replacer) { + obj = replacer(key, obj); + } + + var i = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + for (i = 0; i < stack.length; i += 1) { + if (stack[i] === obj) { + return replacementStack[i]; + } + } + + var canonicalizedObj = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + if ('[object Array]' === objectPrototypeToString.call(obj)) { + stack.push(obj); + canonicalizedObj = new Array(obj.length); + replacementStack.push(canonicalizedObj); + for (i = 0; i < obj.length; i += 1) { + canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key); + } + stack.pop(); + replacementStack.pop(); + return canonicalizedObj; + } + + if (obj && obj.toJSON) { + obj = obj.toJSON(); + } + + if ( /*istanbul ignore start*/(typeof /*istanbul ignore end*/obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj !== null) { + stack.push(obj); + canonicalizedObj = {}; + replacementStack.push(canonicalizedObj); + var sortedKeys = [], + _key = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (_key in obj) { + /* istanbul ignore else */ + if (obj.hasOwnProperty(_key)) { + sortedKeys.push(_key); + } + } + sortedKeys.sort(); + for (i = 0; i < sortedKeys.length; i += 1) { + _key = sortedKeys[i]; + canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key); + } + stack.pop(); + replacementStack.pop(); + } else { + canonicalizedObj = obj; + } + return canonicalizedObj; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.arrayDiff = undefined; + exports. /*istanbul ignore end*/diffArrays = diffArrays; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var arrayDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + arrayDiff.tokenize = function (value) { + return value.slice(); + }; + arrayDiff.join = arrayDiff.removeEmpty = function (value) { + return value; + }; + + function diffArrays(oldArr, newArr, callback) { + return arrayDiff.diff(oldArr, newArr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2FycmF5LmpzIl0sIm5hbWVzIjpbImRpZmZBcnJheXMiLCJhcnJheURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic2xpY2UiLCJqb2luIiwicmVtb3ZlRW1wdHkiLCJvbGRBcnIiLCJuZXdBcnIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBVWdCQSxVLEdBQUFBLFU7O0FBVmhCOzs7Ozs7dUJBRU8sSUFBTUMsaUZBQVksd0VBQWxCO0FBQ1BBLFVBQVVDLFFBQVYsR0FBcUIsVUFBU0MsS0FBVCxFQUFnQjtBQUNuQyxTQUFPQSxNQUFNQyxLQUFOLEVBQVA7QUFDRCxDQUZEO0FBR0FILFVBQVVJLElBQVYsR0FBaUJKLFVBQVVLLFdBQVYsR0FBd0IsVUFBU0gsS0FBVCxFQUFnQjtBQUN2RCxTQUFPQSxLQUFQO0FBQ0QsQ0FGRDs7QUFJTyxTQUFTSCxVQUFULENBQW9CTyxNQUFwQixFQUE0QkMsTUFBNUIsRUFBb0NDLFFBQXBDLEVBQThDO0FBQUUsU0FBT1IsVUFBVVMsSUFBVixDQUFlSCxNQUFmLEVBQXVCQyxNQUF2QixFQUErQkMsUUFBL0IsQ0FBUDtBQUFrRCIsImZpbGUiOiJhcnJheS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBhcnJheURpZmYgPSBuZXcgRGlmZigpO1xuYXJyYXlEaWZmLnRva2VuaXplID0gZnVuY3Rpb24odmFsdWUpIHtcbiAgcmV0dXJuIHZhbHVlLnNsaWNlKCk7XG59O1xuYXJyYXlEaWZmLmpvaW4gPSBhcnJheURpZmYucmVtb3ZlRW1wdHkgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWU7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkFycmF5cyhvbGRBcnIsIG5ld0FyciwgY2FsbGJhY2spIHsgcmV0dXJuIGFycmF5RGlmZi5kaWZmKG9sZEFyciwgbmV3QXJyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/applyPatch = applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = applyPatches; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_distanceIterator = __webpack_require__(12) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _distanceIterator2 = _interopRequireDefault(_distanceIterator); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/function applyPatch(source, uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + if (Array.isArray(uniDiff)) { + if (uniDiff.length > 1) { + throw new Error('applyPatch only works with a single input.'); + } + + uniDiff = uniDiff[0]; + } + + // Apply the diff to the input + var lines = source.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [], + hunks = uniDiff.hunks, + compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/line === patchContent + ); + }, + errorCount = 0, + fuzzFactor = options.fuzzFactor || 0, + minLine = 0, + offset = 0, + removeEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + addEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + /** + * Checks if the hunk exactly fits on the provided location + */ + function hunkFits(hunk, toPos) { + for (var j = 0; j < hunk.lines.length; j++) { + var line = hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line; + + if (operation === ' ' || operation === '-') { + // Context sanity check + if (!compareLine(toPos + 1, lines[toPos], operation, content)) { + errorCount++; + + if (errorCount > fuzzFactor) { + return false; + } + } + toPos++; + } + } + + return true; + } + + // Search best fit offsets for each hunk based on the previous ones + for (var i = 0; i < hunks.length; i++) { + var hunk = hunks[i], + maxLine = lines.length - hunk.oldLines, + localOffset = 0, + toPos = offset + hunk.oldStart - 1; + + var iterator = /*istanbul ignore start*/(0, _distanceIterator2['default']) /*istanbul ignore end*/(toPos, minLine, maxLine); + + for (; localOffset !== undefined; localOffset = iterator()) { + if (hunkFits(hunk, toPos + localOffset)) { + hunk.offset = offset += localOffset; + break; + } + } + + if (localOffset === undefined) { + return false; + } + + // Set lower text limit to end of the current hunk, so next ones don't try + // to fit over already patched text + minLine = hunk.offset + hunk.oldStart + hunk.oldLines; + } + + // Apply patch hunks + var diffOffset = 0; + for (var _i = 0; _i < hunks.length; _i++) { + var _hunk = hunks[_i], + _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1; + diffOffset += _hunk.newLines - _hunk.oldLines; + + if (_toPos < 0) { + // Creating a new file + _toPos = 0; + } + + for (var j = 0; j < _hunk.lines.length; j++) { + var line = _hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line, + delimiter = _hunk.linedelimiters[j]; + + if (operation === ' ') { + _toPos++; + } else if (operation === '-') { + lines.splice(_toPos, 1); + delimiters.splice(_toPos, 1); + /* istanbul ignore else */ + } else if (operation === '+') { + lines.splice(_toPos, 0, content); + delimiters.splice(_toPos, 0, delimiter); + _toPos++; + } else if (operation === '\\') { + var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null; + if (previousOperation === '+') { + removeEOFNL = true; + } else if (previousOperation === '-') { + addEOFNL = true; + } + } + } + } + + // Handle EOFNL insertion/removal + if (removeEOFNL) { + while (!lines[lines.length - 1]) { + lines.pop(); + delimiters.pop(); + } + } else if (addEOFNL) { + lines.push(''); + delimiters.push('\n'); + } + for (var _k = 0; _k < lines.length - 1; _k++) { + lines[_k] = lines[_k] + delimiters[_k]; + } + return lines.join(''); + } + + // Wrapper that supports multiple file patches via callbacks. + function applyPatches(uniDiff, options) { + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + var currentIndex = 0; + function processIndex() { + var index = uniDiff[currentIndex++]; + if (!index) { + return options.complete(); + } + + options.loadFile(index, function (err, data) { + if (err) { + return options.complete(err); + } + + var updatedContent = applyPatch(data, index, options); + options.patched(index, updatedContent, function (err) { + if (err) { + return options.complete(err); + } + + processIndex(); + }); + }); + } + processIndex(); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":["applyPatch","applyPatches","source","uniDiff","options","Array","isArray","length","Error","lines","split","delimiters","match","hunks","compareLine","lineNumber","line","operation","patchContent","errorCount","fuzzFactor","minLine","offset","removeEOFNL","addEOFNL","hunkFits","hunk","toPos","j","content","substr","i","maxLine","oldLines","localOffset","oldStart","iterator","undefined","diffOffset","newLines","delimiter","linedelimiters","splice","previousOperation","pop","push","_k","join","currentIndex","processIndex","index","complete","loadFile","err","data","updatedContent","patched"],"mappings":"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","file":"apply.js","sourcesContent":["import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  if (Array.isArray(uniDiff)) {\n    if (uniDiff.length > 1) {\n      throw new Error('applyPatch only works with a single input.');\n    }\n\n    uniDiff = uniDiff[0];\n  }\n\n  // Apply the diff to the input\n  let lines = source.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = source.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      hunks = uniDiff.hunks,\n\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line);\n\n      if (operation === ' ' || operation === '-') {\n        // Context sanity check\n        if (!compareLine(toPos + 1, lines[toPos], operation, content)) {\n          errorCount++;\n\n          if (errorCount > fuzzFactor) {\n            return false;\n          }\n        }\n        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let iterator = distanceIterator(toPos, minLine, maxLine);\n\n    for (; localOffset !== undefined; localOffset = iterator()) {\n      if (hunkFits(hunk, toPos + localOffset)) {\n        hunk.offset = offset += localOffset;\n        break;\n      }\n    }\n\n    if (localOffset === undefined) {\n      return false;\n    }\n\n    // Set lower text limit to end of the current hunk, so next ones don't try\n    // to fit over already patched text\n    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    if (toPos < 0) { // Creating a new file\n      toPos = 0;\n    }\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line),\n          delimiter = hunk.linedelimiters[j];\n\n      if (operation === ' ') {\n        toPos++;\n      } else if (operation === '-') {\n        lines.splice(toPos, 1);\n        delimiters.splice(toPos, 1);\n      /* istanbul ignore else */\n      } else if (operation === '+') {\n        lines.splice(toPos, 0, content);\n        delimiters.splice(toPos, 0, delimiter);\n        toPos++;\n      } else if (operation === '\\\\') {\n        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\n  if (removeEOFNL) {\n    while (!lines[lines.length - 1]) {\n      lines.pop();\n      delimiters.pop();\n    }\n  } else if (addEOFNL) {\n    lines.push('');\n    delimiters.push('\\n');\n  }\n  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\n    if (!index) {\n      return options.complete();\n    }\n\n    options.loadFile(index, function(err, data) {\n      if (err) {\n        return options.complete(err);\n      }\n\n      let updatedContent = applyPatch(data, index, options);\n      options.patched(index, updatedContent, function(err) {\n        if (err) {\n          return options.complete(err);\n        }\n\n        processIndex();\n      });\n    });\n  }\n  processIndex();\n}\n"]} + + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/parsePatch = parsePatch; + function parsePatch(uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [], + list = [], + i = 0; + + function parseIndex() { + var index = {}; + list.push(index); + + // Parse diff metadata + while (i < diffstr.length) { + var line = diffstr[i]; + + // File header found, end parsing diff metadata + if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) { + break; + } + + // Diff index + var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line); + if (header) { + index.index = header[1]; + } + + i++; + } + + // Parse file headers if they are defined. Unified diff requires them, but + // there's no technical issues to have an isolated hunk without file header + parseFileHeader(index); + parseFileHeader(index); + + // Parse hunks + index.hunks = []; + + while (i < diffstr.length) { + var _line = diffstr[i]; + + if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) { + break; + } else if (/^@@/.test(_line)) { + index.hunks.push(parseHunk()); + } else if (_line && options.strict) { + // Ignore unexpected content unless in strict mode + throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line)); + } else { + i++; + } + } + } + + // Parses the --- and +++ headers, if none are found, no lines + // are consumed. + function parseFileHeader(index) { + var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]); + if (fileHeader) { + var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new'; + var data = fileHeader[2].split('\t', 2); + var fileName = data[0].replace(/\\\\/g, '\\'); + if (/^".*"$/.test(fileName)) { + fileName = fileName.substr(1, fileName.length - 2); + } + index[keyPrefix + 'FileName'] = fileName; + index[keyPrefix + 'Header'] = (data[1] || '').trim(); + + i++; + } + } + + // Parses a hunk + // This assumes that we are at the start of a hunk. + function parseHunk() { + var chunkHeaderIndex = i, + chunkHeaderLine = diffstr[i++], + chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/); + + var hunk = { + oldStart: +chunkHeader[1], + oldLines: +chunkHeader[2] || 1, + newStart: +chunkHeader[3], + newLines: +chunkHeader[4] || 1, + lines: [], + linedelimiters: [] + }; + + var addCount = 0, + removeCount = 0; + for (; i < diffstr.length; i++) { + // Lines starting with '---' could be mistaken for the "remove line" operation + // But they could be the header for the next file. Therefore prune such cases out. + if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) { + break; + } + var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0]; + + if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') { + hunk.lines.push(diffstr[i]); + hunk.linedelimiters.push(delimiters[i] || '\n'); + + if (operation === '+') { + addCount++; + } else if (operation === '-') { + removeCount++; + } else if (operation === ' ') { + addCount++; + removeCount++; + } + } else { + break; + } + } + + // Handle the empty block count case + if (!addCount && hunk.newLines === 1) { + hunk.newLines = 0; + } + if (!removeCount && hunk.oldLines === 1) { + hunk.oldLines = 0; + } + + // Perform optional sanity checking + if (options.strict) { + if (addCount !== hunk.newLines) { + throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + if (removeCount !== hunk.oldLines) { + throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + } + + return hunk; + } + + while (i < diffstr.length) { + parseIndex(); + } + + return list; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/parse.js"],"names":["parsePatch","uniDiff","options","diffstr","split","delimiters","match","list","i","parseIndex","index","push","length","line","test","header","exec","parseFileHeader","hunks","parseHunk","strict","Error","JSON","stringify","fileHeader","keyPrefix","data","fileName","replace","substr","trim","chunkHeaderIndex","chunkHeaderLine","chunkHeader","hunk","oldStart","oldLines","newStart","newLines","lines","linedelimiters","addCount","removeCount","indexOf","operation"],"mappings":"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","file":"parse.js","sourcesContent":["export function parsePatch(uniDiff, options = {}) {\n  let diffstr = uniDiff.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = uniDiff.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      list = [],\n      i = 0;\n\n  function parseIndex() {\n    let index = {};\n    list.push(index);\n\n    // Parse diff metadata\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      // File header found, end parsing diff metadata\n      if (/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/.test(line)) {\n        break;\n      }\n\n      // Diff index\n      let header = (/^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/).exec(line);\n      if (header) {\n        index.index = header[1];\n      }\n\n      i++;\n    }\n\n    // Parse file headers if they are defined. Unified diff requires them, but\n    // there's no technical issues to have an isolated hunk without file header\n    parseFileHeader(index);\n    parseFileHeader(index);\n\n    // Parse hunks\n    index.hunks = [];\n\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      if (/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/.test(line)) {\n        break;\n      } else if (/^@@/.test(line)) {\n        index.hunks.push(parseHunk());\n      } else if (line && options.strict) {\n        // Ignore unexpected content unless in strict mode\n        throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // Parses the --- and +++ headers, if none are found, no lines\n  // are consumed.\n  function parseFileHeader(index) {\n    const fileHeader = (/^(---|\\+\\+\\+)\\s+(.*)$/).exec(diffstr[i]);\n    if (fileHeader) {\n      let keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n      const data = fileHeader[2].split('\\t', 2);\n      let fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n      if (/^\".*\"$/.test(fileName)) {\n        fileName = fileName.substr(1, fileName.length - 2);\n      }\n      index[keyPrefix + 'FileName'] = fileName;\n      index[keyPrefix + 'Header'] = (data[1] || '').trim();\n\n      i++;\n    }\n  }\n\n  // Parses a hunk\n  // This assumes that we are at the start of a hunk.\n  function parseHunk() {\n    let chunkHeaderIndex = i,\n        chunkHeaderLine = diffstr[i++],\n        chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n\n    let hunk = {\n      oldStart: +chunkHeader[1],\n      oldLines: +chunkHeader[2] || 1,\n      newStart: +chunkHeader[3],\n      newLines: +chunkHeader[4] || 1,\n      lines: [],\n      linedelimiters: []\n    };\n\n    let addCount = 0,\n        removeCount = 0;\n    for (; i < diffstr.length; i++) {\n      // Lines starting with '---' could be mistaken for the \"remove line\" operation\n      // But they could be the header for the next file. Therefore prune such cases out.\n      if (diffstr[i].indexOf('--- ') === 0\n            && (i + 2 < diffstr.length)\n            && diffstr[i + 1].indexOf('+++ ') === 0\n            && diffstr[i + 2].indexOf('@@') === 0) {\n          break;\n      }\n      let operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];\n\n      if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n        hunk.lines.push(diffstr[i]);\n        hunk.linedelimiters.push(delimiters[i] || '\\n');\n\n        if (operation === '+') {\n          addCount++;\n        } else if (operation === '-') {\n          removeCount++;\n        } else if (operation === ' ') {\n          addCount++;\n          removeCount++;\n        }\n      } else {\n        break;\n      }\n    }\n\n    // Handle the empty block count case\n    if (!addCount && hunk.newLines === 1) {\n      hunk.newLines = 0;\n    }\n    if (!removeCount && hunk.oldLines === 1) {\n      hunk.oldLines = 0;\n    }\n\n    // Perform optional sanity checking\n    if (options.strict) {\n      if (addCount !== hunk.newLines) {\n        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n      if (removeCount !== hunk.oldLines) {\n        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n    }\n\n    return hunk;\n  }\n\n  while (i < diffstr.length) {\n    parseIndex();\n  }\n\n  return list;\n}\n"]} + + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + + exports["default"] = /*istanbul ignore end*/function (start, minLine, maxLine) { + var wantForward = true, + backwardExhausted = false, + forwardExhausted = false, + localOffset = 1; + + return function iterator() { + if (wantForward && !forwardExhausted) { + if (backwardExhausted) { + localOffset++; + } else { + wantForward = false; + } + + // Check if trying to fit beyond text length, and if not, check it fits + // after offset location (or desired location on first iteration) + if (start + localOffset <= maxLine) { + return localOffset; + } + + forwardExhausted = true; + } + + if (!backwardExhausted) { + if (!forwardExhausted) { + wantForward = true; + } + + // Check if trying to fit before text beginning, and if not, check it fits + // before offset location + if (minLine <= start - localOffset) { + return -localOffset++; + } + + backwardExhausted = true; + return iterator(); + } + + // We tried to fit hunk before text beginning and beyond text length, then + // hunk can't fit on the text. Return undefined + }; + }; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/calcLineCount = calcLineCount; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = merge; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(15) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function calcLineCount(hunk) { + /*istanbul ignore start*/var _calcOldNewLineCount = /*istanbul ignore end*/calcOldNewLineCount(hunk.lines), + oldLines = _calcOldNewLineCount.oldLines, + newLines = _calcOldNewLineCount.newLines; + + if (oldLines !== undefined) { + hunk.oldLines = oldLines; + } else { + delete hunk.oldLines; + } + + if (newLines !== undefined) { + hunk.newLines = newLines; + } else { + delete hunk.newLines; + } + } + + function merge(mine, theirs, base) { + mine = loadPatch(mine, base); + theirs = loadPatch(theirs, base); + + var ret = {}; + + // For index we just let it pass through as it doesn't have any necessary meaning. + // Leaving sanity checks on this to the API consumer that may know more about the + // meaning in their own context. + if (mine.index || theirs.index) { + ret.index = mine.index || theirs.index; + } + + if (mine.newFileName || theirs.newFileName) { + if (!fileNameChanged(mine)) { + // No header or no change in ours, use theirs (and ours if theirs does not exist) + ret.oldFileName = theirs.oldFileName || mine.oldFileName; + ret.newFileName = theirs.newFileName || mine.newFileName; + ret.oldHeader = theirs.oldHeader || mine.oldHeader; + ret.newHeader = theirs.newHeader || mine.newHeader; + } else if (!fileNameChanged(theirs)) { + // No header or no change in theirs, use ours + ret.oldFileName = mine.oldFileName; + ret.newFileName = mine.newFileName; + ret.oldHeader = mine.oldHeader; + ret.newHeader = mine.newHeader; + } else { + // Both changed... figure it out + ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName); + ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName); + ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader); + ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader); + } + } + + ret.hunks = []; + + var mineIndex = 0, + theirsIndex = 0, + mineOffset = 0, + theirsOffset = 0; + + while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) { + var mineCurrent = mine.hunks[mineIndex] || { oldStart: Infinity }, + theirsCurrent = theirs.hunks[theirsIndex] || { oldStart: Infinity }; + + if (hunkBefore(mineCurrent, theirsCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(mineCurrent, mineOffset)); + mineIndex++; + theirsOffset += mineCurrent.newLines - mineCurrent.oldLines; + } else if (hunkBefore(theirsCurrent, mineCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset)); + theirsIndex++; + mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines; + } else { + // Overlap, merge as best we can + var mergedHunk = { + oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart), + oldLines: 0, + newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset), + newLines: 0, + lines: [] + }; + mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines); + theirsIndex++; + mineIndex++; + + ret.hunks.push(mergedHunk); + } + } + + return ret; + } + + function loadPatch(param, base) { + if (typeof param === 'string') { + if (/^@@/m.test(param) || /^Index:/m.test(param)) { + return (/*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(param)[0] + ); + } + + if (!base) { + throw new Error('Must provide a base reference or pass in a patch'); + } + return (/*istanbul ignore start*/(0, _create.structuredPatch) /*istanbul ignore end*/(undefined, undefined, base, param) + ); + } + + return param; + } + + function fileNameChanged(patch) { + return patch.newFileName && patch.newFileName !== patch.oldFileName; + } + + function selectField(index, mine, theirs) { + if (mine === theirs) { + return mine; + } else { + index.conflict = true; + return { mine: mine, theirs: theirs }; + } + } + + function hunkBefore(test, check) { + return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart; + } + + function cloneHunk(hunk, offset) { + return { + oldStart: hunk.oldStart, oldLines: hunk.oldLines, + newStart: hunk.newStart + offset, newLines: hunk.newLines, + lines: hunk.lines + }; + } + + function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) { + // This will generally result in a conflicted hunk, but there are cases where the context + // is the only overlap where we can successfully merge the content here. + var mine = { offset: mineOffset, lines: mineLines, index: 0 }, + their = { offset: theirOffset, lines: theirLines, index: 0 }; + + // Handle any leading content + insertLeading(hunk, mine, their); + insertLeading(hunk, their, mine); + + // Now in the overlap content. Scan through and select the best changes from each. + while (mine.index < mine.lines.length && their.index < their.lines.length) { + var mineCurrent = mine.lines[mine.index], + theirCurrent = their.lines[their.index]; + + if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) { + // Both modified ... + mutualChange(hunk, mine, their); + } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines; + + /*istanbul ignore end*/ // Mine inserted + /*istanbul ignore start*/(_hunk$lines = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(mine))); + } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines2; + + /*istanbul ignore end*/ // Theirs inserted + /*istanbul ignore start*/(_hunk$lines2 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(their))); + } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') { + // Mine removed or edited + removal(hunk, mine, their); + } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') { + // Their removed or edited + removal(hunk, their, mine, true); + } else if (mineCurrent === theirCurrent) { + // Context identity + hunk.lines.push(mineCurrent); + mine.index++; + their.index++; + } else { + // Context mismatch + conflict(hunk, collectChange(mine), collectChange(their)); + } + } + + // Now push anything that may be remaining + insertTrailing(hunk, mine); + insertTrailing(hunk, their); + + calcLineCount(hunk); + } + + function mutualChange(hunk, mine, their) { + var myChanges = collectChange(mine), + theirChanges = collectChange(their); + + if (allRemoves(myChanges) && allRemoves(theirChanges)) { + // Special case for remove changes that are supersets of one another + if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) { + /*istanbul ignore start*/var _hunk$lines3; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines3 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } else if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) { + /*istanbul ignore start*/var _hunk$lines4; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines4 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines4 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges)); + return; + } + } else if ( /*istanbul ignore start*/(0, _array.arrayEqual) /*istanbul ignore end*/(myChanges, theirChanges)) { + /*istanbul ignore start*/var _hunk$lines5; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines5 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines5 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } + + conflict(hunk, myChanges, theirChanges); + } + + function removal(hunk, mine, their, swap) { + var myChanges = collectChange(mine), + theirChanges = collectContext(their, myChanges); + if (theirChanges.merged) { + /*istanbul ignore start*/var _hunk$lines6; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines6 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines6 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges.merged)); + } else { + conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges); + } + } + + function conflict(hunk, mine, their) { + hunk.conflict = true; + hunk.lines.push({ + conflict: true, + mine: mine, + theirs: their + }); + } + + function insertLeading(hunk, insert, their) { + while (insert.offset < their.offset && insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + insert.offset++; + } + } + function insertTrailing(hunk, insert) { + while (insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + } + } + + function collectChange(state) { + var ret = [], + operation = state.lines[state.index][0]; + while (state.index < state.lines.length) { + var line = state.lines[state.index]; + + // Group additions that are immediately after subtractions and treat them as one "atomic" modify change. + if (operation === '-' && line[0] === '+') { + operation = '+'; + } + + if (operation === line[0]) { + ret.push(line); + state.index++; + } else { + break; + } + } + + return ret; + } + function collectContext(state, matchChanges) { + var changes = [], + merged = [], + matchIndex = 0, + contextChanges = false, + conflicted = false; + while (matchIndex < matchChanges.length && state.index < state.lines.length) { + var change = state.lines[state.index], + match = matchChanges[matchIndex]; + + // Once we've hit our add, then we are done + if (match[0] === '+') { + break; + } + + contextChanges = contextChanges || change[0] !== ' '; + + merged.push(match); + matchIndex++; + + // Consume any additions in the other block as a conflict to attempt + // to pull in the remaining context after this + if (change[0] === '+') { + conflicted = true; + + while (change[0] === '+') { + changes.push(change); + change = state.lines[++state.index]; + } + } + + if (match.substr(1) === change.substr(1)) { + changes.push(change); + state.index++; + } else { + conflicted = true; + } + } + + if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) { + conflicted = true; + } + + if (conflicted) { + return changes; + } + + while (matchIndex < matchChanges.length) { + merged.push(matchChanges[matchIndex++]); + } + + return { + merged: merged, + changes: changes + }; + } + + function allRemoves(changes) { + return changes.reduce(function (prev, change) { + return prev && change[0] === '-'; + }, true); + } + function skipRemoveSuperset(state, removeChanges, delta) { + for (var i = 0; i < delta; i++) { + var changeContent = removeChanges[removeChanges.length - delta + i].substr(1); + if (state.lines[state.index + i] !== ' ' + changeContent) { + return false; + } + } + + state.index += delta; + return true; + } + + function calcOldNewLineCount(lines) { + var oldLines = 0; + var newLines = 0; + + lines.forEach(function (line) { + if (typeof line !== 'string') { + var myCount = calcOldNewLineCount(line.mine); + var theirCount = calcOldNewLineCount(line.theirs); + + if (oldLines !== undefined) { + if (myCount.oldLines === theirCount.oldLines) { + oldLines += myCount.oldLines; + } else { + oldLines = undefined; + } + } + + if (newLines !== undefined) { + if (myCount.newLines === theirCount.newLines) { + newLines += myCount.newLines; + } else { + newLines = undefined; + } + } + } else { + if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) { + newLines++; + } + if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) { + oldLines++; + } + } + }); + + return { oldLines: oldLines, newLines: newLines }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/merge.js"],"names":["calcLineCount","merge","hunk","calcOldNewLineCount","lines","oldLines","newLines","undefined","mine","theirs","base","loadPatch","ret","index","newFileName","fileNameChanged","oldFileName","oldHeader","newHeader","selectField","hunks","mineIndex","theirsIndex","mineOffset","theirsOffset","length","mineCurrent","oldStart","Infinity","theirsCurrent","hunkBefore","push","cloneHunk","mergedHunk","Math","min","newStart","mergeLines","param","test","Error","patch","conflict","check","offset","mineLines","theirOffset","theirLines","their","insertLeading","theirCurrent","mutualChange","collectChange","removal","insertTrailing","myChanges","theirChanges","allRemoves","skipRemoveSuperset","swap","collectContext","merged","insert","line","state","operation","matchChanges","changes","matchIndex","contextChanges","conflicted","change","match","substr","reduce","prev","removeChanges","delta","i","changeContent","forEach","myCount","theirCount"],"mappings":"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","file":"merge.js","sourcesContent":["import {structuredPatch} from './create';\nimport {parsePatch} from './parse';\n\nimport {arrayEqual, arrayStartsWith} from '../util/array';\n\nexport function calcLineCount(hunk) {\n  const {oldLines, newLines} = calcOldNewLineCount(hunk.lines);\n\n  if (oldLines !== undefined) {\n    hunk.oldLines = oldLines;\n  } else {\n    delete hunk.oldLines;\n  }\n\n  if (newLines !== undefined) {\n    hunk.newLines = newLines;\n  } else {\n    delete hunk.newLines;\n  }\n}\n\nexport function merge(mine, theirs, base) {\n  mine = loadPatch(mine, base);\n  theirs = loadPatch(theirs, base);\n\n  let ret = {};\n\n  // For index we just let it pass through as it doesn't have any necessary meaning.\n  // Leaving sanity checks on this to the API consumer that may know more about the\n  // meaning in their own context.\n  if (mine.index || theirs.index) {\n    ret.index = mine.index || theirs.index;\n  }\n\n  if (mine.newFileName || theirs.newFileName) {\n    if (!fileNameChanged(mine)) {\n      // No header or no change in ours, use theirs (and ours if theirs does not exist)\n      ret.oldFileName = theirs.oldFileName || mine.oldFileName;\n      ret.newFileName = theirs.newFileName || mine.newFileName;\n      ret.oldHeader = theirs.oldHeader || mine.oldHeader;\n      ret.newHeader = theirs.newHeader || mine.newHeader;\n    } else if (!fileNameChanged(theirs)) {\n      // No header or no change in theirs, use ours\n      ret.oldFileName = mine.oldFileName;\n      ret.newFileName = mine.newFileName;\n      ret.oldHeader = mine.oldHeader;\n      ret.newHeader = mine.newHeader;\n    } else {\n      // Both changed... figure it out\n      ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);\n      ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);\n      ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);\n      ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);\n    }\n  }\n\n  ret.hunks = [];\n\n  let mineIndex = 0,\n      theirsIndex = 0,\n      mineOffset = 0,\n      theirsOffset = 0;\n\n  while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {\n    let mineCurrent = mine.hunks[mineIndex] || {oldStart: Infinity},\n        theirsCurrent = theirs.hunks[theirsIndex] || {oldStart: Infinity};\n\n    if (hunkBefore(mineCurrent, theirsCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(mineCurrent, mineOffset));\n      mineIndex++;\n      theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;\n    } else if (hunkBefore(theirsCurrent, mineCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));\n      theirsIndex++;\n      mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;\n    } else {\n      // Overlap, merge as best we can\n      let mergedHunk = {\n        oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),\n        oldLines: 0,\n        newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),\n        newLines: 0,\n        lines: []\n      };\n      mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);\n      theirsIndex++;\n      mineIndex++;\n\n      ret.hunks.push(mergedHunk);\n    }\n  }\n\n  return ret;\n}\n\nfunction loadPatch(param, base) {\n  if (typeof param === 'string') {\n    if (/^@@/m.test(param) || (/^Index:/m.test(param))) {\n      return parsePatch(param)[0];\n    }\n\n    if (!base) {\n      throw new Error('Must provide a base reference or pass in a patch');\n    }\n    return structuredPatch(undefined, undefined, base, param);\n  }\n\n  return param;\n}\n\nfunction fileNameChanged(patch) {\n  return patch.newFileName && patch.newFileName !== patch.oldFileName;\n}\n\nfunction selectField(index, mine, theirs) {\n  if (mine === theirs) {\n    return mine;\n  } else {\n    index.conflict = true;\n    return {mine, theirs};\n  }\n}\n\nfunction hunkBefore(test, check) {\n  return test.oldStart < check.oldStart\n    && (test.oldStart + test.oldLines) < check.oldStart;\n}\n\nfunction cloneHunk(hunk, offset) {\n  return {\n    oldStart: hunk.oldStart, oldLines: hunk.oldLines,\n    newStart: hunk.newStart + offset, newLines: hunk.newLines,\n    lines: hunk.lines\n  };\n}\n\nfunction mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {\n  // This will generally result in a conflicted hunk, but there are cases where the context\n  // is the only overlap where we can successfully merge the content here.\n  let mine = {offset: mineOffset, lines: mineLines, index: 0},\n      their = {offset: theirOffset, lines: theirLines, index: 0};\n\n  // Handle any leading content\n  insertLeading(hunk, mine, their);\n  insertLeading(hunk, their, mine);\n\n  // Now in the overlap content. Scan through and select the best changes from each.\n  while (mine.index < mine.lines.length && their.index < their.lines.length) {\n    let mineCurrent = mine.lines[mine.index],\n        theirCurrent = their.lines[their.index];\n\n    if ((mineCurrent[0] === '-' || mineCurrent[0] === '+')\n        && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {\n      // Both modified ...\n      mutualChange(hunk, mine, their);\n    } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {\n      // Mine inserted\n      hunk.lines.push(... collectChange(mine));\n    } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {\n      // Theirs inserted\n      hunk.lines.push(... collectChange(their));\n    } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {\n      // Mine removed or edited\n      removal(hunk, mine, their);\n    } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {\n      // Their removed or edited\n      removal(hunk, their, mine, true);\n    } else if (mineCurrent === theirCurrent) {\n      // Context identity\n      hunk.lines.push(mineCurrent);\n      mine.index++;\n      their.index++;\n    } else {\n      // Context mismatch\n      conflict(hunk, collectChange(mine), collectChange(their));\n    }\n  }\n\n  // Now push anything that may be remaining\n  insertTrailing(hunk, mine);\n  insertTrailing(hunk, their);\n\n  calcLineCount(hunk);\n}\n\nfunction mutualChange(hunk, mine, their) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectChange(their);\n\n  if (allRemoves(myChanges) && allRemoves(theirChanges)) {\n    // Special case for remove changes that are supersets of one another\n    if (arrayStartsWith(myChanges, theirChanges)\n        && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {\n      hunk.lines.push(... myChanges);\n      return;\n    } else if (arrayStartsWith(theirChanges, myChanges)\n        && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {\n      hunk.lines.push(... theirChanges);\n      return;\n    }\n  } else if (arrayEqual(myChanges, theirChanges)) {\n    hunk.lines.push(... myChanges);\n    return;\n  }\n\n  conflict(hunk, myChanges, theirChanges);\n}\n\nfunction removal(hunk, mine, their, swap) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectContext(their, myChanges);\n  if (theirChanges.merged) {\n    hunk.lines.push(... theirChanges.merged);\n  } else {\n    conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);\n  }\n}\n\nfunction conflict(hunk, mine, their) {\n  hunk.conflict = true;\n  hunk.lines.push({\n    conflict: true,\n    mine: mine,\n    theirs: their\n  });\n}\n\nfunction insertLeading(hunk, insert, their) {\n  while (insert.offset < their.offset && insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n    insert.offset++;\n  }\n}\nfunction insertTrailing(hunk, insert) {\n  while (insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n  }\n}\n\nfunction collectChange(state) {\n  let ret = [],\n      operation = state.lines[state.index][0];\n  while (state.index < state.lines.length) {\n    let line = state.lines[state.index];\n\n    // Group additions that are immediately after subtractions and treat them as one \"atomic\" modify change.\n    if (operation === '-' && line[0] === '+') {\n      operation = '+';\n    }\n\n    if (operation === line[0]) {\n      ret.push(line);\n      state.index++;\n    } else {\n      break;\n    }\n  }\n\n  return ret;\n}\nfunction collectContext(state, matchChanges) {\n  let changes = [],\n      merged = [],\n      matchIndex = 0,\n      contextChanges = false,\n      conflicted = false;\n  while (matchIndex < matchChanges.length\n        && state.index < state.lines.length) {\n    let change = state.lines[state.index],\n        match = matchChanges[matchIndex];\n\n    // Once we've hit our add, then we are done\n    if (match[0] === '+') {\n      break;\n    }\n\n    contextChanges = contextChanges || change[0] !== ' ';\n\n    merged.push(match);\n    matchIndex++;\n\n    // Consume any additions in the other block as a conflict to attempt\n    // to pull in the remaining context after this\n    if (change[0] === '+') {\n      conflicted = true;\n\n      while (change[0] === '+') {\n        changes.push(change);\n        change = state.lines[++state.index];\n      }\n    }\n\n    if (match.substr(1) === change.substr(1)) {\n      changes.push(change);\n      state.index++;\n    } else {\n      conflicted = true;\n    }\n  }\n\n  if ((matchChanges[matchIndex] || '')[0] === '+'\n      && contextChanges) {\n    conflicted = true;\n  }\n\n  if (conflicted) {\n    return changes;\n  }\n\n  while (matchIndex < matchChanges.length) {\n    merged.push(matchChanges[matchIndex++]);\n  }\n\n  return {\n    merged,\n    changes\n  };\n}\n\nfunction allRemoves(changes) {\n  return changes.reduce(function(prev, change) {\n    return prev && change[0] === '-';\n  }, true);\n}\nfunction skipRemoveSuperset(state, removeChanges, delta) {\n  for (let i = 0; i < delta; i++) {\n    let changeContent = removeChanges[removeChanges.length - delta + i].substr(1);\n    if (state.lines[state.index + i] !== ' ' + changeContent) {\n      return false;\n    }\n  }\n\n  state.index += delta;\n  return true;\n}\n\nfunction calcOldNewLineCount(lines) {\n  let oldLines = 0;\n  let newLines = 0;\n\n  lines.forEach(function(line) {\n    if (typeof line !== 'string') {\n      let myCount = calcOldNewLineCount(line.mine);\n      let theirCount = calcOldNewLineCount(line.theirs);\n\n      if (oldLines !== undefined) {\n        if (myCount.oldLines === theirCount.oldLines) {\n          oldLines += myCount.oldLines;\n        } else {\n          oldLines = undefined;\n        }\n      }\n\n      if (newLines !== undefined) {\n        if (myCount.newLines === theirCount.newLines) {\n          newLines += myCount.newLines;\n        } else {\n          newLines = undefined;\n        }\n      }\n    } else {\n      if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {\n        newLines++;\n      }\n      if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {\n        oldLines++;\n      }\n    }\n  });\n\n  return {oldLines, newLines};\n}\n"]} + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/structuredPatch = structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = createPatch; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + if (!options) { + options = {}; + } + if (typeof options.context === 'undefined') { + options.context = 4; + } + + var diff = /*istanbul ignore start*/(0, _line.diffLines) /*istanbul ignore end*/(oldStr, newStr, options); + diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier + + function contextLines(lines) { + return lines.map(function (entry) { + return ' ' + entry; + }); + } + + var hunks = []; + var oldRangeStart = 0, + newRangeStart = 0, + curRange = [], + oldLine = 1, + newLine = 1; + + /*istanbul ignore start*/var _loop = function _loop( /*istanbul ignore end*/i) { + var current = diff[i], + lines = current.lines || current.value.replace(/\n$/, '').split('\n'); + current.lines = lines; + + if (current.added || current.removed) { + /*istanbul ignore start*/var _curRange; + + /*istanbul ignore end*/ // If we have previous context, start with that + if (!oldRangeStart) { + var prev = diff[i - 1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + + if (prev) { + curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : []; + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + + // Output our changes + /*istanbul ignore start*/(_curRange = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/lines.map(function (entry) { + return (current.added ? '+' : '-') + entry; + }))); + + // Track the updated file position + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + // Identical context lines. Track line changes + if (oldRangeStart) { + // Close out any changes that have been output (or join overlapping) + if (lines.length <= options.context * 2 && i < diff.length - 2) { + /*istanbul ignore start*/var _curRange2; + + /*istanbul ignore end*/ // Overlapping + /*istanbul ignore start*/(_curRange2 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines))); + } else { + /*istanbul ignore start*/var _curRange3; + + /*istanbul ignore end*/ // end the range and output + var contextSize = Math.min(lines.length, options.context); + /*istanbul ignore start*/(_curRange3 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines.slice(0, contextSize)))); + + var hunk = { + oldStart: oldRangeStart, + oldLines: oldLine - oldRangeStart + contextSize, + newStart: newRangeStart, + newLines: newLine - newRangeStart + contextSize, + lines: curRange + }; + if (i >= diff.length - 2 && lines.length <= options.context) { + // EOF is inside this hunk + var oldEOFNewline = /\n$/.test(oldStr); + var newEOFNewline = /\n$/.test(newStr); + if (lines.length == 0 && !oldEOFNewline) { + // special case: old has no eol and no trailing context; no-nl can end up before adds + curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file'); + } else if (!oldEOFNewline || !newEOFNewline) { + curRange.push('\\ No newline at end of file'); + } + } + hunks.push(hunk); + + oldRangeStart = 0; + newRangeStart = 0; + curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + }; + + for (var i = 0; i < diff.length; i++) { + /*istanbul ignore start*/_loop( /*istanbul ignore end*/i); + } + + return { + oldFileName: oldFileName, newFileName: newFileName, + oldHeader: oldHeader, newHeader: newHeader, + hunks: hunks + }; + } + + function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options); + + var ret = []; + if (oldFileName == newFileName) { + ret.push('Index: ' + oldFileName); + } + ret.push('==================================================================='); + ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader)); + ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader)); + + for (var i = 0; i < diff.hunks.length; i++) { + var hunk = diff.hunks[i]; + ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@'); + ret.push.apply(ret, hunk.lines); + } + + return ret.join('\n') + '\n'; + } + + function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { + return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":["structuredPatch","createTwoFilesPatch","createPatch","oldFileName","newFileName","oldStr","newStr","oldHeader","newHeader","options","context","diff","push","value","lines","contextLines","map","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","i","current","replace","split","added","removed","prev","slice","length","contextSize","Math","min","hunk","oldStart","oldLines","newStart","newLines","oldEOFNewline","test","newEOFNewline","splice","ret","apply","join","fileName"],"mappings":"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","file":"create.js","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const current = diff[i],\n          lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n    current.lines = lines;\n\n    if (current.added || current.removed) {\n      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const prev = diff[i - 1];\n        oldRangeStart = oldLine;\n        newRangeStart = newLine;\n\n        if (prev) {\n          curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];\n          oldRangeStart -= curRange.length;\n          newRangeStart -= curRange.length;\n        }\n      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\n      if (current.added) {\n        newLine += lines.length;\n      } else {\n        oldLine += lines.length;\n      }\n    } else {\n      // Identical context lines. Track line changes\n      if (oldRangeStart) {\n        // Close out any changes that have been output (or join overlapping)\n        if (lines.length <= options.context * 2 && i < diff.length - 2) {\n          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = (/\\n$/.test(oldStr));\n            let newEOFNewline = (/\\n$/.test(newStr));\n            if (lines.length == 0 && !oldEOFNewline) {\n              // special case: old has no eol and no trailing context; no-nl can end up before adds\n              curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n            } else if (!oldEOFNewline || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  const diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n\n  const ret = [];\n  if (oldFileName == newFileName) {\n    ret.push('Index: ' + oldFileName);\n  }\n  ret.push('===================================================================');\n  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\\t' + diff.oldHeader));\n  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\\t' + diff.newHeader));\n\n  for (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]} + + +/***/ }), +/* 15 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/arrayEqual = arrayEqual; + /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayStartsWith = arrayStartsWith; + function arrayEqual(a, b) { + if (a.length !== b.length) { + return false; + } + + return arrayStartsWith(a, b); + } + + function arrayStartsWith(array, start) { + if (start.length > array.length) { + return false; + } + + for (var i = 0; i < start.length; i++) { + if (start[i] !== array[i]) { + return false; + } + } + + return true; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL2FycmF5LmpzIl0sIm5hbWVzIjpbImFycmF5RXF1YWwiLCJhcnJheVN0YXJ0c1dpdGgiLCJhIiwiYiIsImxlbmd0aCIsImFycmF5Iiwic3RhcnQiLCJpIl0sIm1hcHBpbmdzIjoiOzs7Z0NBQWdCQSxVLEdBQUFBLFU7eURBUUFDLGUsR0FBQUEsZTtBQVJULFNBQVNELFVBQVQsQ0FBb0JFLENBQXBCLEVBQXVCQyxDQUF2QixFQUEwQjtBQUMvQixNQUFJRCxFQUFFRSxNQUFGLEtBQWFELEVBQUVDLE1BQW5CLEVBQTJCO0FBQ3pCLFdBQU8sS0FBUDtBQUNEOztBQUVELFNBQU9ILGdCQUFnQkMsQ0FBaEIsRUFBbUJDLENBQW5CLENBQVA7QUFDRDs7QUFFTSxTQUFTRixlQUFULENBQXlCSSxLQUF6QixFQUFnQ0MsS0FBaEMsRUFBdUM7QUFDNUMsTUFBSUEsTUFBTUYsTUFBTixHQUFlQyxNQUFNRCxNQUF6QixFQUFpQztBQUMvQixXQUFPLEtBQVA7QUFDRDs7QUFFRCxPQUFLLElBQUlHLElBQUksQ0FBYixFQUFnQkEsSUFBSUQsTUFBTUYsTUFBMUIsRUFBa0NHLEdBQWxDLEVBQXVDO0FBQ3JDLFFBQUlELE1BQU1DLENBQU4sTUFBYUYsTUFBTUUsQ0FBTixDQUFqQixFQUEyQjtBQUN6QixhQUFPLEtBQVA7QUFDRDtBQUNGOztBQUVELFNBQU8sSUFBUDtBQUNEIiwiZmlsZSI6ImFycmF5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGFycmF5RXF1YWwoYSwgYikge1xuICBpZiAoYS5sZW5ndGggIT09IGIubGVuZ3RoKSB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgcmV0dXJuIGFycmF5U3RhcnRzV2l0aChhLCBiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFycmF5U3RhcnRzV2l0aChhcnJheSwgc3RhcnQpIHtcbiAgaWYgKHN0YXJ0Lmxlbmd0aCA+IGFycmF5Lmxlbmd0aCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIGZvciAobGV0IGkgPSAwOyBpIDwgc3RhcnQubGVuZ3RoOyBpKyspIHtcbiAgICBpZiAoc3RhcnRbaV0gIT09IGFycmF5W2ldKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHRydWU7XG59XG4iXX0= + + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToDMP = convertChangesToDMP; + // See: http://code.google.com/p/google-diff-match-patch/wiki/API + function convertChangesToDMP(changes) { + var ret = [], + change = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + operation = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (var i = 0; i < changes.length; i++) { + change = changes[i]; + if (change.added) { + operation = 1; + } else if (change.removed) { + operation = -1; + } else { + operation = 0; + } + + ret.push([operation, change.value]); + } + return ret; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb252ZXJ0L2RtcC5qcyJdLCJuYW1lcyI6WyJjb252ZXJ0Q2hhbmdlc1RvRE1QIiwiY2hhbmdlcyIsInJldCIsImNoYW5nZSIsIm9wZXJhdGlvbiIsImkiLCJsZW5ndGgiLCJhZGRlZCIsInJlbW92ZWQiLCJwdXNoIiwidmFsdWUiXSwibWFwcGluZ3MiOiI7OztnQ0FDZ0JBLG1CLEdBQUFBLG1CO0FBRGhCO0FBQ08sU0FBU0EsbUJBQVQsQ0FBNkJDLE9BQTdCLEVBQXNDO0FBQzNDLE1BQUlDLE1BQU0sRUFBVjtBQUFBLE1BQ0lDLHdDQURKO0FBQUEsTUFFSUMsMkNBRko7QUFHQSxPQUFLLElBQUlDLElBQUksQ0FBYixFQUFnQkEsSUFBSUosUUFBUUssTUFBNUIsRUFBb0NELEdBQXBDLEVBQXlDO0FBQ3ZDRixhQUFTRixRQUFRSSxDQUFSLENBQVQ7QUFDQSxRQUFJRixPQUFPSSxLQUFYLEVBQWtCO0FBQ2hCSCxrQkFBWSxDQUFaO0FBQ0QsS0FGRCxNQUVPLElBQUlELE9BQU9LLE9BQVgsRUFBb0I7QUFDekJKLGtCQUFZLENBQUMsQ0FBYjtBQUNELEtBRk0sTUFFQTtBQUNMQSxrQkFBWSxDQUFaO0FBQ0Q7O0FBRURGLFFBQUlPLElBQUosQ0FBUyxDQUFDTCxTQUFELEVBQVlELE9BQU9PLEtBQW5CLENBQVQ7QUFDRDtBQUNELFNBQU9SLEdBQVA7QUFDRCIsImZpbGUiOiJkbXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTZWU6IGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9nb29nbGUtZGlmZi1tYXRjaC1wYXRjaC93aWtpL0FQSVxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRDaGFuZ2VzVG9ETVAoY2hhbmdlcykge1xuICBsZXQgcmV0ID0gW10sXG4gICAgICBjaGFuZ2UsXG4gICAgICBvcGVyYXRpb247XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgY2hhbmdlcy5sZW5ndGg7IGkrKykge1xuICAgIGNoYW5nZSA9IGNoYW5nZXNbaV07XG4gICAgaWYgKGNoYW5nZS5hZGRlZCkge1xuICAgICAgb3BlcmF0aW9uID0gMTtcbiAgICB9IGVsc2UgaWYgKGNoYW5nZS5yZW1vdmVkKSB7XG4gICAgICBvcGVyYXRpb24gPSAtMTtcbiAgICB9IGVsc2Uge1xuICAgICAgb3BlcmF0aW9uID0gMDtcbiAgICB9XG5cbiAgICByZXQucHVzaChbb3BlcmF0aW9uLCBjaGFuZ2UudmFsdWVdKTtcbiAgfVxuICByZXR1cm4gcmV0O1xufVxuIl19 + + +/***/ }), +/* 17 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToXML = convertChangesToXML; + function convertChangesToXML(changes) { + var ret = []; + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + + ret.push(escapeHTML(change.value)); + + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + } + return ret.join(''); + } + + function escapeHTML(s) { + var n = s; + n = n.replace(/&/g, '&'); + n = n.replace(//g, '>'); + n = n.replace(/"/g, '"'); + + return n; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }) +/******/ ]) +}); +; \ No newline at end of file diff --git a/report/html_report/diverged.js b/report/html_report/diverged.js new file mode 100644 index 0000000000..b96620eb8e --- /dev/null +++ b/report/html_report/diverged.js @@ -0,0 +1,340 @@ +'use strict'; +const noop = function (){}; +let LCS_DIFF_ARRAY_METHOD = undefined; +// debugger +if (typeof require !== 'undefined') { + LCS_DIFF_ARRAY_METHOD = require('diff').diffArrays; +} else { + try { + LCS_DIFF_ARRAY_METHOD = JsDiff.diffArrays; + } catch(err) { + console.error(err); + } +} + +const rowSpread = 1; + +const spread = 50; // range of adjacent pixels to aggregate when calculating diff +const IS_ADDED_WORD = '0_255_0_255'; +const IS_REMOVED_WORD = '255_0_0_255'; +const IS_ADDED_AND_REMOVED_WORD = '0_255_255_255'; +const IS_SAME_WORD = ''; +const OPACITY = '40'; // 0-255 range + +/** + * Applies Longest-Common-Subsequence-Diff algorithm to imageData formatted arrays + * + * @param {Uint8ClampedArray} [reference] baseline image + * @param {Uint8ClampedArray} [test] test image + * + * @returns {Uint8ClampedArray} diff image + * + */ +if (typeof module !== 'undefined') { + module.exports = diverged; +} + +function diverged(reference, test, h, w) { + console.time("diverged_total_time"); + + const spread = Math.floor(h / 80); //override + + console.log('spread:', spread); + + console.time("imgDataToWords"); + const img1wordArr = imgDataToWords(reference); + const img2wordArr = imgDataToWords(test); + console.timeEnd("imgDataToWords"); + + console.time("imgDataWordArrToColsAndRows"); + let cols_rows_ref = imgDataWordArrToColsAndRows(img1wordArr, h, w); + let cols_rows_test = imgDataWordArrToColsAndRows(img2wordArr, h, w); + console.timeEnd("imgDataWordArrToColsAndRows"); + + console.time("groupAdjacent"); + const columnRef = groupAdjacent(cols_rows_ref.columns, spread, h, w); + const columnTest = groupAdjacent(cols_rows_test.columns, spread, h, w); + console.timeEnd("groupAdjacent"); + + console.time("columnDiffRaw"); + const columnDiffRaw = diffArr(columnRef, columnTest, h, w); + console.timeEnd("columnDiffRaw"); + + console.time("reduceColumnDiffRaw"); + const reducedColumnDiff = reduceColumnDiffRaw(columnDiffRaw, h, w); + console.timeEnd("reduceColumnDiffRaw"); + // console.log("reducedColumnDiff>>>", reducedColumnDiff); + + console.time("unGroupAdjacent"); + const expandedColumns = ungroupAdjacent(reducedColumnDiff, spread, cols_rows_test.columns, h, w); + console.timeEnd("unGroupAdjacent"); + + console.time("columnWordDataToImgDataFormatAsWords"); + const convertedColumnDiffImgData = columnWordDataToImgDataFormatAsWords(expandedColumns, h, w); + console.timeEnd("columnWordDataToImgDataFormatAsWords"); + // console.log("convertedColumnDiffImgData>>>", convertedColumnDiffImgData); + + console.time("imgDataWordsToClampedImgData"); + const imgDataArr = convertImgDataWordsToClampedImgData(convertedColumnDiffImgData); + console.timeEnd("imgDataWordsToClampedImgData"); + // console.log("imgDataArr>>>", imgDataArr); + + console.timeEnd("diverged_total_time"); + return imgDataArr; +} + +/** + * ========= HELPERS ======== + */ + +function columnWordDataToImgDataFormatAsWords(columns, h, w) { + const imgDataWordsLength = w * h; + + let convertedArr = new Array(imgDataWordsLength); + for (var i = 0; i < imgDataWordsLength; i++) { + const {column, depth} = serialToColumnMap(i, h, w); + convertedArr[i] = columns[column][depth]; + } + return convertedArr; +} + +function convertImgDataWordsToClampedImgData(wordsArr) { + let convertedArr = new Uint8ClampedArray(wordsArr.length * 4); + for (var i = 0; i < wordsArr.length; i++) { + const convertedOffset = i * 4; + const segments = wordsArr[i].split('_'); + convertedArr[convertedOffset] = segments[0]; + convertedArr[convertedOffset+1] = segments[1]; + convertedArr[convertedOffset+2] = segments[2]; + convertedArr[convertedOffset+3] = segments[3]; + } + return convertedArr; +} + +function reduceColumnDiffRaw(columnDiffs, h, w) { + let reducedColumns = new Array(columnDiffs.length); + for (let columnIndex = 0; columnIndex < columnDiffs.length; columnIndex++) { + const columnDiff = columnDiffs[columnIndex]; + let resultColumn = new Array(); + let removedCounter = 0; + let resultClass = ''; + let segment = []; + let debug = false; + + for (let depthIndex = 0; depthIndex < columnDiff.length; depthIndex++) { + let segmentLength = 0; + + // Categorize the current segment + if (columnDiff[depthIndex].removed) { + segmentLength = columnDiff[depthIndex].count; + removedCounter += segmentLength; + resultClass = IS_REMOVED_WORD; + } else { + if (columnDiff[depthIndex].added) { + if (removedCounter) { + resultClass = IS_ADDED_AND_REMOVED_WORD; + } else { + resultClass = IS_ADDED_WORD; + } + } else { + resultClass = IS_SAME_WORD; + } + + segmentLength = columnDiff[depthIndex].count; + + if (removedCounter > 0) { + if (segmentLength > removedCounter) { + segmentLength -= removedCounter; + removedCounter = 0; + } else { + removedCounter -= segmentLength; + segmentLength = 0; + } + } + } + + // Limit segmentLength to total length of column + if (!segmentLength) { + continue; + } else { + segmentLength = Math.min(segmentLength, h - resultColumn.length); + } + + const printSampleMap = false; + if (!printSampleMap || resultClass !== IS_SAME_WORD){ + segment = new Array(segmentLength).fill(resultClass); + } else { + // reduced resolution image + segment = columnDiff[depthIndex].value.slice(0,segmentLength).map((value, i) => { + if (/|/.test(value)) { + return value.split('|')[0]; + } + return value; + }); + } + + + resultColumn = resultColumn.concat(segment); + + if (resultColumn.length > h) { + console.log('WARNING -- this value is out of bounds!') + } + } + + reducedColumns[columnIndex] = resultColumn; + } + + return reducedColumns; +} + +function diffArr(refArr, testArr, h, w) { + let rawResultArr = []; + for (let i = 0; i < refArr.length; i++) { + rawResultArr.push(LCS_DIFF_ARRAY_METHOD(refArr[i], testArr[i])); + } + return rawResultArr; +} + +function groupAdjacent(columns, spread, h, w) { + if (!spread) { + return columns; + } + + /** + * [getAdjacentArrayBounds retuns existing adjacent lower and upper column bounds] + * @param {[int]} pointer [current index] + * @param {[int]} spread [distance from index] + * @param {[int]} length [total length] + * @return {[array]} [0] lower bound, [1] upper bound + */ + function getAdjacentArrayBounds(pointer, spread, length) { + return [ + // Math.max(0, pointer - spread), + Math.max(0, pointer), + Math.min(length - 1, pointer + spread) + ] + } + + function getInterpolatedSequence(beginning, end) { + const interpolated = []; + for (let step = beginning; step <= end; step++) { + interpolated.push(step); + } + return interpolated; + } + + function getCompositeColumnDepthValues(columns, sequence, depth) { + return sequence.reduce((acc, column) => { + return acc.concat(columns[column][depth]); + }, []) + } + + function getCompositeRowIndexValues(groupedColumns, sequence, column) { + return sequence.reduce((acc, depth) => { + return acc.concat(groupedColumns[column][depth]); + }, []) + } + + const groupedColumns = new Array(); + let columnPointer = 0; + while (columnPointer < w) { + const adjacentColumnBounds = getAdjacentArrayBounds(columnPointer, spread, w); + const interpolatedColumns = getInterpolatedSequence(...adjacentColumnBounds); + + const columnComposite = new Array(); + for (var depth = 0; depth < h; depth++) { + columnComposite[depth] = getCompositeColumnDepthValues(columns, interpolatedColumns, depth).join('|'); + } + groupedColumns.push(columnComposite); + columnPointer += spread; + } + + const groupedRows = new Array(); + if (rowSpread > 1) { + for (var index = 0; index < groupedColumns.length; index++) { + const rowComposite = new Array(); + let depthPointer = 0; + while (depthPointer < h) { + const adjacentRowBounds = getAdjacentArrayBounds(depthPointer, rowSpread, h); + const interpolatedRows = getInterpolatedSequence(...adjacentRowBounds); + rowComposite.push(getCompositeRowIndexValues(groupedColumns, interpolatedRows, index).join(',')); + depthPointer += rowSpread; + } + groupedRows[index] = rowComposite; + } + } + return groupedRows.length ? groupedRows : groupedColumns ; +} + +function ungroupAdjacent(grouped, spread, columnUnderlay, h, w) { + if (!spread) { + return grouped; + } + + function mapUngroupedColumnIndexToGroupedIndex(index, spread) { + return Math.floor(index / spread); + } + + // expand columns + const ungrouped = new Array(w); + for (let index = 0; index < w; index++) { + if (!ungrouped[index]) { + ungrouped[index] = new Array(h); + } + + const groupedIndexMap = mapUngroupedColumnIndexToGroupedIndex(index, spread); + for (let depth = 0; depth < h; depth++) { + const groupedDepthMap = rowSpread > 1 ? mapUngroupedColumnIndexToGroupedIndex(depth, rowSpread) : depth; + const value = grouped[groupedIndexMap][groupedDepthMap].split('|')[0]; + ungrouped[index][depth] = value ? value : columnUnderlay[index][depth].replace(/\d+$/, OPACITY); + } + } + + return ungrouped +} + + + +function imgDataWordArrToColsAndRows(arr, h, w) { + let columns = new Array(w); + let rows = new Array(h); + + for (var i = 0; i < arr.length; i++) { + const word = arr[i]; + + var {column, depth} = serialToColumnMap(i, h, w); + if (!columns[column]) { + columns[column] = new Array(h); + } + columns[column][depth] = word; + + var {row, index} = serialToRowMap(i, h, w); + if (!rows[row]) { + rows[row] = new Array(w); + } + rows[row][index] = word; + } + return {columns, rows} +} + +function serialToColumnMap(index, h, w) { + return { + column: index % w, + depth: Math.floor(index / w) + } +} + +function serialToRowMap(index, h, w) { + return { + row: Math.floor(index / w), + index: index % w + } +} + +function imgDataToWords(arr) { + let result = []; + for (let i = 0; i < arr.length-1; i += 4) { + result.push(`${arr[i]}_${arr[i+1]}_${arr[i+2]}_${arr[i+3]}`) + } + return result; +} diff --git a/report/html_report/divergedWorker.js b/report/html_report/divergedWorker.js new file mode 100644 index 0000000000..c41d85e54b --- /dev/null +++ b/report/html_report/divergedWorker.js @@ -0,0 +1,6 @@ +importScripts('diff.js'); +importScripts('diverged.js'); +self.addEventListener('message', function(e) { + self.postMessage(diverged(...e.data.divergedInput)); + self.close(); +}, false); diff --git a/report/html_report/index.html b/report/html_report/index.html new file mode 100644 index 0000000000..89badbd4d8 --- /dev/null +++ b/report/html_report/index.html @@ -0,0 +1,49 @@ + + + + + + + + + + BackstopJS Report + + + + +
+ +
+ + + + + diff --git a/report/html_report/index_bundle.js b/report/html_report/index_bundle.js new file mode 100644 index 0000000000..696e1c8f1f --- /dev/null +++ b/report/html_report/index_bundle.js @@ -0,0 +1,2 @@ +/*! For license information please see index_bundle.js.LICENSE.txt */ +(()=>{var e,t,n={184:(e,t,n)=>{"use strict";function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}t.Z=void 0;var o=function(e,t){if(e&&e.__esModule)return e;if(null===e||"object"!=r(e)&&"function"!=typeof e)return{default:e};var n=i(t);if(n&&n.has(e))return n.get(e);var o={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var l in e)if("default"!==l&&Object.prototype.hasOwnProperty.call(e,l)){var u=a?Object.getOwnPropertyDescriptor(e,l):null;u&&(u.get||u.set)?Object.defineProperty(o,l,u):o[l]=e[l]}return o.default=e,n&&n.set(e,o),o}(n(294));function i(e){if("function"!=typeof WeakMap)return null;var t=new WeakMap,n=new WeakMap;return(i=function(e){return e?n:t})(e)}function a(e,t){for(var n=0;n=u)&&Math.abs(d)>l)return void this.endDrag();if(!t)return}var y=this.twentyTwentyComponent.current.getBoundingClientRect(),h=100*(o-y.left)/y.width;h=Math.max(Math.min(h,100),0),this.setState({position:h,isDragging:t})}}},{key:"beginDrag",value:function(e){if(e&&e.preventDefault(),this.props.isDraggingEnabled){var t="touches"in e?e.touches[0]:e,n=t.pageX,r=t.pageY;this.setState({startX:n,startY:r}),document.addEventListener("mousemove",this.onDragMove),document.addEventListener("mouseup",this.endDrag),document.addEventListener("touchmove",this.onDragMove),document.addEventListener("touchend",this.endDrag)}}},{key:"endDrag",value:function(){document.removeEventListener("mousemove",this.onDragMove),document.removeEventListener("mouseup",this.endDrag),document.removeEventListener("touchmove",this.onDragMove),document.removeEventListener("touchend",this.endDrag),this.setState({isDragging:!1,startY:NaN,endY:NaN})}},{key:"render",value:function(){var e=this.state.position,t=this.props,n=t.children,r=t.verticalAlign,i=t.leftHorizontalAlign,a=t.rightHorizontalAlign;return 2!==n.length&&3!==n.length?(console.warn("Expected exactly two or three children"),null):o.default.createElement("div",{ref:this.twentyTwentyComponent,style:{position:"relative",overflow:"hidden",whiteSpace:"nowrap"},onMouseDown:this.beginDrag,onTouchStart:this.beginDrag},o.default.createElement("div",{style:{position:"absolute",left:"".concat(e,"%"),height:"100%",width:0,zIndex:1}},n[2]),o.default.createElement("div",{style:{display:"inline-block",width:"100%",position:"relative",verticalAlign:r,left:"".concat(e-100,"%"),overflow:"hidden"}},o.default.createElement("div",{style:{position:"relative",right:"".concat(e-100,"%"),textAlign:i}},n[0])),o.default.createElement("div",{style:{display:"inline-block",width:"100%",position:"relative",verticalAlign:r,left:"".concat(e-100,"%"),overflow:"hidden"}},o.default.createElement("div",{style:{position:"relative",right:"".concat(e,"%"),textAlign:a}},n[1])))}}])&&a(t.prototype,n),Object.defineProperty(t,"prototype",{writable:!1}),d}(o.Component)).defaultProps={verticalAlign:"middle",leftHorizontalAlign:"center",rightHorizontalAlign:"center",minDistanceToBeginInteraction:15,maxAngleToBeginInteraction:30,initialPosition:50,isDraggingEnabled:!0}},875:(e,t,n)=>{var r;!function(){"use strict";var o=!("undefined"==typeof window||!window.document||!window.document.createElement),i={canUseDOM:o,canUseWorkers:"undefined"!=typeof Worker,canUseEventListeners:o&&!(!window.addEventListener&&!window.attachEvent),canUseViewport:o&&!!window.screen};void 0===(r=function(){return i}.call(t,n,t,e))||(e.exports=r)}()},75:function(e){(function(){var t,n,r,o,i,a;"undefined"!=typeof performance&&null!==performance&&performance.now?e.exports=function(){return performance.now()}:"undefined"!=typeof process&&null!==process&&process.hrtime?(e.exports=function(){return(t()-i)/1e6},n=process.hrtime,o=(t=function(){var e;return 1e9*(e=n())[0]+e[1]})(),a=1e9*process.uptime(),i=o-a):Date.now?(e.exports=function(){return Date.now()-r},r=Date.now()):(e.exports=function(){return(new Date).getTime()-r},r=(new Date).getTime())}).call(this)},703:(e,t,n)=>{"use strict";var r=n(414);function o(){}function i(){}i.resetWarningCache=o,e.exports=function(){function e(e,t,n,o,i,a){if(a!==r){var l=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");throw l.name="Invariant Violation",l}}function t(){return e}e.isRequired=e;var n={array:e,bigint:e,bool:e,func:e,number:e,object:e,string:e,symbol:e,any:e,arrayOf:t,element:e,elementType:e,instanceOf:t,node:e,objectOf:t,oneOf:t,oneOfType:t,shape:t,exact:t,checkPropTypes:i,resetWarningCache:o};return n.PropTypes=n,n}},697:(e,t,n)=>{e.exports=n(703)()},414:e=>{"use strict";e.exports="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"},87:(e,t,n)=>{for(var r=n(75),o="undefined"==typeof window?n.g:window,i=["moz","webkit"],a="AnimationFrame",l=o["request"+a],u=o["cancel"+a]||o["cancelRequest"+a],c=0;!l&&c{"use strict";var r=n(294),o=n(840);function i(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n