☰

WME Utils - Google Link Enhancer

Adds some extra WME functionality related to Google place links.

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

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

  1. // ==UserScript==
  2. // @name         WME Utils - Google Link Enhancer
  3. // @namespace    WazeDev
  4. // @version      2022.08.10.001
  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 OpenLayers */
  13. /* global Promise */
  14. /* global W */
  15. /* global Node */
  16.  
  17. /* eslint-disable */
  18.  
  19. class GoogleLinkEnhancer {
  20.  
  21.     constructor() {
  22.         this.DISABLE_CLOSED_PLACES = false; // Set to TRUE if the "closed Google place" feature needs to be temporarily disabled, e.g. during the COVID-19 pandemic.
  23.         this.EXT_PROV_ELEM_QUERY = 'li.external-provider-item';
  24.         this.LINK_CACHE_NAME = 'gle_link_cache';
  25.         this.LINK_CACHE_CLEAN_INTERVAL_MIN = 1; // Interval to remove old links and save new ones.
  26.         this.LINK_CACHE_LIFESPAN_HR = 6; // Remove old links when they exceed this time limit.
  27.         this.DEC = k => atob(atob(k));
  28.         this._enabled = false;
  29.         this._disableApiUntil; // When a serious API error occurs (OVER_QUERY_LIMIT, REQUEST_DENIED), set this to a time in the future.
  30.         this._mapLayer = null;
  31.         this._urlOrigin = window.location.origin;
  32.         this._distanceLimit = 400; // Default distance (meters) when Waze place is flagged for being too far from Google place.
  33.         // Area place is calculated as _distanceLimit + <distance between centroid and furthest node>
  34.  
  35.         this._showTempClosedPOIs = true;
  36.         this.strings = {};
  37.         this.strings.permClosedPlace = 'Google indicates this place is permanently closed.\nVerify with other sources or your editor community before deleting.';
  38.         this.strings.tempClosedPlace = 'Google indicates this place is temporarily closed.';
  39.         this.strings.multiLinked = 'Linked more than once already. Please find and remove multiple links.';
  40.         this.strings.linkedToThisPlace = 'Already linked to this place';
  41.         this.strings.linkedNearby = 'Already linked to a nearby place';
  42.         this.strings.linkedToXPlaces = 'This is linked to {0} places';
  43.         this.strings.badLink = 'Invalid Google link. Please remove it.';
  44.         this.strings.tooFar = 'The Google linked place is more than {0} meters from the Waze place.  Please verify the link is correct.';
  45.  
  46.         this._urlBase = `${this._urlOrigin}/maps/api/place/details/json?fields=geometry,business_status&${this.DEC('YTJWNVBVRkplbUZUZVVObFltSkZVM0pYUlZKWk1VMVNXalUyWjBWQlpuQjBOM1JMTWxJMmFGWmZTUT09')}&placeid=`;
  47.  
  48.         this._initLZString();
  49.  
  50.         let storedCache = localStorage.getItem(this.LINK_CACHE_NAME);
  51.         try {
  52.             this._linkCache = storedCache ? $.parseJSON(this._LZString.decompressFromUTF16(storedCache)) : {};
  53.         } catch (ex) {
  54.             if (ex.name === 'SyntaxError') {
  55.                 // In case the cache is corrupted and can't be read.
  56.                 this._linkCache = {};
  57.                 console.warn('GoogleLinkEnhancer:', 'An error occurred while loading the stored cache.  A new cache was created.');
  58.             } else {
  59.                 throw ex;
  60.             }
  61.         }
  62.         if (this._linkCache === null || this._linkCache.length === 0) this._linkCache = {};
  63.  
  64.         this._initLayer();
  65.  
  66.         // Watch for ext provider elements being added to the DOM, and add hover events.
  67.         this._linkObserver = new MutationObserver(mutations => {
  68.             mutations.forEach(mutation => {
  69.                 for (let idx = 0; idx < mutation.addedNodes.length; idx++) {
  70.                     let nd = mutation.addedNodes[idx];
  71.                     if (nd.nodeType === Node.ELEMENT_NODE) {
  72.                         var $el = $(nd);
  73.                         // elements under a shadowroot dont show up here, so trigger on an item that
  74.                         // does get added when a venue is selected, then search for ext provider elements.
  75.                         if (nd.nodeName == "INPUT" && nd.defaultValue == "TAKE_AWAY") {
  76.                             var ex = document.getElementsByClassName("external-provider-content");
  77.                             for (let i2 = 0; i2 < ex.length; i2++){
  78.                                 $el = $(ex[i2]);
  79.                                 this._addHoverEvent($el);
  80.                             }
  81.                         }
  82.                         else if ($el.is(this.EXT_PROV_ELEM_QUERY)) {
  83.                             this._addHoverEvent($el);
  84.                         } else {
  85.                             if ($el.find('div.uuid').length) {
  86.                                 this._formatLinkElements();
  87.                             }
  88.                         }
  89.                     }
  90.                 }
  91.  
  92.             });
  93.         });
  94.  
  95.         // Watch for Google place search result list items being added to the DOM
  96.         let that = this;
  97.         this._searchResultsObserver = new MutationObserver(mutations => {
  98.             mutations.forEach(mutation => {
  99.                 for (let idx = 0; idx < mutation.addedNodes.length; idx++) {
  100.                     let nd = mutation.addedNodes[idx];
  101.                     if (nd.nodeType === Node.ELEMENT_NODE && $(nd).is('.select2-results-dept-0') && $(nd).parent().parent().is('.select2-with-searchbox')) {
  102.                         $(nd).mouseenter(() => {
  103.                             // When mousing over a list item, find the Google place ID from the list that was stored previously.
  104.                             // Then add the point/line to the map.
  105.                             that._addPoint(that._lastSearchResultPlaceIds[idx]);
  106.                         }).mouseleave(() => {
  107.                             // When leaving the list item, remove the point.
  108.                             that._destroyPoint()
  109.                         });
  110.                     }
  111.                 }
  112.             });
  113.         });
  114.  
  115.         // Watch the side panel for addition of the sidebar-layout div, which indicates a mode change.
  116.         this._modeObserver = new MutationObserver(mutations => {
  117.             mutations.forEach(mutation => {
  118.                 for (let idx = 0; idx < mutation.addedNodes.length; idx++) {
  119.                     let nd = mutation.addedNodes[idx];
  120.                     if (nd.nodeType === Node.ELEMENT_NODE && $(nd).is('.sidebar-layout')) {
  121.                         this._observeLinks();
  122.                         break;
  123.                     }
  124.                 }
  125.             });
  126.         });
  127.  
  128.         // This is a special event that will be triggered when DOM elements are destroyed.
  129.         (function ($) {
  130.             $.event.special.destroyed = {
  131.                 remove: function (o) {
  132.                     if (o.handler && o.type !== 'destroyed') {
  133.                         o.handler();
  134.                     }
  135.                 }
  136.             };
  137.         })(jQuery);
  138.     }
  139.  
  140.     _initLayer() {
  141.         this._mapLayer = new OpenLayers.Layer.Vector('Google Link Enhancements.', {
  142.             uniqueName: '___GoogleLinkEnhancements',
  143.             displayInLayerSwitcher: true,
  144.             styleMap: new OpenLayers.StyleMap({
  145.                 default: {
  146.                     strokeColor: '${strokeColor}',
  147.                     strokeWidth: '${strokeWidth}',
  148.                     strokeDashstyle: '${strokeDashstyle}',
  149.                     pointRadius: '15',
  150.                     fillOpacity: '0'
  151.                 }
  152.             })
  153.         });
  154.  
  155.         this._mapLayer.setOpacity(0.8);
  156.  
  157.         W.map.addLayer(this._mapLayer);
  158.  
  159.         W.model.events.register('mergeend', this, function (e) {
  160.             this._processPlaces();
  161.         }, true);
  162.  
  163.         // *************************************
  164.         // EDIT 2019.03.14 - Not sure if this is needed.  Mergeend event seems to work fine.
  165.         // Removing it for now, but not thoroughly tested.
  166.         // *************************************
  167.         // W.map.events.register('moveend', this, function (e) {
  168.         //     this._processPlaces();
  169.         // }, true);
  170.  
  171.         W.model.venues.on('objectschanged', function (e) { this._processPlaces(); }, this);
  172.         W.model.venues.on('objectsremoved', function (e) { this._processPlaces(); }, this);
  173.         W.model.venues.on('objectsadded', function (e) { this._processPlaces(); }, this);
  174.     }
  175.  
  176.     enable() {
  177.         if (!this._enabled) {
  178.             this._modeObserver.observe($('.edit-area #sidebarContent')[0], { childList: true, subtree: false });
  179.             this._observeLinks();
  180.             this._searchResultsObserver.observe($('body')[0], { childList: true, subtree: true });
  181.             // Watch for JSONP callbacks. JSONP is used for the autocomplete results when searching for Google links.
  182.             this._addJsonpInterceptor();
  183.             // Note: Using on() allows passing "this" as a variable, so it can be used in the handler function.
  184.             $('#map').on('mouseenter', null, this, this._onMapMouseenter);
  185.             $(window).on('unload', null, this, this._onWindowUnload);
  186.             W.model.venues.on('objectschanged', this._formatLinkElements, this);
  187.             this._processPlaces();
  188.             this._cleanAndSaveLinkCache();
  189.             this._cacheCleanIntervalID = setInterval(() => this._cleanAndSaveLinkCache(), 1000 * 60 * this.LINK_CACHE_CLEAN_INTERVAL_MIN);
  190.             this._enabled = true;
  191.         }
  192.     }
  193.  
  194.     disable() {
  195.         if (this._enabled) {
  196.             this._modeObserver.disconnect();
  197.             this._linkObserver.disconnect();
  198.             this._searchResultsObserver.disconnect();
  199.             this._removeJsonpInterceptor();
  200.             $('#map').off('mouseenter', this._onMapMouseenter);
  201.             $(window).off('unload', null, this, this._onWindowUnload);
  202.             W.model.venues.off('objectschanged', this._formatLinkElements, this);
  203.             if (this._cacheCleanIntervalID) clearInterval(this._cacheCleanIntervalID);
  204.             this._cleanAndSaveLinkCache();
  205.             this._enabled = false;
  206.         }
  207.     }
  208.  
  209.     // The distance (in meters) before flagging a Waze place that is too far from the linked Google place.
  210.     // Area places use distanceLimit, plus the distance from the centroid of the AP to its furthest node.
  211.     get distanceLimit() {
  212.         return this._distanceLimit;
  213.     }
  214.     set distanceLimit(value) {
  215.         this._distanceLimit = value;
  216.         this._processPlaces();
  217.     }
  218.  
  219. 	get showTempClosedPOIs(){
  220. 		return this._showTempClosedPOIs;
  221. 	}
  222. 	
  223. 	set showTempClosedPOIs(value){
  224. 		this._showTempClosedPOIs = value;
  225. 		this._processPlaces();
  226. 	}
  227.  
  228.     _onWindowUnload(evt) {
  229.         evt.data._cleanAndSaveLinkCache();
  230.     }
  231.  
  232.     _cleanAndSaveLinkCache() {
  233.         if (!this._linkCache) return;
  234.         let now = new Date();
  235.         Object.keys(this._linkCache).forEach(id => {
  236.             let link = this._linkCache[id];
  237.             // Bug fix:
  238.             if (link.location) {
  239.                 link.loc = link.location;
  240.                 delete link.location;
  241.             }
  242.             // Delete link if older than X hours.
  243.             if (!link.ts || (now - new Date(link.ts)) > this.LINK_CACHE_LIFESPAN_HR * 3600 * 1000) {
  244.                 delete this._linkCache[id];
  245.             }
  246.         });
  247.         localStorage.setItem(this.LINK_CACHE_NAME, this._LZString.compressToUTF16(JSON.stringify(this._linkCache)));
  248.         //console.log('link cache count: ' + Object.keys(this._linkCache).length, this._linkCache);
  249.     }
  250.  
  251.     _distanceBetweenPoints(x1, y1, x2, y2) {
  252.         return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
  253.     }
  254.  
  255.     _isLinkTooFar(link, venue) {
  256.         if (link.loc) {
  257.             let linkPt = new OpenLayers.Geometry.Point(link.loc.lng, link.loc.lat);
  258.             linkPt.transform(W.Config.map.projection.remote, W.map.getProjectionObject());
  259.             let venuePt;
  260.             let distanceLimit;
  261.             if (venue.isPoint()) {
  262.                 venuePt = venue.geometry.getCentroid();
  263.                 distanceLimit = this.distanceLimit;
  264.             } else {
  265.                 let bounds = venue.geometry.getBounds();
  266.                 let center = bounds.getCenterLonLat();
  267.                 venuePt = { x: center.lon, y: center.lat };
  268.                 distanceLimit = this._distanceBetweenPoints(center.lon, center.lat, bounds.right, bounds.top) + this.distanceLimit;
  269.             }
  270.             let distance = this._distanceBetweenPoints(linkPt.x, linkPt.y, venuePt.x, venuePt.y);
  271.  
  272.             return distance > distanceLimit;
  273.         } else {
  274.             return false;
  275.         }
  276.     }
  277.  
  278.     _processPlaces() {
  279.         try {
  280.             if (this._enabled) {
  281.                 let that = this;
  282.                 let projFrom = W.Config.map.projection.remote; // W.map.getOLMap().displayProjection;
  283.                 let projTo = W.map.getProjectionObject();
  284.                 let mapExtent = W.map.getExtent();
  285.                 // Get a list of already-linked id's
  286.                 let existingLinks = this._getExistingLinks();
  287.                 this._mapLayer.removeAllFeatures();
  288.                 let drawnLinks = [];
  289.                 W.model.venues.getObjectArray().forEach(function (venue) {
  290.                     const promises = [];
  291.                     venue.attributes.externalProviderIDs.forEach(provID => {
  292.                         let id = provID.attributes.uuid;
  293.  
  294.                         // Check for duplicate links
  295.                         let linkInfo = existingLinks[id];
  296.                         if (linkInfo.count > 1) {
  297.                             let geometry = venue.isPoint() ? venue.geometry.getCentroid() : venue.geometry.clone();
  298.                             let width = venue.isPoint() ? '4' : '12';
  299.                             let color = '#fb8d00';
  300.                             let features = [new OpenLayers.Feature.Vector(geometry, {
  301.                                 strokeWidth: width, strokeColor: color
  302.                             })];
  303.                             let lineStart = geometry.getCentroid();
  304.                             linkInfo.venues.forEach(linkVenue => {
  305.                                 if (linkVenue !== venue
  306.                                     && !drawnLinks.some(dl => (dl[0] === venue && dl[1] === linkVenue) || (dl[0] === linkVenue && dl[1] === venue))) {
  307.                                     features.push(
  308.                                         new OpenLayers.Feature.Vector(
  309.                                             new OpenLayers.Geometry.LineString([lineStart, linkVenue.geometry.getCentroid()]),
  310.                                             {
  311.                                                 strokeWidth: 4,
  312.                                                 strokeColor: color,
  313.                                                 strokeDashstyle: '12 12',
  314.                                             })
  315.                                     )
  316.                                     drawnLinks.push([venue, linkVenue]);
  317.                                 }
  318.                             })
  319.                             that._mapLayer.addFeatures(features);
  320.                         }
  321.  
  322.                         // Get Google link info, and store results for processing.
  323.                         promises.push(that._getLinkInfoAsync(id));
  324.                     });
  325.  
  326.                     // Process all results of link lookups and add a highlight feature if needed.
  327.                     Promise.all(promises).then(results => {
  328.                         let strokeColor = null;
  329.                         let strokeDashStyle = 'solid';
  330.                         if (results.some(res => that._isLinkTooFar(res, venue))) {
  331.                             strokeColor = '#0FF';
  332.                         } else if (!that.DISABLE_CLOSED_PLACES && results.some(res => res.permclosed)) {
  333.                             if (/^(\[|\()?(permanently )?closed(\]|\)| -)/i.test(venue.attributes.name)
  334.                                 || /(\(|- |\[)(permanently )?closed(\)|\])?$/i.test(venue.attributes.name)) {
  335.                                 strokeDashStyle = venue.isPoint() ? '2 6' : '2 16';
  336.                             }
  337.                             strokeColor = '#F00';
  338.                         } else if (!that.DISABLE_CLOSED_PLACES && that._showTempClosedPOIs && results.some(res => res.tempclosed)) {
  339.                             if (/^(\[|\()?(temporarily )?closed(\]|\)| -)/i.test(venue.attributes.name)
  340.                                 || /(\(|- |\[)(temporarily )?closed(\)|\])?$/i.test(venue.attributes.name)) {
  341.                                 strokeDashStyle = venue.isPoint() ? '2 6' : '2 16';
  342.                             }
  343.                             strokeColor = '#FD3';
  344.                         } else if (results.some(res => res.notFound)) {
  345.                             strokeColor = '#F0F';
  346.                         }
  347.                         if (strokeColor) {
  348.                             const style = {
  349.                                 strokeWidth: venue.isPoint() ? '4' : '12',
  350.                                 strokeColor,
  351.                                 strokeDashStyle
  352.                             }
  353.                             const geometry = venue.isPoint() ? venue.geometry.getCentroid() : venue.geometry.clone();
  354.                             that._mapLayer.addFeatures([new OpenLayers.Feature.Vector(geometry, style)]);
  355.                         }
  356.                     });
  357.                 });
  358.             }
  359.         } catch (ex) {
  360.             console.error('PIE (Google Link Enhancer) error:', ex);
  361.         }
  362.     }
  363.  
  364.     _cacheLink(id, link) {
  365.         link.ts = new Date();
  366.         this._linkCache[id] = link;
  367.         //console.log('link cache count: ' + Object.keys(this._linkCache).length, this._linkCache);
  368.     }
  369.  
  370.     _getLinkInfoAsync(id) {
  371.         var link = this._linkCache[id];
  372.         if (link) {
  373.             return Promise.resolve(link);
  374.         } else {
  375.             if (this._disableApiUntil) {
  376.                 if (Date.now() < this._disableApiUntil) {
  377.                     return Promise.resolve({ apiDisabled: true });
  378.                 }
  379.                 this._disableApiUntil = null;
  380.             }
  381.             return new Promise((resolve, reject) => {
  382.                 $.getJSON(`${this._urlBase}${id}`).then(json => {
  383.                     let res = {};
  384.                     if (json.status === "OK") {
  385.                         res.loc = json.result.geometry.location;
  386.                         if (json.result.business_status == "CLOSED_PERMANENTLY") {
  387.                             res.permclosed = true;
  388.                         } else if (json.result.business_status == "CLOSED_TEMPORARILY") {
  389.                             res.tempclosed = true;
  390.                         }
  391.                         this._cacheLink(id, res);
  392.                     } else if (json.status === "NOT_FOUND") {
  393.                         res.notfound = true;
  394.                         this._cacheLink(id, res);
  395.                     } else {
  396.                         if (this._disableApiUntil) {
  397.                             res.apiDisabled = true;
  398.                         } else {
  399.                             res.error = json.status;
  400.                             res.errorMessage = json.error_message;
  401.                             this._disableApiUntil = Date.now() + 10 * 1000 // Disable api calls for 10 seconds.
  402.                             console.error(GM_info.script.name + ', Google Link Enhancer disabled for 10 seconds due to API error.', res);
  403.                         }
  404.                     }
  405.                     resolve(res);
  406.                 });
  407.             });
  408.         }
  409.     }
  410.  
  411.     _onMapMouseenter(event) {
  412.         // If the point isn't destroyed yet, destroy it when mousing over the map.
  413.         event.data._destroyPoint();
  414.     }
  415.  
  416.     _getSelectedFeatures() {
  417.         if (!W.selectionManager.getSelectedFeatures)
  418.             return W.selectionManager.selectedItems;
  419.         return W.selectionManager.getSelectedFeatures();
  420.     }
  421.  
  422.     _formatLinkElements(a, b, c) {
  423.         let existingLinks = this._getExistingLinks();
  424.         $('#edit-panel').find(this.EXT_PROV_ELEM_QUERY).each((ix, childEl) => {
  425.             console.log(childEl);
  426.             let $childEl = $(childEl);
  427.             let id = this._getIdFromElement($childEl);
  428.             if (existingLinks[id] && existingLinks[id].count > 1 && existingLinks[id].isThisVenue) {
  429.                 setTimeout(() => {
  430.                     $childEl.find('div.uuid').css({ backgroundColor: '#FFA500' }).attr({ 'title': this.strings.linkedToXPlaces.replace('{0}', existingLinks[id].count) });
  431.                 }, 50);
  432.             }
  433.             this._addHoverEvent($(childEl));
  434.  
  435.             let link = this._linkCache[id];
  436.             if (link) {
  437.                 if (link.permclosed && !this.DISABLE_CLOSED_PLACES) {
  438.                     // A delay is needed to allow the UI to do its formatting so it doesn't overwrite ours.
  439.                     // EDIT 2019.03.14 - Tested without the timeouts and it appears to be working now.
  440.  
  441.                     //setTimeout(() => {
  442.                     $childEl.find('div.uuid').css({ backgroundColor: '#FAA' }).attr('title', this.strings.permClosedPlace);
  443.                     //}, 50);
  444.                 } else if (link.tempclosed && !this.DISABLE_CLOSED_PLACES) {
  445.                     //setTimeout(() => {
  446.                     $childEl.find('div.uuid').css({ backgroundColor: '#FFA' }).attr('title', this.strings.tempClosedPlace);
  447.                     //}, 50);
  448.                 } else if (link.notFound) {
  449.                     //setTimeout(() => {
  450.                     $childEl.find('div.uuid').css({ backgroundColor: '#F0F' }).attr('title', this.strings.badLink);
  451.                     //}, 50);
  452.                 } else {
  453.                     let venue = this._getSelectedFeatures()[0].model;
  454.                     if (this._isLinkTooFar(link, venue)) {
  455.                         //setTimeout(() => {
  456.                         $childEl.find('div.uuid').css({ backgroundColor: '#0FF' }).attr('title', this.strings.tooFar.replace('{0}', this.distanceLimit));
  457.                         //}, 50);
  458.                     }
  459.                 }
  460.             }
  461.         });
  462.     }
  463.  
  464.     _getExistingLinks() {
  465.         let existingLinks = {};
  466.         let thisVenue;
  467.         if (this._getSelectedFeatures().length) {
  468.             thisVenue = this._getSelectedFeatures()[0].model;
  469.         }
  470.         W.model.venues.getObjectArray().forEach(venue => {
  471.             let isThisVenue = venue === thisVenue;
  472.             let thisPlaceIDs = [];
  473.             venue.attributes.externalProviderIDs.forEach(provID => {
  474.                 let id = provID.attributes.uuid;
  475.                 if (thisPlaceIDs.indexOf(id) === -1) {
  476.                     thisPlaceIDs.push(id);
  477.                     let link = existingLinks[id];
  478.                     if (link) {
  479.                         link.count++;
  480.                         link.venues.push(venue);
  481.                     } else {
  482.                         link = { count: 1, venues: [venue] };
  483.                         existingLinks[id] = link;
  484.                     }
  485.                     link.isThisVenue = link.isThisVenue || isThisVenue;
  486.                 }
  487.             });
  488.         });
  489.         return existingLinks;
  490.     }
  491.  
  492.     // Remove the POI point from the map.
  493.     _destroyPoint() {
  494.         if (this._ptFeature) {
  495.             this._ptFeature.destroy();
  496.             this._ptFeature = null;
  497.             this._lineFeature.destroy();
  498.             this._lineFeature = null;
  499.         }
  500.     }
  501.  
  502.     // Add the POI point to the map.
  503.     _addPoint(id) {
  504.         if (!id) return;
  505.         let link = this._linkCache[id];
  506.         if (link) {
  507.             if (!link.notFound) {
  508.                 let coord = link.loc;
  509.                 let poiPt = new OpenLayers.Geometry.Point(coord.lng, coord.lat);
  510.                 poiPt.transform(W.Config.map.projection.remote, W.map.getProjectionObject());
  511.                 let placeGeom = this._getSelectedFeatures()[0].geometry.getCentroid();
  512.                 let placePt = new OpenLayers.Geometry.Point(placeGeom.x, placeGeom.y);
  513.                 let ext = W.map.getExtent();
  514.                 var lsBounds = new OpenLayers.Geometry.LineString([
  515.                     new OpenLayers.Geometry.Point(ext.left, ext.bottom),
  516.                     new OpenLayers.Geometry.Point(ext.left, ext.top),
  517.                     new OpenLayers.Geometry.Point(ext.right, ext.top),
  518.                     new OpenLayers.Geometry.Point(ext.right, ext.bottom),
  519.                     new OpenLayers.Geometry.Point(ext.left, ext.bottom)]);
  520.                 let lsLine = new OpenLayers.Geometry.LineString([placePt, poiPt]);
  521.  
  522.                 // If the line extends outside the bounds, split it so we don't draw a line across the world.
  523.                 let splits = lsLine.splitWith(lsBounds);
  524.                 let label = '';
  525.                 if (splits) {
  526.                     let splitPoints;
  527.                     splits.forEach(split => {
  528.                         split.components.forEach(component => {
  529.                             if (component.x === placePt.x && component.y === placePt.y) splitPoints = split;
  530.                         });
  531.                     });
  532.                     lsLine = new OpenLayers.Geometry.LineString([splitPoints.components[0], splitPoints.components[1]]);
  533.                     let distance = poiPt.distanceTo(placePt);
  534.                     let unitConversion, unit1, unit2;
  535.                     if (W.model.isImperial) {
  536.                         distance *= 3.28084;
  537.                         unitConversion = 5280;
  538.                         unit1 = ' ft';
  539.                         unit2 = ' mi';
  540.                     } else {
  541.                         unitConversion = 1000;
  542.                         unit1 = ' m';
  543.                         unit2 = ' km';
  544.                     }
  545.                     if (distance > unitConversion * 10) {
  546.                         label = Math.round(distance / unitConversion) + unit2;
  547.                     } else if (distance > 1000) {
  548.                         label = (Math.round(distance / (unitConversion / 10)) / 10) + unit2;
  549.                     } else {
  550.                         label = Math.round(distance) + unit1;
  551.                     }
  552.                 }
  553.  
  554.                 this._destroyPoint();  // Just in case it still exists.
  555.                 this._ptFeature = new OpenLayers.Feature.Vector(poiPt, { poiCoord: true }, {
  556.                     pointRadius: 6,
  557.                     strokeWidth: 30,
  558.                     strokeColor: '#FF0',
  559.                     fillColor: '#FF0',
  560.                     strokeOpacity: 0.5
  561.                 });
  562.                 this._lineFeature = new OpenLayers.Feature.Vector(lsLine, {}, {
  563.                     strokeWidth: 3,
  564.                     strokeDashstyle: '12 8',
  565.                     strokeColor: '#FF0',
  566.                     label: label,
  567.                     labelYOffset: 45,
  568.                     fontColor: '#FF0',
  569.                     fontWeight: 'bold',
  570.                     labelOutlineColor: "#000",
  571.                     labelOutlineWidth: 4,
  572.                     fontSize: '18'
  573.                 });
  574.                 W.map.getLayerByUniqueName('venues').addFeatures([this._ptFeature, this._lineFeature]);
  575.                 this._timeoutDestroyPoint();
  576.             }
  577.         } else {
  578.             this._getLinkInfoAsync(id).then(res => {
  579.                 if (res.error || res.apiDisabled) {
  580.                     // API was temporarily disabled.  Ignore for now.
  581.                 } else {
  582.                     this._addPoint(id);
  583.                 }
  584.             })
  585.         }
  586.     }
  587.  
  588.     // Destroy the point after some time, if it hasn't been destroyed already.
  589.     _timeoutDestroyPoint() {
  590.         if (this._timeoutID) clearTimeout(this._timeoutID);
  591.         this._timeoutID = setTimeout(() => this._destroyPoint(), 4000);
  592.     }
  593.  
  594.     _getSelectedVenue() {
  595.         const features = W.selectionManager.getSelectedFeatures();
  596.         // Be sure to check for features.length === 1, in case multiple venues are currently selected.
  597.         return features.length === 1 && features[0].model.type === 'venue'
  598.             ? features[0].model : undefined;
  599.     }
  600.  
  601.     _getIdFromElement($el) {
  602.         const venue = this._getSelectedVenue();
  603.         const links = venue.attributes.externalProviderIDs;
  604.         const url = $el[0].parentNode.getElementsByClassName("url")[0].href;
  605.  
  606.         let id = "";
  607.         for (var ln in links) {
  608.             var lnk = links[ln];
  609.             const u = lnk.attributes.url;
  610.             if (u == url) {
  611.                 id = lnk.attributes.id;
  612.                 break;
  613.             }
  614.         }
  615.         return id;
  616.     }
  617.  
  618.     _addHoverEvent($el) {
  619.         $el.hover(() => this._addPoint(this._getIdFromElement($el)), () => this._destroyPoint());
  620.     }
  621.  
  622.     _observeLinks() {
  623.         this._linkObserver.observe($('#edit-panel')[0], { childList: true, subtree: true });
  624.     }
  625.  
  626.     // The JSONP interceptor is used to watch the head element for the addition of JSONP functions
  627.     // that process Google link search results. Those functions are overridden by our own so we can
  628.     // process the results before sending them on to the original function.
  629.     _addJsonpInterceptor() {
  630.         // The idea for this function was hatched here:
  631.         // https://stackoverflow.com/questions/6803521/can-google-maps-places-autocomplete-api-be-used-via-ajax/9856786
  632.  
  633.         // The head element, where the Google Autocomplete code will insert a tag 
  634.         // for a javascript file.
  635.         var head = $('head')[0];
  636.         // The name of the method the Autocomplete code uses to insert the tag.
  637.         var method = 'appendChild';
  638.         // The method we will be overriding.
  639.         var originalMethod = head[method];
  640.         this._originalHeadAppendChildMethod = originalMethod;
  641.         let that = this;
  642.         head[method] = function () {
  643.             // Check that the element is a javascript tag being inserted by Google.
  644.             if (arguments[0] && arguments[0].src && arguments[0].src.match(/GetPredictions/)) {
  645.                 // Regex to extract the name of the callback method that the JSONP will call.
  646.                 var callbackMatchObject = (/callback=([^&]+)&|$/).exec(arguments[0].src);
  647.  
  648.                 // Regex to extract the search term that was entered by the user.
  649.                 var searchTermMatchObject = (/\?1s([^&]+)&/).exec(arguments[0].src);
  650.  
  651.                 var searchTerm = unescape(searchTermMatchObject[1]);
  652.                 if (callbackMatchObject && searchTermMatchObject) {
  653.                     // The JSONP callback method is in the form "abc.def" and each time has a different random name.
  654.                     var names = callbackMatchObject[1].split('.');
  655.                     // Store the original callback method.
  656.                     var originalCallback = names[0] && names[1] && window[names[0]] && window[names[0]][names[1]];
  657.  
  658.                     if (originalCallback) {
  659.                         var newCallback = function () {  // Define your own JSONP callback
  660.                             if (arguments[0] && arguments[0].predictions) {
  661.                                 // SUCCESS!
  662.  
  663.                                 // The autocomplete results
  664.                                 var data = arguments[0];
  665.  
  666.                                 console.log(data);
  667.                                 that._lastSearchResultPlaceIds = data.predictions.map(pred => pred.place_id);
  668.  
  669.                                 // Call the original callback so the WME dropdown can do its thing.
  670.                                 originalCallback(data);
  671.                             }
  672.                         }
  673.  
  674.                         // Add copy all the attributes of the old callback function to the new callback function. 
  675.                         // This prevents the autocomplete functionality from throwing an error.
  676.                         for (name in originalCallback) {
  677.                             newCallback[name] = originalCallback[name];
  678.                         }
  679.                         window[names[0]][names[1]] = newCallback;  // Override the JSONP callback
  680.                     }
  681.                 }
  682.             }
  683.             // Insert the element into the dom, regardless of whether it was being inserted by Google.
  684.             return originalMethod.apply(this, arguments);
  685.         };
  686.     }
  687.  
  688.     _removeJsonpInterceptor() {
  689.         $('head')[0].appendChild = this._originalHeadAppendChildMethod;
  690.     }
  691.  
  692.     _initLZString() {
  693.         // LZ Compressor
  694.         // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
  695.         // This work is free. You can redistribute it and/or modify it
  696.         // under the terms of the WTFPL, Version 2
  697.         // LZ-based compression algorithm, version 1.4.4
  698.         this._LZString = (function () {
  699.             // private property
  700.             var f = String.fromCharCode;
  701.             var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  702.             var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
  703.             var baseReverseDic = {};
  704.  
  705.             function getBaseValue(alphabet, character) {
  706.                 if (!baseReverseDic[alphabet]) {
  707.                     baseReverseDic[alphabet] = {};
  708.                     for (var i = 0; i < alphabet.length; i++) {
  709.                         baseReverseDic[alphabet][alphabet.charAt(i)] = i;
  710.                     }
  711.                 }
  712.                 return baseReverseDic[alphabet][character];
  713.             }
  714.             var LZString = {
  715.                 compressToBase64: function (input) {
  716.                     if (input === null) return "";
  717.                     var res = LZString._compress(input, 6, function (a) {
  718.                         return keyStrBase64.charAt(a);
  719.                     });
  720.                     switch (res.length % 4) { // To produce valid Base64
  721.                         default: // When could this happen ?
  722.                         case 0:
  723.                             return res;
  724.                         case 1:
  725.                             return res + "===";
  726.                         case 2:
  727.                             return res + "==";
  728.                         case 3:
  729.                             return res + "=";
  730.                     }
  731.                 },
  732.                 decompressFromBase64: function (input) {
  733.                     if (input === null) return "";
  734.                     if (input === "") return null;
  735.                     return LZString._decompress(input.length, 32, function (index) {
  736.                         return getBaseValue(keyStrBase64, input.charAt(index));
  737.                     });
  738.                 },
  739.                 compressToUTF16: function (input) {
  740.                     if (input === null) return "";
  741.                     return LZString._compress(input, 15, function (a) {
  742.                         return f(a + 32);
  743.                     }) + " ";
  744.                 },
  745.                 decompressFromUTF16: function (compressed) {
  746.                     if (compressed === null) return "";
  747.                     if (compressed === "") return null;
  748.                     return LZString._decompress(compressed.length, 16384, function (index) {
  749.                         return compressed.charCodeAt(index) - 32;
  750.                     });
  751.                 },
  752.  
  753.                 compress: function (uncompressed) {
  754.                     return LZString._compress(uncompressed, 16, function (a) {
  755.                         return f(a);
  756.                     });
  757.                 },
  758.                 _compress: function (uncompressed, bitsPerChar, getCharFromInt) {
  759.                     if (uncompressed === null) return "";
  760.                     var i, value,
  761.                         context_dictionary = {},
  762.                         context_dictionaryToCreate = {},
  763.                         context_c = "",
  764.                         context_wc = "",
  765.                         context_w = "",
  766.                         context_enlargeIn = 2, // Compensate for the first entry which should not count
  767.                         context_dictSize = 3,
  768.                         context_numBits = 2,
  769.                         context_data = [],
  770.                         context_data_val = 0,
  771.                         context_data_position = 0,
  772.                         ii;
  773.                     for (ii = 0; ii < uncompressed.length; ii += 1) {
  774.                         context_c = uncompressed.charAt(ii);
  775.                         if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
  776.                             context_dictionary[context_c] = context_dictSize++;
  777.                             context_dictionaryToCreate[context_c] = true;
  778.                         }
  779.                         context_wc = context_w + context_c;
  780.                         if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
  781.                             context_w = context_wc;
  782.                         } else {
  783.                             if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  784.                                 if (context_w.charCodeAt(0) < 256) {
  785.                                     for (i = 0; i < context_numBits; i++) {
  786.                                         context_data_val = (context_data_val << 1);
  787.                                         if (context_data_position === bitsPerChar - 1) {
  788.                                             context_data_position = 0;
  789.                                             context_data.push(getCharFromInt(context_data_val));
  790.                                             context_data_val = 0;
  791.                                         } else {
  792.                                             context_data_position++;
  793.                                         }
  794.                                     }
  795.                                     value = context_w.charCodeAt(0);
  796.                                     for (i = 0; i < 8; i++) {
  797.                                         context_data_val = (context_data_val << 1) | (value & 1);
  798.                                         if (context_data_position === bitsPerChar - 1) {
  799.                                             context_data_position = 0;
  800.                                             context_data.push(getCharFromInt(context_data_val));
  801.                                             context_data_val = 0;
  802.                                         } else {
  803.                                             context_data_position++;
  804.                                         }
  805.                                         value = value >> 1;
  806.                                     }
  807.                                 } else {
  808.                                     value = 1;
  809.                                     for (i = 0; i < context_numBits; i++) {
  810.                                         context_data_val = (context_data_val << 1) | value;
  811.                                         if (context_data_position === bitsPerChar - 1) {
  812.                                             context_data_position = 0;
  813.                                             context_data.push(getCharFromInt(context_data_val));
  814.                                             context_data_val = 0;
  815.                                         } else {
  816.                                             context_data_position++;
  817.                                         }
  818.                                         value = 0;
  819.                                     }
  820.                                     value = context_w.charCodeAt(0);
  821.                                     for (i = 0; i < 16; i++) {
  822.                                         context_data_val = (context_data_val << 1) | (value & 1);
  823.                                         if (context_data_position === bitsPerChar - 1) {
  824.                                             context_data_position = 0;
  825.                                             context_data.push(getCharFromInt(context_data_val));
  826.                                             context_data_val = 0;
  827.                                         } else {
  828.                                             context_data_position++;
  829.                                         }
  830.                                         value = value >> 1;
  831.                                     }
  832.                                 }
  833.                                 context_enlargeIn--;
  834.                                 if (context_enlargeIn === 0) {
  835.                                     context_enlargeIn = Math.pow(2, context_numBits);
  836.                                     context_numBits++;
  837.                                 }
  838.                                 delete context_dictionaryToCreate[context_w];
  839.                             } else {
  840.                                 value = context_dictionary[context_w];
  841.                                 for (i = 0; i < context_numBits; i++) {
  842.                                     context_data_val = (context_data_val << 1) | (value & 1);
  843.                                     if (context_data_position === bitsPerChar - 1) {
  844.                                         context_data_position = 0;
  845.                                         context_data.push(getCharFromInt(context_data_val));
  846.                                         context_data_val = 0;
  847.                                     } else {
  848.                                         context_data_position++;
  849.                                     }
  850.                                     value = value >> 1;
  851.                                 }
  852.                             }
  853.                             context_enlargeIn--;
  854.                             if (context_enlargeIn === 0) {
  855.                                 context_enlargeIn = Math.pow(2, context_numBits);
  856.                                 context_numBits++;
  857.                             }
  858.                             // Add wc to the dictionary.
  859.                             context_dictionary[context_wc] = context_dictSize++;
  860.                             context_w = String(context_c);
  861.                         }
  862.                     }
  863.                     // Output the code for w.
  864.                     if (context_w !== "") {
  865.                         if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
  866.                             if (context_w.charCodeAt(0) < 256) {
  867.                                 for (i = 0; i < context_numBits; i++) {
  868.                                     context_data_val = (context_data_val << 1);
  869.                                     if (context_data_position === bitsPerChar - 1) {
  870.                                         context_data_position = 0;
  871.                                         context_data.push(getCharFromInt(context_data_val));
  872.                                         context_data_val = 0;
  873.                                     } else {
  874.                                         context_data_position++;
  875.                                     }
  876.                                 }
  877.                                 value = context_w.charCodeAt(0);
  878.                                 for (i = 0; i < 8; i++) {
  879.                                     context_data_val = (context_data_val << 1) | (value & 1);
  880.                                     if (context_data_position === bitsPerChar - 1) {
  881.                                         context_data_position = 0;
  882.                                         context_data.push(getCharFromInt(context_data_val));
  883.                                         context_data_val = 0;
  884.                                     } else {
  885.                                         context_data_position++;
  886.                                     }
  887.                                     value = value >> 1;
  888.                                 }
  889.                             } else {
  890.                                 value = 1;
  891.                                 for (i = 0; i < context_numBits; i++) {
  892.                                     context_data_val = (context_data_val << 1) | value;
  893.                                     if (context_data_position === bitsPerChar - 1) {
  894.                                         context_data_position = 0;
  895.                                         context_data.push(getCharFromInt(context_data_val));
  896.                                         context_data_val = 0;
  897.                                     } else {
  898.                                         context_data_position++;
  899.                                     }
  900.                                     value = 0;
  901.                                 }
  902.                                 value = context_w.charCodeAt(0);
  903.                                 for (i = 0; i < 16; i++) {
  904.                                     context_data_val = (context_data_val << 1) | (value & 1);
  905.                                     if (context_data_position === bitsPerChar - 1) {
  906.                                         context_data_position = 0;
  907.                                         context_data.push(getCharFromInt(context_data_val));
  908.                                         context_data_val = 0;
  909.                                     } else {
  910.                                         context_data_position++;
  911.                                     }
  912.                                     value = value >> 1;
  913.                                 }
  914.                             }
  915.                             context_enlargeIn--;
  916.                             if (context_enlargeIn === 0) {
  917.                                 context_enlargeIn = Math.pow(2, context_numBits);
  918.                                 context_numBits++;
  919.                             }
  920.                             delete context_dictionaryToCreate[context_w];
  921.                         } else {
  922.                             value = context_dictionary[context_w];
  923.                             for (i = 0; i < context_numBits; i++) {
  924.                                 context_data_val = (context_data_val << 1) | (value & 1);
  925.                                 if (context_data_position === bitsPerChar - 1) {
  926.                                     context_data_position = 0;
  927.                                     context_data.push(getCharFromInt(context_data_val));
  928.                                     context_data_val = 0;
  929.                                 } else {
  930.                                     context_data_position++;
  931.                                 }
  932.                                 value = value >> 1;
  933.                             }
  934.                         }
  935.                         context_enlargeIn--;
  936.                         if (context_enlargeIn === 0) {
  937.                             context_enlargeIn = Math.pow(2, context_numBits);
  938.                             context_numBits++;
  939.                         }
  940.                     }
  941.                     // Mark the end of the stream
  942.                     value = 2;
  943.                     for (i = 0; i < context_numBits; i++) {
  944.                         context_data_val = (context_data_val << 1) | (value & 1);
  945.                         if (context_data_position === bitsPerChar - 1) {
  946.                             context_data_position = 0;
  947.                             context_data.push(getCharFromInt(context_data_val));
  948.                             context_data_val = 0;
  949.                         } else {
  950.                             context_data_position++;
  951.                         }
  952.                         value = value >> 1;
  953.                     }
  954.                     // Flush the last char
  955.                     while (true) {
  956.                         context_data_val = (context_data_val << 1);
  957.                         if (context_data_position === bitsPerChar - 1) {
  958.                             context_data.push(getCharFromInt(context_data_val));
  959.                             break;
  960.                         } else context_data_position++;
  961.                     }
  962.                     return context_data.join('');
  963.                 },
  964.                 decompress: function (compressed) {
  965.                     if (compressed === null) return "";
  966.                     if (compressed === "") return null;
  967.                     return LZString._decompress(compressed.length, 32768, function (index) {
  968.                         return compressed.charCodeAt(index);
  969.                     });
  970.                 },
  971.                 _decompress: function (length, resetValue, getNextValue) {
  972.                     var dictionary = [],
  973.                         next,
  974.                         enlargeIn = 4,
  975.                         dictSize = 4,
  976.                         numBits = 3,
  977.                         entry = "",
  978.                         result = [],
  979.                         i,
  980.                         w,
  981.                         bits, resb, maxpower, power,
  982.                         c,
  983.                         data = {
  984.                             val: getNextValue(0),
  985.                             position: resetValue,
  986.                             index: 1
  987.                         };
  988.                     for (i = 0; i < 3; i += 1) {
  989.                         dictionary[i] = i;
  990.                     }
  991.                     bits = 0;
  992.                     maxpower = Math.pow(2, 2);
  993.                     power = 1;
  994.                     while (power !== maxpower) {
  995.                         resb = data.val & data.position;
  996.                         data.position >>= 1;
  997.                         if (data.position === 0) {
  998.                             data.position = resetValue;
  999.                             data.val = getNextValue(data.index++);
  1000.                         }
  1001.                         bits |= (resb > 0 ? 1 : 0) * power;
  1002.                         power <<= 1;
  1003.                     }
  1004.                     switch (next = bits) {
  1005.                         case 0:
  1006.                             bits = 0;
  1007.                             maxpower = Math.pow(2, 8);
  1008.                             power = 1;
  1009.                             while (power !== maxpower) {
  1010.                                 resb = data.val & data.position;
  1011.                                 data.position >>= 1;
  1012.                                 if (data.position === 0) {
  1013.                                     data.position = resetValue;
  1014.                                     data.val = getNextValue(data.index++);
  1015.                                 }
  1016.                                 bits |= (resb > 0 ? 1 : 0) * power;
  1017.                                 power <<= 1;
  1018.                             }
  1019.                             c = f(bits);
  1020.                             break;
  1021.                         case 1:
  1022.                             bits = 0;
  1023.                             maxpower = Math.pow(2, 16);
  1024.                             power = 1;
  1025.                             while (power !== maxpower) {
  1026.                                 resb = data.val & data.position;
  1027.                                 data.position >>= 1;
  1028.                                 if (data.position === 0) {
  1029.                                     data.position = resetValue;
  1030.                                     data.val = getNextValue(data.index++);
  1031.                                 }
  1032.                                 bits |= (resb > 0 ? 1 : 0) * power;
  1033.                                 power <<= 1;
  1034.                             }
  1035.                             c = f(bits);
  1036.                             break;
  1037.                         case 2:
  1038.                             return "";
  1039.                     }
  1040.                     dictionary[3] = c;
  1041.                     w = c;
  1042.                     result.push(c);
  1043.                     while (true) {
  1044.                         if (data.index > length) {
  1045.                             return "";
  1046.                         }
  1047.                         bits = 0;
  1048.                         maxpower = Math.pow(2, numBits);
  1049.                         power = 1;
  1050.                         while (power !== maxpower) {
  1051.                             resb = data.val & data.position;
  1052.                             data.position >>= 1;
  1053.                             if (data.position === 0) {
  1054.                                 data.position = resetValue;
  1055.                                 data.val = getNextValue(data.index++);
  1056.                             }
  1057.                             bits |= (resb > 0 ? 1 : 0) * power;
  1058.                             power <<= 1;
  1059.                         }
  1060.                         switch (c = bits) {
  1061.                             case 0:
  1062.                                 bits = 0;
  1063.                                 maxpower = Math.pow(2, 8);
  1064.                                 power = 1;
  1065.                                 while (power !== maxpower) {
  1066.                                     resb = data.val & data.position;
  1067.                                     data.position >>= 1;
  1068.                                     if (data.position === 0) {
  1069.                                         data.position = resetValue;
  1070.                                         data.val = getNextValue(data.index++);
  1071.                                     }
  1072.                                     bits |= (resb > 0 ? 1 : 0) * power;
  1073.                                     power <<= 1;
  1074.                                 }
  1075.                                 dictionary[dictSize++] = f(bits);
  1076.                                 c = dictSize - 1;
  1077.                                 enlargeIn--;
  1078.                                 break;
  1079.                             case 1:
  1080.                                 bits = 0;
  1081.                                 maxpower = Math.pow(2, 16);
  1082.                                 power = 1;
  1083.                                 while (power !== maxpower) {
  1084.                                     resb = data.val & data.position;
  1085.                                     data.position >>= 1;
  1086.                                     if (data.position === 0) {
  1087.                                         data.position = resetValue;
  1088.                                         data.val = getNextValue(data.index++);
  1089.                                     }
  1090.                                     bits |= (resb > 0 ? 1 : 0) * power;
  1091.                                     power <<= 1;
  1092.                                 }
  1093.                                 dictionary[dictSize++] = f(bits);
  1094.                                 c = dictSize - 1;
  1095.                                 enlargeIn--;
  1096.                                 break;
  1097.                             case 2:
  1098.                                 return result.join('');
  1099.                         }
  1100.                         if (enlargeIn === 0) {
  1101.                             enlargeIn = Math.pow(2, numBits);
  1102.                             numBits++;
  1103.                         }
  1104.                         if (dictionary[c]) {
  1105.                             entry = dictionary[c];
  1106.                         } else {
  1107.                             if (c === dictSize) {
  1108.                                 entry = w + w.charAt(0);
  1109.                             } else {
  1110.                                 return null;
  1111.                             }
  1112.                         }
  1113.                         result.push(entry);
  1114.                         // Add w+entry[0] to the dictionary.
  1115.                         dictionary[dictSize++] = w + entry.charAt(0);
  1116.                         enlargeIn--;
  1117.                         w = entry;
  1118.                         if (enlargeIn === 0) {
  1119.                             enlargeIn = Math.pow(2, numBits);
  1120.                             numBits++;
  1121.                         }
  1122.                     }
  1123.                 }
  1124.             };
  1125.             return LZString;
  1126.         })();
  1127.     }
  1128. }