☰

WME Utils - Google Link Enhancer

Adds some extra WME functionality related to Google place links.

当前为 2018-04-10 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.cn-greasyfork.org/scripts/39208/264432/WME%20Utils%20-%20Google%20Link%20Enhancer.js 

  1. // ==UserScript==
  2. // @name         WME Utils - Google Link Enhancer
  3. // @namespace    WazeDev
  4. // @version      2018.04.10.002
  5. // @description  Adds some extra WME functionality related to Google place links.
  6. // @author       MapOMatic, WazeDev group
  7. // @include      /^https:\/\/(www|beta)\.waze\.com\/(?!user\/)(.{2,6}\/)?editor\/?.*$/
  8. // @license      GNU GPLv3
  9. // ==/UserScript==
  10.  
  11. /* global $ */
  12. /* global OL */
  13. /* global Promise */
  14. /* global W */
  15. /* global Node */
  16.  
  17. class GoogleLinkEnhancer {
  18.  
  19.     constructor() {
  20.         this.EXT_PROV_ELEM_QUERY = 'li.external-provider-item';
  21.         this.LINK_CACHE_NAME = 'gle_link_cache';
  22.         this.LINK_CACHE_CLEAN_INTERVAL_MIN = 1;   // Interval to remove old links and save new ones.
  23.         this.LINK_CACHE_LIFESPAN_HR = 6;          // Remove old links when they exceed this time limit.
  24.         this._enabled = false;
  25.         this._mapLayer = null;
  26.         this._urlOrigin = window.location.origin;
  27.         this._distanceLimit = 400;                // Default distance (meters) when Waze place is flagged for being too far from Google place.
  28.                                                   // Area place is calculated as _distanceLimit + <distance between centroid and furthest node>
  29.  
  30.         this.strings = {};
  31.         this.strings.closedPlace = 'Google indicates this place is permanently closed.\nVerify with other sources or your editor community before deleting.';
  32.         this.strings.multiLinked = 'Linked more than once already. Please find and remove multiple links.';
  33.         this.strings.linkedToThisPlace = 'Already linked to this place';
  34.         this.strings.linkedNearby = 'Already linked to a nearby place';
  35.         this.strings.linkedToXPlaces = 'This is linked to {0} places';
  36.         this.strings.badLink = 'Invalid Google link.  Please remove it.';
  37.         this.strings.tooFar = 'The Google linked place is more than {0} meters from the Waze place.  Please verify the link is correct.';
  38.  
  39.         this._initLZString();
  40.         
  41.         let storedCache = localStorage.getItem(this.LINK_CACHE_NAME);
  42.         try {
  43.             this._linkCache = storedCache ? $.parseJSON(this._LZString.decompress(storedCache)) : {};
  44.         } catch (ex) {
  45.             if (ex.hasOwnProperty(name) && ex.name === 'SyntaxError') {
  46.                 // In case the cache is corrupted and can't be read.  Seems to happen occasionally, at least in FireFox.
  47.                 this._linkCache = {};
  48.             } else {
  49.                 throw ex;
  50.             }
  51.         }
  52.         if (this._linkCache === null) this._linkCache = {};
  53.  
  54.         this._initLayer();
  55.  
  56.         // Watch for ext provider elements being added to the DOM, and add hover events.
  57.         this._linkObserver = new MutationObserver(mutations => {
  58.             mutations.forEach(mutation => {
  59.                 for (let idx=0; idx<mutation.addedNodes.length; idx++) {
  60.                     let nd = mutation.addedNodes[idx];
  61.                     if (nd.nodeType === Node.ELEMENT_NODE) {
  62.                         let $el = $(nd);
  63.                         if ($el.is(this.EXT_PROV_ELEM_QUERY)) {
  64.                             this._addHoverEvent($el);
  65.                         } else {
  66.                             if ($el.find('div.uuid').length) {
  67.                                 this._formatLinkElements();
  68.                             }
  69.                         }
  70.                     }
  71.                 }
  72.             });
  73.         });
  74.  
  75.         // Watch the side panel for addition of the sidebar-layout div, which indicates a mode change.
  76.         this._modeObserver = new MutationObserver(mutations => {
  77.             mutations.forEach(mutation => {
  78.                 for (let idx = 0; idx<mutation.addedNodes.length; idx++) {
  79.                     let nd = mutation.addedNodes[idx];
  80.                     if (nd.nodeType === Node.ELEMENT_NODE && $(nd).is('.sidebar-layout')) {
  81.                         this._observeLinks();
  82.                         break;
  83.                     }
  84.                 }
  85.             });
  86.         });
  87.  
  88.         // This is a special event that will be triggered when DOM elements are destroyed.
  89.         (function($){
  90.             $.event.special.destroyed = {
  91.                 remove: function(o) {
  92.                     if (o.handler && o.type !== 'destroyed') {
  93.                         o.handler();
  94.                     }
  95.                 }
  96.             };
  97.         })(jQuery);
  98.     }
  99.  
  100.  
  101.     _initLayer(){
  102.         this._mapLayer = new OL.Layer.Vector('Google Link Enhancements.', {
  103.             uniqueName: '___GoogleLinkEnhancements',
  104.             displayInLayerSwitcher: true,
  105.             styleMap: new OL.StyleMap({
  106.                 default: {
  107.                     strokeColor: '${strokeColor}',
  108.                     strokeWidth: '${strokeWidth}',
  109.                     strokeDashstyle: '${strokeDashstyle}',
  110.                     pointRadius: '15',
  111.                     fillOpacity: '0'
  112.                 }
  113.             })
  114.         });
  115.  
  116.         this._mapLayer.setOpacity(0.8);
  117.  
  118.         W.map.addLayer(this._mapLayer);
  119.  
  120.         W.model.events.register('mergeend',this,function(e){
  121.             this._processPlaces();
  122.         },true);
  123.         W.map.events.register('moveend',this,function(e){
  124.             this._processPlaces();
  125.         },true);
  126.         W.model.venues.on('objectschanged', function(e) {
  127.             this._processPlaces();
  128.         }, this);
  129.     }
  130.  
  131.     enable() {
  132.         this._enabled = true;
  133.         this._modeObserver.observe($('.edit-area #sidebarContent')[0], {childList: true, subtree:false});
  134.         this._observeLinks();
  135.         // Note: Using on() allows passing "this" as a variable, so it can be used in the handler function.
  136.         $(document).on('ajaxSuccess', null, this, this._onAjaxSuccess);
  137.         $('#map').on('mouseenter', null, this, this._onMapMouseenter);
  138.         $(window).on('unload', null, this, this._onWindowUnload);
  139.         W.model.venues.on('objectschanged', this._formatLinkElements, this);
  140.         this._processPlaces();
  141.         this._cleanAndSaveLinkCache();
  142.         this._cacheCleanIntervalID = setInterval(() => this._cleanAndSaveLinkCache(), 1000 * 60 * this.LINK_CACHE_CLEAN_INTERVAL_MIN);
  143.     }
  144.  
  145.     disable() {
  146.         this._enabled = false;
  147.         this._modeObserver.disconnect();
  148.         this._linkObserver.disconnect();
  149.         $(document).off('ajaxSuccess', this._onAjaxSuccess);
  150.         $('#map').off('mouseenter', this._onMapMouseenter);
  151.         $(window).off('unload', null, this, this._onWindowUnload);
  152.         W.model.venues.off('objectschanged', this._formatLinkElements, this);
  153.         if (this._cacheCleanIntervalID) clearInterval(this._cacheCleanIntervalID);
  154.         this._cleanAndSaveLinkCache();
  155.         this._mapLayer.removeAllFeatures();
  156.     }
  157.  
  158.     // The distance (in meters) before flagging a Waze place that is too far from the linked Google place.
  159.     // Area places use distanceLimit, plus the distance from the centroid of the AP to its furthest node.
  160.     get distanceLimit() {
  161.         return this._distanceLimit;
  162.     }
  163.     set distanceLimit(value) {
  164.         this._distanceLimit = value;
  165.         this._processPlaces();
  166.     }
  167.  
  168.     _onWindowUnload(evt) {
  169.         evt.data._cleanAndSaveLinkCache();
  170.     }
  171.  
  172.     _cleanAndSaveLinkCache() {
  173.         if (!this._linkCache) return;
  174.         let now = new Date();
  175.         Object.keys(this._linkCache).forEach(id => {
  176.             let link = this._linkCache[id];
  177.             // Bug fix:
  178.             if (link.location) {
  179.                 link.loc = link.location;
  180.                 delete link.location;
  181.             }
  182.             // Delete link if older than X hours.
  183.             if (!link.ts || (now - new Date(link.ts)) > this.LINK_CACHE_LIFESPAN_HR * 3600 * 1000) {
  184.                 delete this._linkCache[id];
  185.             }
  186.         });
  187.         localStorage.setItem(this.LINK_CACHE_NAME, this._LZString.compress(JSON.stringify(this._linkCache)));
  188.         //console.log('link cache count: ' + Object.keys(this._linkCache).length, this._linkCache);
  189.     }
  190.  
  191.     _distanceBetweenPoints(x1, y1, x2, y2) {
  192.         return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
  193.     }
  194.  
  195.     _isLinkTooFar(link, venue) {
  196.         if (link.loc) {
  197.             let linkPt = new OL.Geometry.Point(link.loc.lng, link.loc.lat);
  198.             linkPt.transform(W.map.displayProjection, W.map.projection);
  199.             let venuePt;
  200.             let distanceLimit;
  201.             if (venue.isPoint()) {
  202.                 venuePt = venue.geometry.getCentroid();
  203.                 distanceLimit = this.distanceLimit;
  204.             } else {
  205.                 let bounds = venue.geometry.getBounds();
  206.                 let center = bounds.getCenterLonLat();
  207.                 venuePt = {x: center.lon, y: center.lat};
  208.                 distanceLimit = this._distanceBetweenPoints(center.lon, center.lat, bounds.right, bounds.top) + this.distanceLimit;
  209.             }
  210.             let distance = this._distanceBetweenPoints(linkPt.x, linkPt.y, venuePt.x, venuePt.y);
  211.  
  212.             return distance > distanceLimit;
  213.         } else {
  214.             return false;
  215.         }
  216.     }
  217.  
  218.     _processPlaces() {
  219.         try {
  220.             if (this._enabled) {
  221.                 let that = this;
  222.                 let projFrom = W.map.displayProjection;
  223.                 let projTo = W.map.projection;
  224.                 let mapExtent = W.map.getExtent();
  225.                 this._mapLayer.removeAllFeatures();
  226.                 W.model.venues.getObjectArray().forEach(function(venue) {
  227.                     let isTooFar = false;
  228.                     venue.attributes.externalProviderIDs.forEach(provID => {
  229.                         let id = provID.attributes.uuid;
  230.                         that._getLinkInfoAsync(id).then(link => {
  231.                             // Check for distance from Google POI.
  232.                             if (that._isLinkTooFar(link, venue) && !isTooFar) {
  233.                                 isTooFar = true;
  234.                                 let venuePt = venue.geometry.getCentroid();
  235.                                 let dashStyle = 'solid'; //venue.isPoint() ? '2 6' : '2 16';
  236.                                 let geometry = venue.isPoint() ? venuePt : venue.geometry.clone();
  237.                                 let width = venue.isPoint() ? '4' : '12';
  238.                                 that._mapLayer.addFeatures([new OL.Feature.Vector(geometry, {strokeWidth:width, strokeColor:'#0FF', strokeDashstyle:dashStyle})]);
  239.                             }
  240.  
  241.                             // Check for closed places or invalid Google links.
  242.                             if (link.closed || link.notFound) {
  243.                                 let dashStyle = link.closed && (/^(\[|\()?(permanently )?closed(\]|\)| -)/i.test(venue.attributes.name) || /(\(|- |\[)(permanently )?closed(\)|\])?$/i.test(venue.attributes.name)) ? (venue.isPoint() ? '2 6' : '2 16') : 'solid';
  244.                                 let geometry = venue.isPoint() ? venue.geometry.getCentroid() : venue.geometry.clone();
  245.                                 let width = venue.isPoint() ? '4' : '12';
  246.                                 let color = link.notFound ? '#F0F' : '#F00';
  247.                                 that._mapLayer.addFeatures([new OL.Feature.Vector(geometry, {strokeWidth:width, strokeColor:color, strokeDashstyle:dashStyle})]);
  248.                             }
  249.                         }).catch(res => {
  250.                             console.log(res);
  251.                         });
  252.                     });
  253.                 });
  254.             }
  255.         } catch (ex) {
  256.             console.log(ex);
  257.         }
  258.     }
  259.  
  260.     _cacheLink(id, link) {
  261.         link.ts = new Date();
  262.         this._linkCache[id] = link;
  263.         //console.log('link cache count: ' + Object.keys(this._linkCache).length, this._linkCache);
  264.     }
  265.  
  266.     _getLinkInfoAsync(id) {
  267.         var link = this._linkCache[id];
  268.         if (link) {
  269.             return Promise.resolve(link);
  270.         } else {
  271.             return new Promise((resolve, reject) => {
  272.                 $.getJSON(this._urlOrigin + '/maps/api/place/details/json?&key=AIzaSyDf-q2MCay0AE7RF6oIMrDPrjBwxVtsUuI&placeid=' + id).then(json => {
  273.                     if (json.status==='NOT_FOUND')  {
  274.                         link = {notFound: true};
  275.                     } else {
  276.                         link = {loc:json.result.geometry.location,closed:json.result.permanently_closed};
  277.                     }
  278.                     this._cacheLink(id, link);
  279.                     resolve(link);
  280.                 }).fail(res => {
  281.                     reject(res);
  282.                 });
  283.             });
  284.         }
  285.     }
  286.  
  287.     _onMapMouseenter(event) {
  288.         // If the point isn't destroyed yet, destroy it when mousing over the map.
  289.         event.data._destroyPoint();
  290.     }
  291.     
  292.     _getSelectedFeatures(){
  293.         if(!W.selectionManager.getSelectedFeatures)
  294.             return W.selectionManager.selectedItems;
  295.         return W.selectionManager.getSelectedFeatures();
  296.     }
  297.  
  298.     _formatLinkElements(a,b,c) {
  299.         let existingLinks = this._getExistingLinks();
  300.         $('#edit-panel').find(this.EXT_PROV_ELEM_QUERY).each((ix, childEl) => {
  301.             let $childEl = $(childEl);
  302.             let id = this._getIdFromElement($childEl);
  303.             if (existingLinks[id] && existingLinks[id].count > 1 && existingLinks[id].isThisVenue) {
  304.                 setTimeout(() => {
  305.                     $childEl.find('div.uuid').css({backgroundColor:'#FFA500'}).attr({'title':this.strings.linkedToXPlaces.replace('{0}', existingLinks[id].count)});
  306.                 }, 50);
  307.             }
  308.             this._addHoverEvent($(childEl));
  309.  
  310.             let link = this._linkCache[id];
  311.             if (link) {
  312.                 if (link.closed) {
  313.                     // A delay is needed to allow the UI to do its formatting so it doesn't overwrite ours.
  314.                     setTimeout(() => {
  315.                         $childEl.find('div.uuid').css({backgroundColor:'#FAA'}).attr('title',this.strings.closedPlace);
  316.                     }, 50);
  317.                 } else if (link.notFound) {
  318.                     setTimeout(() => {
  319.                         $childEl.find('div.uuid').css({backgroundColor:'#F0F'}).attr('title',this.strings.badLink);
  320.                     }, 50);
  321.                 } else {
  322.                     let venue = this._getSelectedFeatures()[0].model;
  323.                     if (this._isLinkTooFar(link, venue)) {
  324.                         setTimeout(() => {
  325.                             $childEl.find('div.uuid').css({backgroundColor:'#0FF'}).attr('title',this.strings.tooFar.replace('{0}',this.distanceLimit));
  326.                         }, 50);
  327.                     }
  328.                 }
  329.             }
  330.         });
  331.     }
  332.  
  333.     _getExistingLinks() {
  334.         let existingLinks = {};
  335.         let thisVenue;
  336.         if (this._getSelectedFeatures().length) {
  337.             thisVenue = this._getSelectedFeatures()[0].model;
  338.         }
  339.         W.model.venues.getObjectArray().forEach(venue => {
  340.             let isThisVenue = venue === thisVenue;
  341.             let thisPlaceIDs = [];
  342.             venue.attributes.externalProviderIDs.forEach(provID => {
  343.                 let id = provID.attributes.uuid;
  344.                 if (thisPlaceIDs.indexOf(id) === -1) {
  345.                     thisPlaceIDs.push(id);
  346.                     let link = existingLinks[id];
  347.                     if (link) {
  348.                         link.count++;
  349.                     } else {
  350.                         link = {count: 1};
  351.                         existingLinks[id] = link;
  352.                     }
  353.                     link.isThisVenue = link.isThisVenue || isThisVenue;
  354.                 }
  355.             });
  356.         });
  357.         return existingLinks;
  358.     }
  359.  
  360.     _onAjaxSuccess(event, jqXHR, ajaxOptions, data) {
  361.         let url = ajaxOptions.url;
  362.         let that = event.data;
  363.  
  364.         if(/^\/maps\/api\/place\/autocomplete\/json?/i.test(url)) {
  365.             // After an "autocomplete" api call...
  366.  
  367.             // Get a list of already-linked id's
  368.             let existingLinks = that._getExistingLinks();
  369.  
  370.             // Examine the suggestions and format any that are already linked.
  371.             $('#select2-drop ul li').each((idx, el) => {
  372.                 let $el = $(el);
  373.                 let linkData = $el.data('select2Data');
  374.                 if (linkData) {
  375.                     let link = existingLinks[linkData.id];
  376.                     if (link) {
  377.                         let title, bgColor, textColor, fontWeight;
  378.                         if (link.count > 1) {
  379.                             title = that.strings.multiLinked;
  380.                             textColor = '#000';
  381.                             bgColor = '#FFA500';
  382.                         } else {
  383.                             bgColor = '#ddd';
  384.                             if (link.isThisVenue) {
  385.                                 title = that.strings.linkedToThisPlace;
  386.                                 textColor = '#444';
  387.                                 fontWeight = 600;
  388.                             } else {
  389.                                 title = that.strings.linkedNearby;
  390.                                 textColor = '#888';
  391.                             }
  392.                         }
  393.                         if (bgColor) $el.css({backgroundColor: bgColor});
  394.                         if (textColor) $el.css({color: textColor});
  395.                         if (fontWeight) $el.css({fontWeight: fontWeight});
  396.                         $el.attr('title',title);
  397.                     }
  398.                     $el.mouseover(function() {
  399.                         that._addPoint(linkData.id);
  400.                     }).mouseleave(() => that._destroyPoint()).bind('destroyed', () => that._destroyPoint()).mousedown(() => that._destroyPoint());
  401.                 }
  402.             });
  403.         } else if (/^\/maps\/api\/place\/details\/json?/i.test(url)) {
  404.             //After a "details" api call...
  405.  
  406.             // Cache location results.  Note this isn't absolutely necessary because they're
  407.             // cached when calling for them on mouseover.  However, WME calls this api for each link
  408.             // when the place is first loaded, so might as well take advantage of it.
  409.  
  410.             let link = {};
  411.             if (data.status === 'NOT_FOUND') {
  412.                 link.notFound = true;
  413.             } else {
  414.                 link.loc = data.result.geometry.location;
  415.                 link.closed = data.result.permanently_closed;
  416.             }
  417.             var id = url.match(/placeid=(.*)&?/)[0];
  418.             that._cacheLink(id, link);
  419.             that._formatLinkElements();
  420.         }
  421.     }
  422.  
  423.     // Remove the POI point from the map.
  424.     _destroyPoint() {
  425.         if (this._ptFeature) {
  426.             this._ptFeature.destroy();
  427.             this._ptFeature = null;
  428.             this._lineFeature.destroy();
  429.             this._lineFeature = null;
  430.         }
  431.     }
  432.  
  433.     // Add the POI point to the map.
  434.     _addPoint(id) {
  435.         if (!id) return;
  436.         let link = this._linkCache[id];
  437.         if (link) {
  438.             if (!link.notFound) {
  439.                 let coord = link.loc;
  440.                 let poiPt = new OL.Geometry.Point(coord.lng, coord.lat);
  441.                 poiPt.transform(W.map.displayProjection, W.map.projection);
  442.                 let placeGeom = this._getSelectedFeatures()[0].geometry.getCentroid();
  443.                 let placePt = new OL.Geometry.Point(placeGeom.x, placeGeom.y);
  444.                 let ext = W.map.getExtent();
  445.                 var lsBounds = new OL.Geometry.LineString([new OL.Geometry.Point(ext.left, ext.bottom), new OL.Geometry.Point(ext.left, ext.top),
  446.                                                          new OL.Geometry.Point(ext.right, ext.top),new OL.Geometry.Point(ext.right, ext.bottom),new OL.Geometry.Point(ext.left, ext.bottom)]);
  447.                 let lsLine = new OL.Geometry.LineString([placePt, poiPt]);
  448.  
  449.                 // If the line extends outside the bounds, split it so we don't draw a line across the world.
  450.                 let splits = lsLine.splitWith(lsBounds);
  451.                 let label = '';
  452.                 if (splits) {
  453.                     let splitPoints;
  454.                     splits.forEach(split => {
  455.                         split.components.forEach(component => {
  456.                             if (component.x === placePt.x && component.y === placePt.y) splitPoints = split;
  457.                         });
  458.                     });
  459.                     lsLine = new OL.Geometry.LineString([splitPoints.components[0], splitPoints.components[1]]);
  460.                     let distance = poiPt.distanceTo(placePt);
  461.                     let unitConversion, unit1, unit2;
  462.                     if (W.model.isImperial) {
  463.                         distance *= 3.28084;
  464.                         unitConversion = 5280;
  465.                         unit1 = ' ft';
  466.                         unit2 = ' mi';
  467.                     } else {
  468.                         unitConversion = 1000;
  469.                         unit1 = ' m';
  470.                         unit2 = ' km';
  471.                     }
  472.                     if (distance > unitConversion * 10) {
  473.                         label = Math.round(distance / unitConversion) + unit2;
  474.                     } else if (distance > 1000) {
  475.                         label = (Math.round(distance / (unitConversion / 10)) / 10) + unit2;
  476.                     } else {
  477.                         label = Math.round(distance) + unit1;
  478.                     }
  479.                 }
  480.  
  481.                 this._destroyPoint();  // Just in case it still exists.
  482.                 this._ptFeature = new OL.Feature.Vector(poiPt,{poiCoord:true},{
  483.                     pointRadius: 6,
  484.                     strokeWidth: 30,
  485.                     strokeColor: '#FF0',
  486.                     fillColor: '#FF0',
  487.                     strokeOpacity: 0.5
  488.                 });
  489.                 this._lineFeature = new OL.Feature.Vector(lsLine, {}, {
  490.                     strokeWidth: 3,
  491.                     strokeDashstyle: '12 8',
  492.                     strokeColor: '#FF0',
  493.                     label: label,
  494.                     labelYOffset: 45,
  495.                     fontColor: '#FF0',
  496.                     fontWeight: 'bold',
  497.                     labelOutlineColor: "#000",
  498.                     labelOutlineWidth: 4,
  499.                     fontSize: '18'
  500.                 });
  501.                 W.map.getLayerByUniqueName('landmarks').addFeatures([this._ptFeature, this._lineFeature]);
  502.                 this._timeoutDestroyPoint();
  503.             }
  504.         } else {
  505.             $.getJSON(this._urlOrigin + '/maps/api/place/details/json?&key=AIzaSyDf-q2MCay0AE7RF6oIMrDPrjBwxVtsUuI&placeid=' + id).then(json => {
  506.                 this._cacheLink(id, {loc:json.result.geometry.location,closed:json.result.permanently_closed});
  507.                 this._addPoint(id);
  508.             });
  509.         }
  510.     }
  511.  
  512.     // Destroy the point after some time, if it hasn't been destroyed already.
  513.     _timeoutDestroyPoint() {
  514.         if (this._timeoutID) clearTimeout(this._timeoutID);
  515.         this._timeoutID = setTimeout(() => this._destroyPoint(), 4000);
  516.     }
  517.  
  518.     _getIdFromElement($el) {
  519.         return $el.find('input.uuid').attr('value');
  520.     }
  521.  
  522.     _addHoverEvent($el) {
  523.         $el.hover(() => this._addPoint(this._getIdFromElement($el)) , () => this._destroyPoint());
  524.     }
  525.  
  526.     _observeLinks() {
  527.         this._linkObserver.observe($('#edit-panel')[0],{ childList: true, subtree: true });
  528.     }
  529.  
  530.     _initLZString() {
  531.         // LZ Compressor
  532.         // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
  533.         // This work is free. You can redistribute it and/or modify it
  534.         // under the terms of the WTFPL, Version 2
  535.         // LZ-based compression algorithm, version 1.4.4
  536.         this._LZString = (function() {
  537.             // private property
  538.             var f = String.fromCharCode;
  539.             var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  540.             var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
  541.             var baseReverseDic = {};
  542.  
  543.             function getBaseValue(alphabet, character) {
  544.                 if (!baseReverseDic[alphabet]) {
  545.                     baseReverseDic[alphabet] = {};
  546.                     for (var i = 0; i < alphabet.length; i++) {
  547.                         baseReverseDic[alphabet][alphabet.charAt(i)] = i;
  548.                     }
  549.                 }
  550.                 return baseReverseDic[alphabet][character];
  551.             }
  552.             var LZString = {
  553.                 compressToBase64: function(input) {
  554.                     if (input === null) return "";
  555.                     var res = LZString._compress(input, 6, function(a) {
  556.                         return keyStrBase64.charAt(a);
  557.                     });
  558.                     switch (res.length % 4) { // To produce valid Base64
  559.                         default: // When could this happen ?
  560.                         case 0:
  561.                             return res;
  562.                         case 1:
  563.                             return res + "===";
  564.                         case 2:
  565.                             return res + "==";
  566.                         case 3:
  567.                             return res + "=";
  568.                     }
  569.                 },
  570.                 decompressFromBase64: function(input) {
  571.                     if (input === null) return "";
  572.                     if (input === "") return null;
  573.                     return LZString._decompress(input.length, 32, function(index) {
  574.                         return getBaseValue(keyStrBase64, input.charAt(index));
  575.                     });
  576.                 },
  577.                 compressToUTF16: function(input) {
  578.                     if (input === null) return "";
  579.                     return LZString._compress(input, 15, function(a) {
  580.                         return f(a + 32);
  581.                     }) + " ";
  582.                 },
  583.                 decompressFromUTF16: function(compressed) {
  584.                     if (compressed === null) return "";
  585.                     if (compressed === "") return null;
  586.                     return LZString._decompress(compressed.length, 16384, function(index) {
  587.                         return compressed.charCodeAt(index) - 32;
  588.                     });
  589.                 },
  590.  
  591.                 compress: function(uncompressed) {
  592.                     return LZString._compress(uncompressed, 16, function(a) {
  593.                         return f(a);
  594.                     });
  595.                 },
  596.                 _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
  597.                     if (uncompressed === null) return "";
  598.                     var i, value,
  599.                         context_dictionary = {},
  600.                         context_dictionaryToCreate = {},
  601.                         context_c = "",
  602.                         context_wc = "",
  603.                         context_w = "",
  604.                         context_enlargeIn = 2, // Compensate for the first entry which should not count
  605.                         context_dictSize = 3,
  606.                         context_numBits = 2,
  607.                         context_data = [],
  608.                         context_data_val = 0,
  609.                         context_data_position = 0,
  610.                         ii;
  611.                     for (ii = 0; ii < uncompressed.length; ii += 1) {
  612.                         context_c = uncompressed.charAt(ii);
  613.                         if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
  614.                             context_dictionary[context_c] = context_dictSize++;
  615.                             context_dictionaryToCreate[context_c] = true;
  616.                         }
  617.                         context_wc = context_w + context_c;
  618.                         if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
  619.                             context_w = context_wc;
  620.                         } else {
  621.                             if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  622.                                 if (context_w.charCodeAt(0) < 256) {
  623.                                     for (i = 0; i < context_numBits; i++) {
  624.                                         context_data_val = (context_data_val << 1);
  625.                                         if (context_data_position === bitsPerChar - 1) {
  626.                                             context_data_position = 0;
  627.                                             context_data.push(getCharFromInt(context_data_val));
  628.                                             context_data_val = 0;
  629.                                         } else {
  630.                                             context_data_position++;
  631.                                         }
  632.                                     }
  633.                                     value = context_w.charCodeAt(0);
  634.                                     for (i = 0; i < 8; i++) {
  635.                                         context_data_val = (context_data_val << 1) | (value & 1);
  636.                                         if (context_data_position === bitsPerChar - 1) {
  637.                                             context_data_position = 0;
  638.                                             context_data.push(getCharFromInt(context_data_val));
  639.                                             context_data_val = 0;
  640.                                         } else {
  641.                                             context_data_position++;
  642.                                         }
  643.                                         value = value >> 1;
  644.                                     }
  645.                                 } else {
  646.                                     value = 1;
  647.                                     for (i = 0; i < context_numBits; i++) {
  648.                                         context_data_val = (context_data_val << 1) | value;
  649.                                         if (context_data_position === bitsPerChar - 1) {
  650.                                             context_data_position = 0;
  651.                                             context_data.push(getCharFromInt(context_data_val));
  652.                                             context_data_val = 0;
  653.                                         } else {
  654.                                             context_data_position++;
  655.                                         }
  656.                                         value = 0;
  657.                                     }
  658.                                     value = context_w.charCodeAt(0);
  659.                                     for (i = 0; i < 16; i++) {
  660.                                         context_data_val = (context_data_val << 1) | (value & 1);
  661.                                         if (context_data_position === bitsPerChar - 1) {
  662.                                             context_data_position = 0;
  663.                                             context_data.push(getCharFromInt(context_data_val));
  664.                                             context_data_val = 0;
  665.                                         } else {
  666.                                             context_data_position++;
  667.                                         }
  668.                                         value = value >> 1;
  669.                                     }
  670.                                 }
  671.                                 context_enlargeIn--;
  672.                                 if (context_enlargeIn === 0) {
  673.                                     context_enlargeIn = Math.pow(2, context_numBits);
  674.                                     context_numBits++;
  675.                                 }
  676.                                 delete context_dictionaryToCreate[context_w];
  677.                             } else {
  678.                                 value = context_dictionary[context_w];
  679.                                 for (i = 0; i < context_numBits; i++) {
  680.                                     context_data_val = (context_data_val << 1) | (value & 1);
  681.                                     if (context_data_position === bitsPerChar - 1) {
  682.                                         context_data_position = 0;
  683.                                         context_data.push(getCharFromInt(context_data_val));
  684.                                         context_data_val = 0;
  685.                                     } else {
  686.                                         context_data_position++;
  687.                                     }
  688.                                     value = value >> 1;
  689.                                 }
  690.                             }
  691.                             context_enlargeIn--;
  692.                             if (context_enlargeIn === 0) {
  693.                                 context_enlargeIn = Math.pow(2, context_numBits);
  694.                                 context_numBits++;
  695.                             }
  696.                             // Add wc to the dictionary.
  697.                             context_dictionary[context_wc] = context_dictSize++;
  698.                             context_w = String(context_c);
  699.                         }
  700.                     }
  701.                     // Output the code for w.
  702.                     if (context_w !== "") {
  703.                         if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  704.                             if (context_w.charCodeAt(0) < 256) {
  705.                                 for (i = 0; i < context_numBits; i++) {
  706.                                     context_data_val = (context_data_val << 1);
  707.                                     if (context_data_position === bitsPerChar - 1) {
  708.                                         context_data_position = 0;
  709.                                         context_data.push(getCharFromInt(context_data_val));
  710.                                         context_data_val = 0;
  711.                                     } else {
  712.                                         context_data_position++;
  713.                                     }
  714.                                 }
  715.                                 value = context_w.charCodeAt(0);
  716.                                 for (i = 0; i < 8; i++) {
  717.                                     context_data_val = (context_data_val << 1) | (value & 1);
  718.                                     if (context_data_position === bitsPerChar - 1) {
  719.                                         context_data_position = 0;
  720.                                         context_data.push(getCharFromInt(context_data_val));
  721.                                         context_data_val = 0;
  722.                                     } else {
  723.                                         context_data_position++;
  724.                                     }
  725.                                     value = value >> 1;
  726.                                 }
  727.                             } else {
  728.                                 value = 1;
  729.                                 for (i = 0; i < context_numBits; i++) {
  730.                                     context_data_val = (context_data_val << 1) | value;
  731.                                     if (context_data_position === bitsPerChar - 1) {
  732.                                         context_data_position = 0;
  733.                                         context_data.push(getCharFromInt(context_data_val));
  734.                                         context_data_val = 0;
  735.                                     } else {
  736.                                         context_data_position++;
  737.                                     }
  738.                                     value = 0;
  739.                                 }
  740.                                 value = context_w.charCodeAt(0);
  741.                                 for (i = 0; i < 16; i++) {
  742.                                     context_data_val = (context_data_val << 1) | (value & 1);
  743.                                     if (context_data_position === bitsPerChar - 1) {
  744.                                         context_data_position = 0;
  745.                                         context_data.push(getCharFromInt(context_data_val));
  746.                                         context_data_val = 0;
  747.                                     } else {
  748.                                         context_data_position++;
  749.                                     }
  750.                                     value = value >> 1;
  751.                                 }
  752.                             }
  753.                             context_enlargeIn--;
  754.                             if (context_enlargeIn === 0) {
  755.                                 context_enlargeIn = Math.pow(2, context_numBits);
  756.                                 context_numBits++;
  757.                             }
  758.                             delete context_dictionaryToCreate[context_w];
  759.                         } else {
  760.                             value = context_dictionary[context_w];
  761.                             for (i = 0; i < context_numBits; i++) {
  762.                                 context_data_val = (context_data_val << 1) | (value & 1);
  763.                                 if (context_data_position === bitsPerChar - 1) {
  764.                                     context_data_position = 0;
  765.                                     context_data.push(getCharFromInt(context_data_val));
  766.                                     context_data_val = 0;
  767.                                 } else {
  768.                                     context_data_position++;
  769.                                 }
  770.                                 value = value >> 1;
  771.                             }
  772.                         }
  773.                         context_enlargeIn--;
  774.                         if (context_enlargeIn === 0) {
  775.                             context_enlargeIn = Math.pow(2, context_numBits);
  776.                             context_numBits++;
  777.                         }
  778.                     }
  779.                     // Mark the end of the stream
  780.                     value = 2;
  781.                     for (i = 0; i < context_numBits; i++) {
  782.                         context_data_val = (context_data_val << 1) | (value & 1);
  783.                         if (context_data_position === bitsPerChar - 1) {
  784.                             context_data_position = 0;
  785.                             context_data.push(getCharFromInt(context_data_val));
  786.                             context_data_val = 0;
  787.                         } else {
  788.                             context_data_position++;
  789.                         }
  790.                         value = value >> 1;
  791.                     }
  792.                     // Flush the last char
  793.                     while (true) {
  794.                         context_data_val = (context_data_val << 1);
  795.                         if (context_data_position === bitsPerChar - 1) {
  796.                             context_data.push(getCharFromInt(context_data_val));
  797.                             break;
  798.                         } else context_data_position++;
  799.                     }
  800.                     return context_data.join('');
  801.                 },
  802.                 decompress: function(compressed) {
  803.                     if (compressed === null) return "";
  804.                     if (compressed === "") return null;
  805.                     return LZString._decompress(compressed.length, 32768, function(index) {
  806.                         return compressed.charCodeAt(index);
  807.                     });
  808.                 },
  809.                 _decompress: function(length, resetValue, getNextValue) {
  810.                     var dictionary = [],
  811.                         next,
  812.                         enlargeIn = 4,
  813.                         dictSize = 4,
  814.                         numBits = 3,
  815.                         entry = "",
  816.                         result = [],
  817.                         i,
  818.                         w,
  819.                         bits, resb, maxpower, power,
  820.                         c,
  821.                         data = {
  822.                             val: getNextValue(0),
  823.                             position: resetValue,
  824.                             index: 1
  825.                         };
  826.                     for (i = 0; i < 3; i += 1) {
  827.                         dictionary[i] = i;
  828.                     }
  829.                     bits = 0;
  830.                     maxpower = Math.pow(2, 2);
  831.                     power = 1;
  832.                     while (power !== maxpower) {
  833.                         resb = data.val & data.position;
  834.                         data.position >>= 1;
  835.                         if (data.position === 0) {
  836.                             data.position = resetValue;
  837.                             data.val = getNextValue(data.index++);
  838.                         }
  839.                         bits |= (resb > 0 ? 1 : 0) * power;
  840.                         power <<= 1;
  841.                     }
  842.                     switch (next = bits) {
  843.                         case 0:
  844.                             bits = 0;
  845.                             maxpower = Math.pow(2, 8);
  846.                             power = 1;
  847.                             while (power !== maxpower) {
  848.                                 resb = data.val & data.position;
  849.                                 data.position >>= 1;
  850.                                 if (data.position === 0) {
  851.                                     data.position = resetValue;
  852.                                     data.val = getNextValue(data.index++);
  853.                                 }
  854.                                 bits |= (resb > 0 ? 1 : 0) * power;
  855.                                 power <<= 1;
  856.                             }
  857.                             c = f(bits);
  858.                             break;
  859.                         case 1:
  860.                             bits = 0;
  861.                             maxpower = Math.pow(2, 16);
  862.                             power = 1;
  863.                             while (power !== maxpower) {
  864.                                 resb = data.val & data.position;
  865.                                 data.position >>= 1;
  866.                                 if (data.position === 0) {
  867.                                     data.position = resetValue;
  868.                                     data.val = getNextValue(data.index++);
  869.                                 }
  870.                                 bits |= (resb > 0 ? 1 : 0) * power;
  871.                                 power <<= 1;
  872.                             }
  873.                             c = f(bits);
  874.                             break;
  875.                         case 2:
  876.                             return "";
  877.                     }
  878.                     dictionary[3] = c;
  879.                     w = c;
  880.                     result.push(c);
  881.                     while (true) {
  882.                         if (data.index > length) {
  883.                             return "";
  884.                         }
  885.                         bits = 0;
  886.                         maxpower = Math.pow(2, numBits);
  887.                         power = 1;
  888.                         while (power !== maxpower) {
  889.                             resb = data.val & data.position;
  890.                             data.position >>= 1;
  891.                             if (data.position === 0) {
  892.                                 data.position = resetValue;
  893.                                 data.val = getNextValue(data.index++);
  894.                             }
  895.                             bits |= (resb > 0 ? 1 : 0) * power;
  896.                             power <<= 1;
  897.                         }
  898.                         switch (c = bits) {
  899.                             case 0:
  900.                                 bits = 0;
  901.                                 maxpower = Math.pow(2, 8);
  902.                                 power = 1;
  903.                                 while (power !== maxpower) {
  904.                                     resb = data.val & data.position;
  905.                                     data.position >>= 1;
  906.                                     if (data.position === 0) {
  907.                                         data.position = resetValue;
  908.                                         data.val = getNextValue(data.index++);
  909.                                     }
  910.                                     bits |= (resb > 0 ? 1 : 0) * power;
  911.                                     power <<= 1;
  912.                                 }
  913.                                 dictionary[dictSize++] = f(bits);
  914.                                 c = dictSize - 1;
  915.                                 enlargeIn--;
  916.                                 break;
  917.                             case 1:
  918.                                 bits = 0;
  919.                                 maxpower = Math.pow(2, 16);
  920.                                 power = 1;
  921.                                 while (power !== maxpower) {
  922.                                     resb = data.val & data.position;
  923.                                     data.position >>= 1;
  924.                                     if (data.position === 0) {
  925.                                         data.position = resetValue;
  926.                                         data.val = getNextValue(data.index++);
  927.                                     }
  928.                                     bits |= (resb > 0 ? 1 : 0) * power;
  929.                                     power <<= 1;
  930.                                 }
  931.                                 dictionary[dictSize++] = f(bits);
  932.                                 c = dictSize - 1;
  933.                                 enlargeIn--;
  934.                                 break;
  935.                             case 2:
  936.                                 return result.join('');
  937.                         }
  938.                         if (enlargeIn === 0) {
  939.                             enlargeIn = Math.pow(2, numBits);
  940.                             numBits++;
  941.                         }
  942.                         if (dictionary[c]) {
  943.                             entry = dictionary[c];
  944.                         } else {
  945.                             if (c === dictSize) {
  946.                                 entry = w + w.charAt(0);
  947.                             } else {
  948.                                 return null;
  949.                             }
  950.                         }
  951.                         result.push(entry);
  952.                         // Add w+entry[0] to the dictionary.
  953.                         dictionary[dictSize++] = w + entry.charAt(0);
  954.                         enlargeIn--;
  955.                         w = entry;
  956.                         if (enlargeIn === 0) {
  957.                             enlargeIn = Math.pow(2, numBits);
  958.                             numBits++;
  959.                         }
  960.                     }
  961.                 }
  962.             };
  963.             return LZString;
  964.         })();
  965.     }
  966. }