☰

Link Enhancer

Adds some extra WME functionality related to Google place links.

بۇ قوليازمىنى بىۋاسىتە قاچىلاشقا بولمايدۇ. بۇ باشقا قوليازمىلارنىڭ ئىشلىتىشى ئۈچۈن تەمىنلەنگەن ئامبار بولۇپ، ئىشلىتىش ئۈچۈن مېتا كۆرسەتمىسىگە قىستۇرىدىغان كود: // @require https://update.greatest.deepsurf.us/scripts/523706/1569240/Link%20Enhancer.js 

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