☰

WME Utils - Google Link Enhancer

Adds some extra WME functionality related to Google place links.

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

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

  1. // ==UserScript==
  2. // @name         WME Utils - Google Link Enhancer
  3. // @namespace    WazeDev
  4. // @version      2018.03.25.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.     _formatLinkElements(a,b,c) {
  293.         let existingLinks = this._getExistingLinks();
  294.         $('#edit-panel').find(this.EXT_PROV_ELEM_QUERY).each((ix, childEl) => {
  295.             let $childEl = $(childEl);
  296.             let id = this._getIdFromElement($childEl);
  297.             if (existingLinks[id] && existingLinks[id].count > 1 && existingLinks[id].isThisVenue) {
  298.                 setTimeout(() => {
  299.                     $childEl.find('div.uuid').css({backgroundColor:'#FFA500'}).attr({'title':this.strings.linkedToXPlaces.replace('{0}', existingLinks[id].count)});
  300.                 }, 50);
  301.             }
  302.             this._addHoverEvent($(childEl));
  303.  
  304.             let link = this._linkCache[id];
  305.             if (link) {
  306.                 if (link.closed) {
  307.                     // A delay is needed to allow the UI to do its formatting so it doesn't overwrite ours.
  308.                     setTimeout(() => {
  309.                         $childEl.find('div.uuid').css({backgroundColor:'#FAA'}).attr('title',this.strings.closedPlace);
  310.                     }, 50);
  311.                 } else if (link.notFound) {
  312.                     setTimeout(() => {
  313.                         $childEl.find('div.uuid').css({backgroundColor:'#F0F'}).attr('title',this.strings.badLink);
  314.                     }, 50);
  315.                 } else {
  316.                     let venue = W.selectionManager.selectedItems[0].model;
  317.                     if (this._isLinkTooFar(link, venue)) {
  318.                         setTimeout(() => {
  319.                             $childEl.find('div.uuid').css({backgroundColor:'#0FF'}).attr('title',this.strings.tooFar.replace('{0}',this.distanceLimit));
  320.                         }, 50);
  321.                     }
  322.                 }
  323.             }
  324.         });
  325.     }
  326.  
  327.     _getExistingLinks() {
  328.         let existingLinks = {};
  329.         let thisVenue;
  330.         if (W.selectionManager.selectedItems.length) {
  331.             thisVenue = W.selectionManager.selectedItems[0].model;
  332.         }
  333.         W.model.venues.getObjectArray().forEach(venue => {
  334.             let isThisVenue = venue === thisVenue;
  335.             let thisPlaceIDs = [];
  336.             venue.attributes.externalProviderIDs.forEach(provID => {
  337.                 let id = provID.attributes.uuid;
  338.                 if (thisPlaceIDs.indexOf(id) === -1) {
  339.                     thisPlaceIDs.push(id);
  340.                     let link = existingLinks[id];
  341.                     if (link) {
  342.                         link.count++;
  343.                     } else {
  344.                         link = {count: 1};
  345.                         existingLinks[id] = link;
  346.                     }
  347.                     link.isThisVenue = link.isThisVenue || isThisVenue;
  348.                 }
  349.             });
  350.         });
  351.         return existingLinks;
  352.     }
  353.  
  354.     _onAjaxSuccess(event, jqXHR, ajaxOptions, data) {
  355.         let url = ajaxOptions.url;
  356.         let that = event.data;
  357.  
  358.         if(/^\/maps\/api\/place\/autocomplete\/json?/i.test(url)) {
  359.             // After an "autocomplete" api call...
  360.  
  361.             // Get a list of already-linked id's
  362.             let existingLinks = that._getExistingLinks();
  363.  
  364.             // Examine the suggestions and format any that are already linked.
  365.             $('#select2-drop ul li').each((idx, el) => {
  366.                 let $el = $(el);
  367.                 let linkData = $el.data('select2Data');
  368.                 if (linkData) {
  369.                     let link = existingLinks[linkData.id];
  370.                     if (link) {
  371.                         let title, bgColor, textColor, fontWeight;
  372.                         if (link.count > 1) {
  373.                             title = that.strings.multiLinked;
  374.                             textColor = '#000';
  375.                             bgColor = '#FFA500';
  376.                         } else {
  377.                             bgColor = '#ddd';
  378.                             if (link.isThisVenue) {
  379.                                 title = that.strings.linkedToThisPlace;
  380.                                 textColor = '#444';
  381.                                 fontWeight = 600;
  382.                             } else {
  383.                                 title = that.strings.linkedNearby;
  384.                                 textColor = '#888';
  385.                             }
  386.                         }
  387.                         if (bgColor) $el.css({backgroundColor: bgColor});
  388.                         if (textColor) $el.css({color: textColor});
  389.                         if (fontWeight) $el.css({fontWeight: fontWeight});
  390.                         $el.attr('title',title);
  391.                     }
  392.                     $el.mouseover(function() {
  393.                         that._addPoint(linkData.id);
  394.                     }).mouseleave(() => that._destroyPoint()).bind('destroyed', () => that._destroyPoint()).mousedown(() => that._destroyPoint());
  395.                 }
  396.             });
  397.         } else if (/^\/maps\/api\/place\/details\/json?/i.test(url)) {
  398.             //After a "details" api call...
  399.  
  400.             // Cache location results.  Note this isn't absolutely necessary because they're
  401.             // cached when calling for them on mouseover.  However, WME calls this api for each link
  402.             // when the place is first loaded, so might as well take advantage of it.
  403.  
  404.             let link = {};
  405.             if (data.status === 'NOT_FOUND') {
  406.                 link.notFound = true;
  407.             } else {
  408.                 link.loc = data.result.geometry.location;
  409.                 link.closed = data.result.permanently_closed;
  410.             }
  411.             var id = url.match(/placeid=(.*)&?/)[0];
  412.             that._cacheLink(id, link);
  413.             that._formatLinkElements();
  414.         }
  415.     }
  416.  
  417.     // Remove the POI point from the map.
  418.     _destroyPoint() {
  419.         if (this._ptFeature) {
  420.             this._ptFeature.destroy();
  421.             this._ptFeature = null;
  422.             this._lineFeature.destroy();
  423.             this._lineFeature = null;
  424.         }
  425.     }
  426.  
  427.     // Add the POI point to the map.
  428.     _addPoint(id) {
  429.         if (!id) return;
  430.         let link = this._linkCache[id];
  431.         if (link) {
  432.             if (!link.notFound) {
  433.                 let coord = link.loc;
  434.                 let poiPt = new OL.Geometry.Point(coord.lng, coord.lat);
  435.                 poiPt.transform(W.map.displayProjection, W.map.projection);
  436.                 let placeGeom = W.selectionManager.selectedItems[0].geometry.getCentroid();
  437.                 let placePt = new OL.Geometry.Point(placeGeom.x, placeGeom.y);
  438.                 let ext = W.map.getExtent();
  439.                 var lsBounds = new OL.Geometry.LineString([new OL.Geometry.Point(ext.left, ext.bottom), new OL.Geometry.Point(ext.left, ext.top),
  440.                                                          new OL.Geometry.Point(ext.right, ext.top),new OL.Geometry.Point(ext.right, ext.bottom),new OL.Geometry.Point(ext.left, ext.bottom)]);
  441.                 let lsLine = new OL.Geometry.LineString([placePt, poiPt]);
  442.  
  443.                 // If the line extends outside the bounds, split it so we don't draw a line across the world.
  444.                 let splits = lsLine.splitWith(lsBounds);
  445.                 let label = '';
  446.                 if (splits) {
  447.                     let splitPoints;
  448.                     splits.forEach(split => {
  449.                         split.components.forEach(component => {
  450.                             if (component.x === placePt.x && component.y === placePt.y) splitPoints = split;
  451.                         });
  452.                     });
  453.                     lsLine = new OL.Geometry.LineString([splitPoints.components[0], splitPoints.components[1]]);
  454.                     let distance = poiPt.distanceTo(placePt);
  455.                     let unitConversion, unit1, unit2;
  456.                     if (W.model.isImperial) {
  457.                         distance *= 3.28084;
  458.                         unitConversion = 5280;
  459.                         unit1 = ' ft';
  460.                         unit2 = ' mi';
  461.                     } else {
  462.                         unitConversion = 1000;
  463.                         unit1 = ' km';
  464.                         unit2 = ' m';
  465.                     }
  466.                     if (distance > unitConversion * 10) {
  467.                         label = Math.round(distance / unitConversion) + unit2;
  468.                     } else if (distance > 1000) {
  469.                         label = (Math.round(distance / (unitConversion / 10)) / 10) + unit2;
  470.                     } else {
  471.                         label = Math.round(distance) + unit1;
  472.                     }
  473.                 }
  474.  
  475.                 this._destroyPoint();  // Just in case it still exists.
  476.                 this._ptFeature = new OL.Feature.Vector(poiPt,{poiCoord:true},{
  477.                     pointRadius: 6,
  478.                     strokeWidth: 30,
  479.                     strokeColor: '#FF0',
  480.                     fillColor: '#FF0',
  481.                     strokeOpacity: 0.5
  482.                 });
  483.                 this._lineFeature = new OL.Feature.Vector(lsLine, {}, {
  484.                     strokeWidth: 3,
  485.                     strokeDashstyle: '12 8',
  486.                     strokeColor: '#FF0',
  487.                     label: label,
  488.                     labelYOffset: 45,
  489.                     fontColor: '#FF0',
  490.                     fontWeight: 'bold',
  491.                     labelOutlineColor: "#000",
  492.                     labelOutlineWidth: 4,
  493.                     fontSize: '18'
  494.                 });
  495.                 W.map.getLayerByUniqueName('landmarks').addFeatures([this._ptFeature, this._lineFeature]);
  496.                 this._timeoutDestroyPoint();
  497.             }
  498.         } else {
  499.             $.getJSON(this._urlOrigin + '/maps/api/place/details/json?&key=AIzaSyDf-q2MCay0AE7RF6oIMrDPrjBwxVtsUuI&placeid=' + id).then(json => {
  500.                 this._cacheLink(id, {loc:json.result.geometry.location,closed:json.result.permanently_closed});
  501.                 this._addPoint(id);
  502.             });
  503.         }
  504.     }
  505.  
  506.     // Destroy the point after some time, if it hasn't been destroyed already.
  507.     _timeoutDestroyPoint() {
  508.         if (this._timeoutID) clearTimeout(this._timeoutID);
  509.         this._timeoutID = setTimeout(() => this._destroyPoint(), 4000);
  510.     }
  511.  
  512.     _getIdFromElement($el) {
  513.         return $el.find('input.uuid').attr('value');
  514.     }
  515.  
  516.     _addHoverEvent($el) {
  517.         $el.hover(() => this._addPoint(this._getIdFromElement($el)) , () => this._destroyPoint());
  518.     }
  519.  
  520.     _observeLinks() {
  521.         this._linkObserver.observe($('#edit-panel')[0],{ childList: true, subtree: true });
  522.     }
  523.  
  524.     _initLZString() {
  525.         // LZ Compressor
  526.         // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
  527.         // This work is free. You can redistribute it and/or modify it
  528.         // under the terms of the WTFPL, Version 2
  529.         // LZ-based compression algorithm, version 1.4.4
  530.         this._LZString = (function() {
  531.             // private property
  532.             var f = String.fromCharCode;
  533.             var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  534.             var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
  535.             var baseReverseDic = {};
  536.  
  537.             function getBaseValue(alphabet, character) {
  538.                 if (!baseReverseDic[alphabet]) {
  539.                     baseReverseDic[alphabet] = {};
  540.                     for (var i = 0; i < alphabet.length; i++) {
  541.                         baseReverseDic[alphabet][alphabet.charAt(i)] = i;
  542.                     }
  543.                 }
  544.                 return baseReverseDic[alphabet][character];
  545.             }
  546.             var LZString = {
  547.                 compressToBase64: function(input) {
  548.                     if (input === null) return "";
  549.                     var res = LZString._compress(input, 6, function(a) {
  550.                         return keyStrBase64.charAt(a);
  551.                     });
  552.                     switch (res.length % 4) { // To produce valid Base64
  553.                         default: // When could this happen ?
  554.                         case 0:
  555.                             return res;
  556.                         case 1:
  557.                             return res + "===";
  558.                         case 2:
  559.                             return res + "==";
  560.                         case 3:
  561.                             return res + "=";
  562.                     }
  563.                 },
  564.                 decompressFromBase64: function(input) {
  565.                     if (input === null) return "";
  566.                     if (input === "") return null;
  567.                     return LZString._decompress(input.length, 32, function(index) {
  568.                         return getBaseValue(keyStrBase64, input.charAt(index));
  569.                     });
  570.                 },
  571.                 compressToUTF16: function(input) {
  572.                     if (input === null) return "";
  573.                     return LZString._compress(input, 15, function(a) {
  574.                         return f(a + 32);
  575.                     }) + " ";
  576.                 },
  577.                 decompressFromUTF16: function(compressed) {
  578.                     if (compressed === null) return "";
  579.                     if (compressed === "") return null;
  580.                     return LZString._decompress(compressed.length, 16384, function(index) {
  581.                         return compressed.charCodeAt(index) - 32;
  582.                     });
  583.                 },
  584.  
  585.                 compress: function(uncompressed) {
  586.                     return LZString._compress(uncompressed, 16, function(a) {
  587.                         return f(a);
  588.                     });
  589.                 },
  590.                 _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
  591.                     if (uncompressed === null) return "";
  592.                     var i, value,
  593.                         context_dictionary = {},
  594.                         context_dictionaryToCreate = {},
  595.                         context_c = "",
  596.                         context_wc = "",
  597.                         context_w = "",
  598.                         context_enlargeIn = 2, // Compensate for the first entry which should not count
  599.                         context_dictSize = 3,
  600.                         context_numBits = 2,
  601.                         context_data = [],
  602.                         context_data_val = 0,
  603.                         context_data_position = 0,
  604.                         ii;
  605.                     for (ii = 0; ii < uncompressed.length; ii += 1) {
  606.                         context_c = uncompressed.charAt(ii);
  607.                         if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
  608.                             context_dictionary[context_c] = context_dictSize++;
  609.                             context_dictionaryToCreate[context_c] = true;
  610.                         }
  611.                         context_wc = context_w + context_c;
  612.                         if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
  613.                             context_w = context_wc;
  614.                         } else {
  615.                             if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  616.                                 if (context_w.charCodeAt(0) < 256) {
  617.                                     for (i = 0; i < context_numBits; i++) {
  618.                                         context_data_val = (context_data_val << 1);
  619.                                         if (context_data_position === bitsPerChar - 1) {
  620.                                             context_data_position = 0;
  621.                                             context_data.push(getCharFromInt(context_data_val));
  622.                                             context_data_val = 0;
  623.                                         } else {
  624.                                             context_data_position++;
  625.                                         }
  626.                                     }
  627.                                     value = context_w.charCodeAt(0);
  628.                                     for (i = 0; i < 8; i++) {
  629.                                         context_data_val = (context_data_val << 1) | (value & 1);
  630.                                         if (context_data_position === bitsPerChar - 1) {
  631.                                             context_data_position = 0;
  632.                                             context_data.push(getCharFromInt(context_data_val));
  633.                                             context_data_val = 0;
  634.                                         } else {
  635.                                             context_data_position++;
  636.                                         }
  637.                                         value = value >> 1;
  638.                                     }
  639.                                 } else {
  640.                                     value = 1;
  641.                                     for (i = 0; i < context_numBits; i++) {
  642.                                         context_data_val = (context_data_val << 1) | value;
  643.                                         if (context_data_position === bitsPerChar - 1) {
  644.                                             context_data_position = 0;
  645.                                             context_data.push(getCharFromInt(context_data_val));
  646.                                             context_data_val = 0;
  647.                                         } else {
  648.                                             context_data_position++;
  649.                                         }
  650.                                         value = 0;
  651.                                     }
  652.                                     value = context_w.charCodeAt(0);
  653.                                     for (i = 0; i < 16; i++) {
  654.                                         context_data_val = (context_data_val << 1) | (value & 1);
  655.                                         if (context_data_position === bitsPerChar - 1) {
  656.                                             context_data_position = 0;
  657.                                             context_data.push(getCharFromInt(context_data_val));
  658.                                             context_data_val = 0;
  659.                                         } else {
  660.                                             context_data_position++;
  661.                                         }
  662.                                         value = value >> 1;
  663.                                     }
  664.                                 }
  665.                                 context_enlargeIn--;
  666.                                 if (context_enlargeIn === 0) {
  667.                                     context_enlargeIn = Math.pow(2, context_numBits);
  668.                                     context_numBits++;
  669.                                 }
  670.                                 delete context_dictionaryToCreate[context_w];
  671.                             } else {
  672.                                 value = context_dictionary[context_w];
  673.                                 for (i = 0; i < context_numBits; i++) {
  674.                                     context_data_val = (context_data_val << 1) | (value & 1);
  675.                                     if (context_data_position === bitsPerChar - 1) {
  676.                                         context_data_position = 0;
  677.                                         context_data.push(getCharFromInt(context_data_val));
  678.                                         context_data_val = 0;
  679.                                     } else {
  680.                                         context_data_position++;
  681.                                     }
  682.                                     value = value >> 1;
  683.                                 }
  684.                             }
  685.                             context_enlargeIn--;
  686.                             if (context_enlargeIn === 0) {
  687.                                 context_enlargeIn = Math.pow(2, context_numBits);
  688.                                 context_numBits++;
  689.                             }
  690.                             // Add wc to the dictionary.
  691.                             context_dictionary[context_wc] = context_dictSize++;
  692.                             context_w = String(context_c);
  693.                         }
  694.                     }
  695.                     // Output the code for w.
  696.                     if (context_w !== "") {
  697.                         if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  698.                             if (context_w.charCodeAt(0) < 256) {
  699.                                 for (i = 0; i < context_numBits; i++) {
  700.                                     context_data_val = (context_data_val << 1);
  701.                                     if (context_data_position === bitsPerChar - 1) {
  702.                                         context_data_position = 0;
  703.                                         context_data.push(getCharFromInt(context_data_val));
  704.                                         context_data_val = 0;
  705.                                     } else {
  706.                                         context_data_position++;
  707.                                     }
  708.                                 }
  709.                                 value = context_w.charCodeAt(0);
  710.                                 for (i = 0; i < 8; i++) {
  711.                                     context_data_val = (context_data_val << 1) | (value & 1);
  712.                                     if (context_data_position === bitsPerChar - 1) {
  713.                                         context_data_position = 0;
  714.                                         context_data.push(getCharFromInt(context_data_val));
  715.                                         context_data_val = 0;
  716.                                     } else {
  717.                                         context_data_position++;
  718.                                     }
  719.                                     value = value >> 1;
  720.                                 }
  721.                             } else {
  722.                                 value = 1;
  723.                                 for (i = 0; i < context_numBits; i++) {
  724.                                     context_data_val = (context_data_val << 1) | value;
  725.                                     if (context_data_position === bitsPerChar - 1) {
  726.                                         context_data_position = 0;
  727.                                         context_data.push(getCharFromInt(context_data_val));
  728.                                         context_data_val = 0;
  729.                                     } else {
  730.                                         context_data_position++;
  731.                                     }
  732.                                     value = 0;
  733.                                 }
  734.                                 value = context_w.charCodeAt(0);
  735.                                 for (i = 0; i < 16; i++) {
  736.                                     context_data_val = (context_data_val << 1) | (value & 1);
  737.                                     if (context_data_position === bitsPerChar - 1) {
  738.                                         context_data_position = 0;
  739.                                         context_data.push(getCharFromInt(context_data_val));
  740.                                         context_data_val = 0;
  741.                                     } else {
  742.                                         context_data_position++;
  743.                                     }
  744.                                     value = value >> 1;
  745.                                 }
  746.                             }
  747.                             context_enlargeIn--;
  748.                             if (context_enlargeIn === 0) {
  749.                                 context_enlargeIn = Math.pow(2, context_numBits);
  750.                                 context_numBits++;
  751.                             }
  752.                             delete context_dictionaryToCreate[context_w];
  753.                         } else {
  754.                             value = context_dictionary[context_w];
  755.                             for (i = 0; i < context_numBits; i++) {
  756.                                 context_data_val = (context_data_val << 1) | (value & 1);
  757.                                 if (context_data_position === bitsPerChar - 1) {
  758.                                     context_data_position = 0;
  759.                                     context_data.push(getCharFromInt(context_data_val));
  760.                                     context_data_val = 0;
  761.                                 } else {
  762.                                     context_data_position++;
  763.                                 }
  764.                                 value = value >> 1;
  765.                             }
  766.                         }
  767.                         context_enlargeIn--;
  768.                         if (context_enlargeIn === 0) {
  769.                             context_enlargeIn = Math.pow(2, context_numBits);
  770.                             context_numBits++;
  771.                         }
  772.                     }
  773.                     // Mark the end of the stream
  774.                     value = 2;
  775.                     for (i = 0; i < context_numBits; i++) {
  776.                         context_data_val = (context_data_val << 1) | (value & 1);
  777.                         if (context_data_position === bitsPerChar - 1) {
  778.                             context_data_position = 0;
  779.                             context_data.push(getCharFromInt(context_data_val));
  780.                             context_data_val = 0;
  781.                         } else {
  782.                             context_data_position++;
  783.                         }
  784.                         value = value >> 1;
  785.                     }
  786.                     // Flush the last char
  787.                     while (true) {
  788.                         context_data_val = (context_data_val << 1);
  789.                         if (context_data_position === bitsPerChar - 1) {
  790.                             context_data.push(getCharFromInt(context_data_val));
  791.                             break;
  792.                         } else context_data_position++;
  793.                     }
  794.                     return context_data.join('');
  795.                 },
  796.                 decompress: function(compressed) {
  797.                     if (compressed === null) return "";
  798.                     if (compressed === "") return null;
  799.                     return LZString._decompress(compressed.length, 32768, function(index) {
  800.                         return compressed.charCodeAt(index);
  801.                     });
  802.                 },
  803.                 _decompress: function(length, resetValue, getNextValue) {
  804.                     var dictionary = [],
  805.                         next,
  806.                         enlargeIn = 4,
  807.                         dictSize = 4,
  808.                         numBits = 3,
  809.                         entry = "",
  810.                         result = [],
  811.                         i,
  812.                         w,
  813.                         bits, resb, maxpower, power,
  814.                         c,
  815.                         data = {
  816.                             val: getNextValue(0),
  817.                             position: resetValue,
  818.                             index: 1
  819.                         };
  820.                     for (i = 0; i < 3; i += 1) {
  821.                         dictionary[i] = i;
  822.                     }
  823.                     bits = 0;
  824.                     maxpower = Math.pow(2, 2);
  825.                     power = 1;
  826.                     while (power !== maxpower) {
  827.                         resb = data.val & data.position;
  828.                         data.position >>= 1;
  829.                         if (data.position === 0) {
  830.                             data.position = resetValue;
  831.                             data.val = getNextValue(data.index++);
  832.                         }
  833.                         bits |= (resb > 0 ? 1 : 0) * power;
  834.                         power <<= 1;
  835.                     }
  836.                     switch (next = bits) {
  837.                         case 0:
  838.                             bits = 0;
  839.                             maxpower = Math.pow(2, 8);
  840.                             power = 1;
  841.                             while (power !== maxpower) {
  842.                                 resb = data.val & data.position;
  843.                                 data.position >>= 1;
  844.                                 if (data.position === 0) {
  845.                                     data.position = resetValue;
  846.                                     data.val = getNextValue(data.index++);
  847.                                 }
  848.                                 bits |= (resb > 0 ? 1 : 0) * power;
  849.                                 power <<= 1;
  850.                             }
  851.                             c = f(bits);
  852.                             break;
  853.                         case 1:
  854.                             bits = 0;
  855.                             maxpower = Math.pow(2, 16);
  856.                             power = 1;
  857.                             while (power !== maxpower) {
  858.                                 resb = data.val & data.position;
  859.                                 data.position >>= 1;
  860.                                 if (data.position === 0) {
  861.                                     data.position = resetValue;
  862.                                     data.val = getNextValue(data.index++);
  863.                                 }
  864.                                 bits |= (resb > 0 ? 1 : 0) * power;
  865.                                 power <<= 1;
  866.                             }
  867.                             c = f(bits);
  868.                             break;
  869.                         case 2:
  870.                             return "";
  871.                     }
  872.                     dictionary[3] = c;
  873.                     w = c;
  874.                     result.push(c);
  875.                     while (true) {
  876.                         if (data.index > length) {
  877.                             return "";
  878.                         }
  879.                         bits = 0;
  880.                         maxpower = Math.pow(2, numBits);
  881.                         power = 1;
  882.                         while (power !== maxpower) {
  883.                             resb = data.val & data.position;
  884.                             data.position >>= 1;
  885.                             if (data.position === 0) {
  886.                                 data.position = resetValue;
  887.                                 data.val = getNextValue(data.index++);
  888.                             }
  889.                             bits |= (resb > 0 ? 1 : 0) * power;
  890.                             power <<= 1;
  891.                         }
  892.                         switch (c = bits) {
  893.                             case 0:
  894.                                 bits = 0;
  895.                                 maxpower = Math.pow(2, 8);
  896.                                 power = 1;
  897.                                 while (power !== maxpower) {
  898.                                     resb = data.val & data.position;
  899.                                     data.position >>= 1;
  900.                                     if (data.position === 0) {
  901.                                         data.position = resetValue;
  902.                                         data.val = getNextValue(data.index++);
  903.                                     }
  904.                                     bits |= (resb > 0 ? 1 : 0) * power;
  905.                                     power <<= 1;
  906.                                 }
  907.                                 dictionary[dictSize++] = f(bits);
  908.                                 c = dictSize - 1;
  909.                                 enlargeIn--;
  910.                                 break;
  911.                             case 1:
  912.                                 bits = 0;
  913.                                 maxpower = Math.pow(2, 16);
  914.                                 power = 1;
  915.                                 while (power !== maxpower) {
  916.                                     resb = data.val & data.position;
  917.                                     data.position >>= 1;
  918.                                     if (data.position === 0) {
  919.                                         data.position = resetValue;
  920.                                         data.val = getNextValue(data.index++);
  921.                                     }
  922.                                     bits |= (resb > 0 ? 1 : 0) * power;
  923.                                     power <<= 1;
  924.                                 }
  925.                                 dictionary[dictSize++] = f(bits);
  926.                                 c = dictSize - 1;
  927.                                 enlargeIn--;
  928.                                 break;
  929.                             case 2:
  930.                                 return result.join('');
  931.                         }
  932.                         if (enlargeIn === 0) {
  933.                             enlargeIn = Math.pow(2, numBits);
  934.                             numBits++;
  935.                         }
  936.                         if (dictionary[c]) {
  937.                             entry = dictionary[c];
  938.                         } else {
  939.                             if (c === dictSize) {
  940.                                 entry = w + w.charAt(0);
  941.                             } else {
  942.                                 return null;
  943.                             }
  944.                         }
  945.                         result.push(entry);
  946.                         // Add w+entry[0] to the dictionary.
  947.                         dictionary[dictSize++] = w + entry.charAt(0);
  948.                         enlargeIn--;
  949.                         w = entry;
  950.                         if (enlargeIn === 0) {
  951.                             enlargeIn = Math.pow(2, numBits);
  952.                             numBits++;
  953.                         }
  954.                     }
  955.                 }
  956.             };
  957.             return LZString;
  958.         })();
  959.     }
  960. }